refactor(skills): retire unused removal service and test concrete owners (#39902)

This commit is contained in:
Neil
2026-11-08 09:19:54 -08:00
committed by GitHub
parent 492ccce634
commit cd546dc3d0
6 changed files with 170 additions and 214 deletions
@@ -6,7 +6,7 @@ import { promisify } from 'node:util'
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
import type { SkillInstallFilesystem } from '../filesystem/skill-install-filesystem'
import { installSharedSkill } from './skill-installation'
import { removeSharedSkill } from '../managed-remove/skill-managed-removal'
import { removeLocalSharedSkill } from '../managed-remove/skill-remove-transaction'
import { createSkillPackageArchive } from '../package-archive/skill-package-creation'
import { createWslSkillInstallFilesystem } from '../filesystem/skill-wsl-install-filesystem'
@@ -136,17 +136,15 @@ describe.runIf(RUN_REAL_WSL)('real WSL skill install transactions', () => {
const removeInput = {
operationId: 'remove-global',
skillName: 'real-wsl-skill',
scope: 'global' as const,
homeDirectory,
orcaStateDirectory: join(localRoot, 'state-global'),
detectedProviders: ['codex', 'claude'],
canonicalPath: join(homeDirectory, '.agents', 'skills', 'real-wsl-skill'),
stateDirectory: join(localRoot, 'state-global', 'skill-installs'),
allowedProviderRoots: [join(homeDirectory, '.claude', 'skills')],
filesystem
}
expect((await removeSharedSkill(removeInput)).conflict?.kind).toBe('modified')
expect((await removeLocalSharedSkill(removeInput)).conflict?.kind).toBe('modified')
expect(
(
await removeSharedSkill({
await removeLocalSharedSkill({
...removeInput,
conflictResolution: 'replace-and-discard-local'
})
@@ -175,14 +173,11 @@ describe.runIf(RUN_REAL_WSL)('real WSL skill install transactions', () => {
).toContain('# Workspace')
expect(
(
await removeSharedSkill({
await removeLocalSharedSkill({
operationId: 'remove-workspace',
skillName: 'real-wsl-skill',
scope: 'workspace',
homeDirectory,
workspaceDirectory,
orcaStateDirectory: join(localRoot, 'state-workspace'),
detectedProviders: ['codex', 'claude'],
canonicalPath: join(workspaceDirectory, '.agents', 'skills', 'real-wsl-skill'),
stateDirectory: join(localRoot, 'state-workspace', 'skill-installs'),
allowedProviderRoots: [join(workspaceDirectory, '.claude', 'skills')],
filesystem
})
).status
@@ -213,14 +208,11 @@ describe.runIf(RUN_REAL_WSL)('real WSL skill install transactions', () => {
).toContain('# DrvFS workspace')
expect(
(
await removeSharedSkill({
await removeLocalSharedSkill({
operationId: 'remove-drvfs',
skillName: 'real-wsl-skill',
scope: 'workspace',
homeDirectory,
workspaceDirectory: windowsWorkspace,
orcaStateDirectory: join(localRoot, 'state-drvfs'),
detectedProviders: ['codex', 'claude'],
canonicalPath: join(windowsWorkspace, '.agents', 'skills', 'real-wsl-skill'),
stateDirectory: join(localRoot, 'state-drvfs', 'skill-installs'),
allowedProviderRoots: [join(windowsWorkspace, '.claude', 'skills')],
filesystem
})
).status
@@ -1,16 +1,18 @@
import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
import { mkdir, mkdtemp, realpath, rm, writeFile } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { createSkillPackageArchive } from '../../package-archive/skill-package-creation'
import type { SkillInstallServiceInput } from '../skill-installation'
import type { ManagementDependencies } from '../skill-install-preview'
const temporaryDirectories: string[] = []
export async function createSkillInstallHome(): Promise<{
root: string
input: SkillInstallServiceInput
managementDependencies: ManagementDependencies
}> {
const root = await mkdtemp(join(tmpdir(), 'orca-skill-service-test-'))
const root = await realpath(await mkdtemp(join(tmpdir(), 'orca-skill-service-test-')))
temporaryDirectories.push(root)
const source = join(root, 'source')
await mkdir(source)
@@ -39,6 +41,16 @@ export async function createSkillInstallHome(): Promise<{
expectedPackageDigest: archive.manifest.packageDigest,
expectedPackageId: archive.manifest.packageId,
expectedVersionId: archive.manifest.versionId
},
managementDependencies: {
authority: {
environmentId: 'test-host',
homeDirectory: join(root, 'home'),
resolveWorktree: async () => null,
resolveFolderWorkspace: async () => null
},
stateDirectory: join(root, 'orca-state'),
detectProviders: async () => []
}
}
}
@@ -1,140 +0,0 @@
import {
createSkillInstallHome,
removeSkillInstallHomes
} from '../install/testing/skill-install-home'
import { cp, lstat, mkdir, readFile, realpath, rm, writeFile } from 'node:fs/promises'
import { join } from 'node:path'
import { afterEach, describe, expect, it } from 'vitest'
import { installSharedSkill } from '../install/skill-installation'
import { removeSharedSkill } from './skill-managed-removal'
import { nativeSkillInstallFilesystem } from '../filesystem/skill-install-filesystem'
afterEach(removeSkillInstallHomes)
describe('managed skill removal', () => {
it('never removes a byte-identical provider copy that was recorded as unowned', async () => {
const { root, input } = await createSkillInstallHome()
const sourceSkill = join(root, 'source')
const claude = join(root, 'home', '.claude', 'skills', 'test-skill')
await mkdir(join(root, 'home', '.claude', 'skills'), { recursive: true })
await cp(sourceSkill, claude, { recursive: true })
const installed = await installSharedSkill(input)
expect(installed.placements).toContainEqual(
expect.objectContaining({ provider: 'claude', status: 'skipped' })
)
const removed = await removeSharedSkill({
operationId: 'remove_identical_unowned',
skillName: 'test-skill',
scope: 'global',
homeDirectory: input.homeDirectory,
orcaStateDirectory: input.orcaStateDirectory,
detectedProviders: input.detectedProviders
})
expect(removed.status).toBe('partial')
expect(await readFile(join(claude, 'SKILL.md'), 'utf8')).toContain('# Test')
})
it('removes owned placements even after the provider is no longer detected', async () => {
const { root, input } = await createSkillInstallHome()
await installSharedSkill(input)
const result = await removeSharedSkill({
operationId: 'remove_1',
skillName: 'test-skill',
scope: 'global',
homeDirectory: input.homeDirectory,
orcaStateDirectory: input.orcaStateDirectory,
detectedProviders: []
})
expect(result.status).toBe('removed')
await expect(
lstat(join(root, 'home', '.agents', 'skills', 'test-skill'))
).rejects.toMatchObject({
code: 'ENOENT'
})
await expect(
lstat(join(root, 'home', '.claude', 'skills', 'test-skill'))
).rejects.toMatchObject({
code: 'ENOENT'
})
})
it('preserves modified canonical and provider content during removal', async () => {
const { root, input } = await createSkillInstallHome()
await installSharedSkill(input)
const canonical = join(root, 'home', '.agents', 'skills', 'test-skill')
const claude = join(root, 'home', '.claude', 'skills', 'test-skill')
await writeFile(join(canonical, 'local.md'), 'keep canonical')
const conflict = await removeSharedSkill({
operationId: 'remove_1',
skillName: 'test-skill',
scope: 'global',
homeDirectory: input.homeDirectory,
orcaStateDirectory: input.orcaStateDirectory,
detectedProviders: input.detectedProviders
})
expect(conflict.conflict?.kind).toBe('modified')
expect(await readFile(join(canonical, 'local.md'), 'utf8')).toBe('keep canonical')
await rm(claude, { force: true })
await mkdir(claude)
await writeFile(join(claude, 'local.md'), 'keep provider')
const removed = await removeSharedSkill({
operationId: 'remove_2',
skillName: 'test-skill',
scope: 'global',
homeDirectory: input.homeDirectory,
orcaStateDirectory: input.orcaStateDirectory,
detectedProviders: input.detectedProviders,
conflictResolution: 'replace-and-discard-local'
})
expect(removed.status).toBe('partial')
expect(await readFile(join(claude, 'local.md'), 'utf8')).toBe('keep provider')
})
it('restores moved placements when removal is interrupted', async () => {
const { root, input } = await createSkillInstallHome()
await installSharedSkill(input)
const canonical = join(root, 'home', '.agents', 'skills', 'test-skill')
const claude = join(root, 'home', '.claude', 'skills', 'test-skill')
let renameCount = 0
const interruptedFilesystem = {
...nativeSkillInstallFilesystem,
rename: async (source: string, target: string): Promise<void> => {
renameCount += 1
if (renameCount === 2) {
throw new Error('injected-removal-interruption')
}
await nativeSkillInstallFilesystem.rename(source, target)
}
}
await expect(
removeSharedSkill({
operationId: 'remove_interrupted',
skillName: 'test-skill',
scope: 'global',
homeDirectory: input.homeDirectory,
orcaStateDirectory: input.orcaStateDirectory,
detectedProviders: input.detectedProviders,
filesystem: interruptedFilesystem
})
).rejects.toThrow('injected-removal-interruption')
expect(await realpath(claude)).toBe(await realpath(canonical))
const retried = await removeSharedSkill({
operationId: 'remove_retried',
skillName: 'test-skill',
scope: 'global',
homeDirectory: input.homeDirectory,
orcaStateDirectory: input.orcaStateDirectory,
detectedProviders: input.detectedProviders
})
expect(retried.status).toBe('removed')
})
})
@@ -1,48 +0,0 @@
import { join } from 'node:path'
import type { SkillInstallResult } from '../../../shared/skill-install-contract'
import { SKILL_INSTALL_PROVIDERS } from '../../../shared/skill-install-providers'
import {
resolveSkillProviderDestinations,
type SkillProviderRootOverrides
} from '../providers/skill-provider-destinations'
import type { SkillInstallFilesystem } from '../filesystem/skill-install-filesystem'
import { canonicalRoot } from '../install/skill-install-paths'
import { removeLocalSharedSkill } from './skill-remove-transaction'
export type SkillRemoveServiceInput = {
operationId: string
skillName: string
scope: 'global' | 'workspace'
homeDirectory: string
workspaceDirectory?: string
orcaStateDirectory: string
detectedProviders: readonly string[]
providerRootOverrides?: SkillProviderRootOverrides
conflictResolution?: 'replace-and-discard-local' | 'cancel'
filesystem?: SkillInstallFilesystem
}
export async function removeSharedSkill(
input: SkillRemoveServiceInput
): Promise<SkillInstallResult> {
if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(input.skillName)) {
throw new Error('skill-install-name-invalid')
}
const providerDestinations = resolveSkillProviderDestinations({
scope: input.scope,
homeDirectory: input.homeDirectory,
workspaceDirectory: input.workspaceDirectory,
detectedProviders: SKILL_INSTALL_PROVIDERS.map((provider) => provider.id),
providerRootOverrides: input.providerRootOverrides
})
return removeLocalSharedSkill({
operationId: input.operationId,
canonicalPath: join(canonicalRoot(input), input.skillName),
stateDirectory: join(input.orcaStateDirectory, 'skill-installs'),
allowedProviderRoots: providerDestinations
.filter((destination) => !destination.readsCanonicalRoot)
.map((destination) => destination.rootPath),
conflictResolution: input.conflictResolution,
filesystem: input.filesystem
})
}
@@ -1,8 +1,13 @@
import {
createSkillInstallHome,
removeSkillInstallHomes
} from '../install/testing/skill-install-home'
import { installSharedSkill } from '../install/skill-installation'
import {
createSkillManagementHome,
removeSkillManagementHomes
} from '../install/testing/skill-management-home'
import { mkdir } from 'node:fs/promises'
import { cp, lstat, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
import { join } from 'node:path'
import { afterEach, beforeEach, describe, expect, it } from 'vitest'
@@ -35,3 +40,82 @@ describe('managed skill removal request', () => {
expect(result).toMatchObject({ status: 'conflict', conflict: { kind: 'unowned' } })
})
})
describe('managed skill removal ownership', () => {
afterEach(removeSkillInstallHomes)
it('never removes a byte-identical provider copy that was recorded as unowned', async () => {
const { root, input, managementDependencies } = await createSkillInstallHome()
const sourceSkill = join(root, 'source')
const claude = join(root, 'home', '.claude', 'skills', 'test-skill')
await mkdir(join(root, 'home', '.claude', 'skills'), { recursive: true })
await cp(sourceSkill, claude, { recursive: true })
const installed = await installSharedSkill(input)
expect(installed.placements).toContainEqual(
expect.objectContaining({ provider: 'claude', status: 'skipped' })
)
const removed = await removeSharedSkillInstall(
{
operationId: 'remove_identical_unowned',
name: 'test-skill',
destination: { scope: 'global' }
},
managementDependencies
)
expect(removed.status).toBe('partial')
expect(await readFile(join(claude, 'SKILL.md'), 'utf8')).toContain('# Test')
})
it('removes owned placements even after the provider is no longer detected', async () => {
const { root, input, managementDependencies } = await createSkillInstallHome()
await installSharedSkill(input)
const result = await removeSharedSkillInstall(
{ operationId: 'remove_1', name: 'test-skill', destination: { scope: 'global' } },
managementDependencies
)
expect(result.status).toBe('removed')
await expect(
lstat(join(root, 'home', '.agents', 'skills', 'test-skill'))
).rejects.toMatchObject({
code: 'ENOENT'
})
await expect(
lstat(join(root, 'home', '.claude', 'skills', 'test-skill'))
).rejects.toMatchObject({
code: 'ENOENT'
})
})
it('preserves modified canonical and provider content during removal', async () => {
const { root, input, managementDependencies } = await createSkillInstallHome()
await installSharedSkill(input)
const canonical = join(root, 'home', '.agents', 'skills', 'test-skill')
const claude = join(root, 'home', '.claude', 'skills', 'test-skill')
await writeFile(join(canonical, 'local.md'), 'keep canonical')
const conflict = await removeSharedSkillInstall(
{ operationId: 'remove_1', name: 'test-skill', destination: { scope: 'global' } },
managementDependencies
)
expect(conflict.conflict?.kind).toBe('modified')
expect(await readFile(join(canonical, 'local.md'), 'utf8')).toBe('keep canonical')
await rm(claude, { force: true })
await mkdir(claude)
await writeFile(join(claude, 'local.md'), 'keep provider')
const removed = await removeSharedSkillInstall(
{
operationId: 'remove_2',
name: 'test-skill',
destination: { scope: 'global' },
conflictResolution: 'replace-and-discard-local'
},
managementDependencies
)
expect(removed.status).toBe('partial')
expect(await readFile(join(claude, 'local.md'), 'utf8')).toBe('keep provider')
})
})
@@ -1,4 +1,20 @@
import { cp, lstat, mkdir, mkdtemp, readFile, rename, rm, writeFile } from 'node:fs/promises'
import {
createSkillInstallHome,
removeSkillInstallHomes
} from '../install/testing/skill-install-home'
import { installSharedSkill } from '../install/skill-installation'
import { nativeSkillInstallFilesystem } from '../filesystem/skill-install-filesystem'
import {
cp,
lstat,
mkdir,
mkdtemp,
readFile,
realpath,
rename,
rm,
writeFile
} from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { basename, dirname, join } from 'node:path'
import { afterEach, describe, expect, it } from 'vitest'
@@ -184,3 +200,43 @@ describe('skill removal recovery', () => {
await expect(lstat(oldPlacementPath)).rejects.toMatchObject({ code: 'ENOENT' })
})
})
describe('skill removal interruption', () => {
afterEach(removeSkillInstallHomes)
it('restores moved placements when removal is interrupted', async () => {
const { root, input } = await createSkillInstallHome()
await installSharedSkill(input)
const canonical = join(root, 'home', '.agents', 'skills', 'test-skill')
const claude = join(root, 'home', '.claude', 'skills', 'test-skill')
let renameCount = 0
const interruptedFilesystem = {
...nativeSkillInstallFilesystem,
rename: async (source: string, target: string): Promise<void> => {
renameCount += 1
if (renameCount === 2) {
throw new Error('injected-removal-interruption')
}
await nativeSkillInstallFilesystem.rename(source, target)
}
}
await expect(
removeLocalSharedSkill({
operationId: 'remove_interrupted',
canonicalPath: join(input.homeDirectory, '.agents', 'skills', 'test-skill'),
stateDirectory: join(input.orcaStateDirectory, 'skill-installs'),
allowedProviderRoots: [join(input.homeDirectory, '.claude', 'skills')],
filesystem: interruptedFilesystem
})
).rejects.toThrow('injected-removal-interruption')
expect(await realpath(claude)).toBe(await realpath(canonical))
const retried = await removeLocalSharedSkill({
operationId: 'remove_retried',
canonicalPath: join(input.homeDirectory, '.agents', 'skills', 'test-skill'),
stateDirectory: join(input.orcaStateDirectory, 'skill-installs'),
allowedProviderRoots: [join(input.homeDirectory, '.claude', 'skills')]
})
expect(retried.status).toBe('removed')
})
})