diff --git a/src/main/skills/install/skill-wsl-install-transaction.integration.test.ts b/src/main/skills/install/skill-wsl-install-transaction.integration.test.ts index 867e8cf5379..73a62b061b0 100644 --- a/src/main/skills/install/skill-wsl-install-transaction.integration.test.ts +++ b/src/main/skills/install/skill-wsl-install-transaction.integration.test.ts @@ -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 diff --git a/src/main/skills/install/testing/skill-install-home.ts b/src/main/skills/install/testing/skill-install-home.ts index 1d9e06ed9d9..23852e7f126 100644 --- a/src/main/skills/install/testing/skill-install-home.ts +++ b/src/main/skills/install/testing/skill-install-home.ts @@ -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 () => [] } } } diff --git a/src/main/skills/managed-remove/skill-managed-removal.test.ts b/src/main/skills/managed-remove/skill-managed-removal.test.ts deleted file mode 100644 index ddcd4622a81..00000000000 --- a/src/main/skills/managed-remove/skill-managed-removal.test.ts +++ /dev/null @@ -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 => { - 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') - }) -}) diff --git a/src/main/skills/managed-remove/skill-managed-removal.ts b/src/main/skills/managed-remove/skill-managed-removal.ts deleted file mode 100644 index 40c73f17137..00000000000 --- a/src/main/skills/managed-remove/skill-managed-removal.ts +++ /dev/null @@ -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 { - 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 - }) -} diff --git a/src/main/skills/managed-remove/skill-managed-remove-request.test.ts b/src/main/skills/managed-remove/skill-managed-remove-request.test.ts index 2b7b1a73d5a..9d6c4d6b02c 100644 --- a/src/main/skills/managed-remove/skill-managed-remove-request.test.ts +++ b/src/main/skills/managed-remove/skill-managed-remove-request.test.ts @@ -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') + }) +}) diff --git a/src/main/skills/managed-remove/skill-remove-transaction.test.ts b/src/main/skills/managed-remove/skill-remove-transaction.test.ts index 9c036440b96..8ad0081886b 100644 --- a/src/main/skills/managed-remove/skill-remove-transaction.test.ts +++ b/src/main/skills/managed-remove/skill-remove-transaction.test.ts @@ -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 => { + 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') + }) +})