skillhub/cli/test/unit/integrations/native-toggle.test.ts
XiaoSeS 6c276d38fc
Some checks are pending
Security / Dependency Review (push) Waiting to run
Security / CodeQL (java-kotlin) (push) Waiting to run
Security / CodeQL (javascript-typescript) (push) Waiting to run
Security / CodeQL (python) (push) Waiting to run
fix(dsh): preserve legacy compatibility and Windows lifecycle safety (#1033)
保持共享库存 v2 与旧版可读普通日志,从真实入口派生启停;隔离扩展日志并保护恢复时的合法后续写入。修复 Windows 库存/日志原子替换及目标锁的短时共享冲突,不删除原数据、不抢占活锁、不重放事务。

补充安全探针诊断与仅公共下载内容的 CI 缓存,Profile 和安装状态仍逐次隔离。准备 CLI 0.3.0 / DSH 0.6.0,npm 发布另行执行。

最终提交的 CLI 三平台、DSH 14 项矩阵及 12 份启停场景摘要均通过。Windows 新 RC 依赖准备仍接近限额,作为 CI 准备稳定性风险保留。

Signed-off-by: XiaoSeS <87064762+XiaoSeS@users.noreply.github.com>
2026-10-29 21:08:14 +08:00

318 lines
23 KiB
TypeScript

import { expect, test } from 'bun:test'
import { randomUUID } from 'node:crypto'
import { cp, mkdtemp, mkdir, readFile, realpath, rename, rm, writeFile } from 'node:fs/promises'
import { fileURLToPath } from 'node:url'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { InventoryStore } from '../../../src/stores/inventory-store'
import { snapshotSkillDirectory } from '../../../src/services/skill-fingerprint'
import { openNativeRuntime } from '../../../src/integrations/native-runtime'
import { OperationStore } from '../../../src/integrations/operation-store'
import { executeNativeToggle, inspectToggle } from '../../../src/integrations/native-toggle'
async function fixture() {
const home = await realpath(await mkdtemp(join(tmpdir(), 'skillhub-toggle-')))
const root = join(home, 'skills')
const path = join(root, 'writer')
await mkdir(join(path, '.skillhub'), { recursive: true })
await writeFile(join(path, 'SKILL.md'), '# Original\n')
await writeFile(join(path, 'resource.txt'), 'keep bytes')
const selected = { registry: 'https://registry.example', namespace: 'demo', slug: 'writer', version: '1.0.0' }
const snapshot = await snapshotSkillDirectory(path)
const target = { agent: 'dsh', rootDir: root, installDir: path, installedAt: '2026-10-27', version: selected.version, fingerprint: snapshot.fingerprint }
const inventory = new InventoryStore(home)
await inventory.writeAtomic({ items: [{ registry: selected.registry, namespace: selected.namespace, slug: selected.slug, targets: [target] }] })
await writeFile(join(path, '.skillhub/metadata.json'), JSON.stringify({ ...selected, ...snapshot, agent: 'dsh', installedAt: target.installedAt }))
const stateDirectory = join(home, 'operations')
const runtime = await openNativeRuntime({ inventoryHome: home, stateDirectory })
return { home, path, selected, inventory, runtime, stateDirectory, target: { root, scope: 'user' as const } }
}
test('offline toggles rename only entry, preserve bytes, reject stale plans, and uninstall disabled', async () => {
const f = await fixture()
try {
const metadata = await readFile(join(f.path, '.skillhub/metadata.json'))
for (const desired of ['disabled', 'enabled', 'disabled'] as const) {
const baseline = await f.runtime.inspectToggle(f.selected, f.target, desired)
if (baseline.status !== 'ready') throw new Error(JSON.stringify(baseline))
const operation = await f.runtime.acceptToggle({ hostInstanceId: f.runtime.hostInstanceId, ownerId: 'owner',
mode: 'new', requestKey: randomUUID(), parameters: { desired } }, async () => ({
namespace: f.selected.namespace, slug: f.selected.slug, version: f.selected.version, kind: desired === 'disabled' ? 'disable' : 'enable', targetLabel: 'User', targetPaths: [f.path],
context: { sourceIdentity: f.selected.registry, sourceLabel: 'Registry', sourceRevision: 'r1', hostLabel: 'Host', initiatedFrom: 'plaza' }
}))
const result = await f.runtime.executeToggle({ operationId: operation!.operationId, ownerId: 'owner', baseline, authorize: async () => {} })
expect(result.outcome).toBe('committed')
const disk = JSON.parse(await readFile(f.inventory.path, 'utf8'))
expect(disk.schemaVersion).toBe(2)
expect(disk.records[0].targets[0]).not.toHaveProperty('installationState')
expect((await f.runtime.getOperation(operation!.operationId, 'owner'))?.files).toBe(desired)
expect(await readFile(join(f.path, desired === 'disabled' ? 'SKILL.md.disabled' : 'SKILL.md'), 'utf8')).toBe('# Original\n')
expect(await readFile(join(f.path, '.skillhub/metadata.json'))).toEqual(metadata)
expect(await readFile(join(f.path, 'resource.txt'), 'utf8')).toBe('keep bytes')
expect((await f.runtime.listInstalled(f.selected.registry, [f.target])).items[0]?.installationState).toBe(desired)
expect((await f.runtime.inspectToggle(f.selected, f.target, desired)).status).toBe('unchanged')
}
const removal = await f.runtime.inspectRemoval(f.selected, f.target)
expect(removal.status).toBe('ready')
if (removal.status !== 'ready') return
const operation = await f.runtime.acceptRemoval({ hostInstanceId: f.runtime.hostInstanceId, ownerId: 'owner', mode: 'new', requestKey: randomUUID(), parameters: { remove: true } }, async () => ({
namespace: f.selected.namespace, slug: f.selected.slug, version: f.selected.version, kind: removal.kind, targetLabel: 'User', targetPaths: [f.path],
context: { sourceIdentity: f.selected.registry, sourceLabel: 'Registry', sourceRevision: 'r1', hostLabel: 'Host', initiatedFrom: 'plaza' }
}))
expect((await f.runtime.executeRemoval({ operationId: operation!.operationId, ownerId: 'owner', baseline: removal, authorize: async () => {} })).outcome).toBe('committed')
expect((await f.inventory.read()).items).toEqual([])
} finally { await rm(f.home, { recursive: true, force: true }) }
})
test.each(['modified', 'alias-collision', 'shared'] as const)('toggle blocks %s before a write', async mode => {
const f = await fixture()
try {
if (mode === 'modified') await writeFile(join(f.path, 'resource.txt'), 'changed')
if (mode === 'alias-collision') await writeFile(join(f.path, 'SKILL.md.disabled'), 'authored')
if (mode === 'shared') await f.inventory.mutateAtomic(value => { value.items[0]!.targets[0]!.installedBy = ['direct', 'suite:demo'] })
expect((await f.runtime.inspectToggle(f.selected, f.target, 'disabled')).status).toBe('blocked')
expect(await readFile(join(f.path, 'SKILL.md'), 'utf8')).toBe('# Original\n')
} finally { await rm(f.home, { recursive: true, force: true }) }
})
test.each(['cas-before', 'cas-after', 'intent', 'committed-log'] as const)('toggle reconciles failure at %s', async mode => {
const f = await fixture()
try {
const operations = await OperationStore.open(f.stateDirectory)
const baseline = await inspectToggle(f.inventory, f.selected, f.target, 'disabled')
if (baseline.status !== 'ready') throw new Error(JSON.stringify(baseline))
const accepted = await f.runtime.acceptToggle({ hostInstanceId: f.runtime.hostInstanceId, ownerId: 'owner', mode: 'new', requestKey: randomUUID(), parameters: { mode } }, async () => ({
namespace: f.selected.namespace, slug: f.selected.slug, version: f.selected.version, kind: 'disable', targetLabel: 'User', targetPaths: [f.path],
context: { sourceIdentity: f.selected.registry, sourceLabel: 'Registry', sourceRevision: 'r1', hostLabel: 'Host', initiatedFrom: 'plaza' }
}))
const append = operations.recordToggle.bind(operations)
let once = true
operations.recordToggle = async (...args) => {
if (once && (mode === 'intent' && args[3].stage === 'intent' || mode !== 'intent' && args[3].stage === 'committed')) {
once = false
if (mode === 'cas-after' || mode === 'committed-log') await append(...args)
throw new Error('Injected journal failure')
}
return append(...args)
}
const run = () => executeNativeToggle(operations, f.inventory, { operationId: accepted!.operationId, ownerId: 'owner', baseline, authorize: async () => {} })
if (mode === 'cas-after' || mode === 'committed-log') expect((await run()).outcome).toBe('committed')
else await expect(run()).rejects.toThrow('Injected')
const state = (await f.inventory.read()).items[0]!.targets[0]!.installationState
expect(state).toBe(mode === 'cas-after' || mode === 'committed-log' ? 'disabled' : 'enabled')
expect(await readFile(join(f.path, state === 'disabled' ? 'SKILL.md.disabled' : 'SKILL.md'), 'utf8')).toBe('# Original\n')
} finally { await rm(f.home, { recursive: true, force: true }) }
})
test.each([false, true])('restart recovers a renamed entry without overwriting a new occupant: conflict=%s', async conflict => {
const f = await fixture()
try {
const baseline = await f.runtime.inspectToggle(f.selected, f.target, 'disabled')
if (baseline.status !== 'ready') throw new Error(JSON.stringify(baseline))
const request = { hostInstanceId: f.runtime.hostInstanceId, ownerId: 'owner', mode: 'new' as const, requestKey: randomUUID(), parameters: { disable: true } }
const accepted = await f.runtime.acceptToggle(request, async () => ({
namespace: 'demo', slug: 'writer', version: '1.0.0', kind: 'disable', targetLabel: 'User', targetPaths: [f.path],
context: { sourceIdentity: f.selected.registry, sourceLabel: 'Registry', sourceRevision: 'r1', hostLabel: 'Host', initiatedFrom: 'plaza' }
}))
expect((await f.runtime.acceptToggle(request, async () => { throw new Error('Must replay') }))?.operationId).toBe(accepted!.operationId)
const operations = await OperationStore.open(f.stateDirectory)
const append = operations.recordToggle.bind(operations)
operations.recordToggle = async (...args) => {
if (args[3].stage === 'moved') throw new Error('Crash window after rename')
return append(...args)
}
await expect(executeNativeToggle(operations, f.inventory, { operationId: accepted!.operationId, ownerId: 'owner', baseline,
authorize: async (_paths, phase) => { if (phase === 'rollback') throw new Error('Recovery unavailable') } })).rejects.toThrow('Crash window')
expect((await f.inventory.read()).items[0]!.targets[0]!.installationState).toBe('disabled')
expect(await readFile(join(f.path, 'SKILL.md.disabled'), 'utf8')).toBe('# Original\n')
if (conflict) await writeFile(join(f.path, 'SKILL.md'), 'New occupant')
const restarted = await openNativeRuntime({ inventoryHome: f.home, stateDirectory: f.stateDirectory })
expect((await restarted.listPending()).map(record => record.operationId)).toContain(accepted!.operationId)
const result = await restarted.recover(accepted!.operationId, 'owner', [f.path], async () => {})
expect(result.outcome).toBe(conflict ? 'unknown' : 'restored')
expect(await readFile(join(f.path, 'SKILL.md'), 'utf8')).toBe(conflict ? 'New occupant' : '# Original\n')
if (conflict) expect(await readFile(join(f.path, 'SKILL.md.disabled'), 'utf8')).toBe('# Original\n')
} finally { await rm(f.home, { recursive: true, force: true }) }
})
test('killed toggle writers recover intent, renamed and committed boundaries', async () => {
const fixtures = await Promise.all(['intent', 'linked', 'moved', 'restore-linked', 'committed'].map(async boundary => {
const f = await fixture()
const accepted = await f.runtime.acceptToggle({ hostInstanceId: f.runtime.hostInstanceId, ownerId: 'owner', mode: 'new', requestKey: randomUUID(), parameters: { boundary } }, async () => ({
namespace: 'demo', slug: 'writer', version: '1.0.0', kind: 'disable', targetLabel: 'User', targetPaths: [f.path],
context: { sourceIdentity: f.selected.registry, sourceLabel: 'Registry', sourceRevision: 'r1', hostLabel: 'Host', initiatedFrom: 'plaza' }
}))
return { ...f, boundary, operationId: accepted!.operationId }
}))
try {
const crashes = await Promise.allSettled(fixtures.map(async f => {
const readyFile = join(f.home, 'crash-ready')
const child = Bun.spawn([process.execPath, fileURLToPath(new URL('../../fixtures/toggle-crash-child.ts', import.meta.url)), f.home, f.operationId, f.boundary, readyFile],
{ stdout: 'pipe', stderr: 'pipe' })
const waitForExit = async (exited: Promise<number>) => {
let timer: ReturnType<typeof setTimeout> | undefined
try {
return await Promise.race([exited, new Promise<never>((_, reject) => {
timer = setTimeout(() => reject(new Error('Owned crash process did not exit within 10 seconds')), 10000)
})])
} finally { clearTimeout(timer) }
}
const terminate = async () => {
if (child.exitCode !== null) return
if (process.platform === 'win32') {
const killer = Bun.spawn(['taskkill.exe', '/PID', String(child.pid), '/T', '/F'], { stdout: 'ignore', stderr: 'pipe' })
try { expect(await waitForExit(killer.exited)).toBe(0) } finally { if (killer.exitCode === null) killer.kill() }
} else child.kill('SIGKILL')
}
try {
const deadline = Date.now() + 20000
let ready = false
while (Date.now() < deadline && child.exitCode === null) {
try { ready = (await readFile(readyFile, 'utf8')) === f.boundary } catch (error) {
if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error
}
if (ready) break
await Bun.sleep(25)
}
expect(ready).toBe(true)
await terminate()
expect(await waitForExit(child.exited)).not.toBe(0)
expect(await new Response(child.stderr).text()).toBe('')
} finally {
// Cleanup uses only this child handle even if taskkill failed; it is not a passing crash assertion.
if (child.exitCode === null) child.kill()
await waitForExit(child.exited)
}
}))
const failures = crashes.filter((result): result is PromiseRejectedResult => result.status === 'rejected')
if (failures.length) throw new AggregateError(failures.map(result => result.reason), 'Crash fixtures failed after all owned children settled')
// Reverse-link recovery holds the inventory lease; its stale timeout is 30 seconds.
await Bun.sleep(31_500)
for (const f of fixtures) {
const restarted = await openNativeRuntime({ inventoryHome: f.home, stateDirectory: f.stateDirectory })
const result = await restarted.recover(f.operationId, 'owner', [f.path], async () => {})
expect(result.outcome).toBe(f.boundary === 'committed' ? 'committed' : 'restored')
const state = (await f.inventory.read()).items[0]!.targets[0]!.installationState
expect(state).toBe(f.boundary === 'committed' ? 'disabled' : 'enabled')
expect(await readFile(join(f.path, state === 'disabled' ? 'SKILL.md.disabled' : 'SKILL.md'), 'utf8')).toBe('# Original\n')
}
} finally { await Promise.all(fixtures.map(f => rm(f.home, { recursive: true, force: true }))) }
}, 90_000)
test.each(['forward', 'rollback'] as const)('exclusive entry creation preserves a competitor appearing after preflight: %s', async direction => {
const f = await fixture()
try {
const baseline = await f.runtime.inspectToggle(f.selected, f.target, 'disabled')
if (baseline.status !== 'ready') throw new Error(JSON.stringify(baseline))
const accepted = await f.runtime.acceptToggle({ hostInstanceId: f.runtime.hostInstanceId, ownerId: 'owner', mode: 'new', requestKey: randomUUID(), parameters: { direction } }, async () => ({
namespace: 'demo', slug: 'writer', version: '1.0.0', kind: 'disable', targetLabel: 'User', targetPaths: [f.path],
context: { sourceIdentity: f.selected.registry, sourceLabel: 'Registry', sourceRevision: 'r1', hostLabel: 'Host', initiatedFrom: 'plaza' }
}))
const operations = await OperationStore.open(f.stateDirectory)
const append = operations.recordToggle.bind(operations)
operations.recordToggle = async (...args) => {
const saved = await append(...args)
if (direction === 'forward' && args[3].stage === 'intent') await writeFile(args[3].to, 'Competing entry', { flag: 'wx' })
if (direction === 'rollback' && args[3].stage === 'restoring') await writeFile(args[3].from, 'Competing entry', { flag: 'wx' })
return saved
}
if (direction === 'rollback') {
const write = operations.recordToggle.bind(operations)
operations.recordToggle = async (...args) => { if (args[3].stage === 'committed') throw new Error('Commit denied'); return write(...args) }
}
await expect(executeNativeToggle(operations, f.inventory, { operationId: accepted!.operationId, ownerId: 'owner', baseline, authorize: async () => {} })).rejects.toThrow()
expect(await readFile(join(f.path, direction === 'forward' ? 'SKILL.md.disabled' : 'SKILL.md'), 'utf8')).toBe('Competing entry')
expect(await readFile(join(f.path, direction === 'forward' ? 'SKILL.md' : 'SKILL.md.disabled'), 'utf8')).toBe('# Original\n')
expect((await f.inventory.read()).items[0]!.targets[0]!.installationState).toBeUndefined()
expect((await f.runtime.getOperation(accepted!.operationId, 'owner'))?.phase).toBe('recovery-required')
} finally { await rm(f.home, { recursive: true, force: true }) }
})
test('independent toggle transactions preserve both targets in shared inventory', async () => {
const f = await fixture()
try {
const other = { scope: 'project' as const, root: join(f.home, 'project') }
const otherPath = join(other.root, 'writer')
await mkdir(other.root)
await cp(f.path, otherPath, { recursive: true })
await f.inventory.mutateAtomic(inventory => {
const item = inventory.items[0]!
item.targets.push({ ...item.targets[0]!, rootDir: other.root, installDir: otherPath })
})
const requests = await Promise.all([f.target, other].map(async target => {
const baseline = await f.runtime.inspectToggle(f.selected, target, 'disabled')
if (baseline.status !== 'ready') throw new Error(JSON.stringify(baseline))
const accepted = await f.runtime.acceptToggle({ hostInstanceId: f.runtime.hostInstanceId, ownerId: 'owner', mode: 'new', requestKey: randomUUID(), parameters: { scope: target.scope } }, async () => ({
namespace: 'demo', slug: 'writer', version: '1.0.0', kind: 'disable', targetLabel: target.scope, targetPaths: [baseline.target.path],
context: { sourceIdentity: f.selected.registry, sourceLabel: 'Registry', sourceRevision: 'r1', hostLabel: 'Host', initiatedFrom: 'plaza' }
}))
return { operationId: accepted!.operationId, ownerId: 'owner', baseline, authorize: async () => {} }
}))
const results = await Promise.allSettled(requests.map(request => f.runtime.executeToggle(request)))
const failures = results.filter(result => result.status === 'rejected')
if (failures.length) throw new AggregateError(failures.map(result => result.reason), 'Independent toggle transactions failed')
expect(results.map(result => result.status === 'fulfilled' ? result.value.outcome : undefined)).toEqual(['committed', 'committed'])
expect((await f.inventory.read()).items[0]!.targets.map(target => target.installationState)).toEqual(['disabled', 'disabled'])
} finally { await rm(f.home, { recursive: true, force: true }) }
})
test.each(['enabled', 'disabled'] as const)('existing v3 recovery respects persisted %s commit evidence', async storedState => {
const f = await fixture()
try {
const baseline = await f.runtime.inspectToggle(f.selected, f.target, 'disabled')
if (baseline.status !== 'ready') throw new Error('Missing baseline')
const accepted = await f.runtime.acceptToggle({ hostInstanceId: f.runtime.hostInstanceId, ownerId: 'owner', mode: 'new', requestKey: randomUUID(), parameters: { storedState } }, async () => ({
namespace: 'demo', slug: 'writer', version: '1.0.0', kind: 'disable', targetLabel: 'User', targetPaths: [f.path],
context: { sourceIdentity: f.selected.registry, sourceLabel: 'Registry', sourceRevision: 'r1', hostLabel: 'Host', initiatedFrom: 'plaza' }
}))
const operations = await OperationStore.open(f.stateDirectory)
const append = operations.recordToggle.bind(operations)
operations.recordToggle = async (...args) => {
const saved = await append(...args)
if (args[3].stage === 'moved') throw new Error('Lost legacy response')
return saved
}
await expect(executeNativeToggle(operations, f.inventory, { operationId: accepted!.operationId, ownerId: 'owner', baseline,
authorize: async (_paths, phase) => { if (phase === 'rollback') throw new Error('Recovery unavailable') } })).rejects.toThrow()
const inventory = await f.inventory.read()
inventory.items[0]!.targets[0]!.installationState = storedState
await writeFile(f.inventory.path, JSON.stringify({ schemaVersion: 3, records: inventory.items }))
const restarted = await openNativeRuntime({ inventoryHome: f.home, stateDirectory: f.stateDirectory })
expect((await restarted.recover(accepted!.operationId, 'owner', [f.path], async () => {})).outcome).toBe(storedState === 'disabled' ? 'committed' : 'restored')
expect((await f.inventory.read()).items[0]!.targets[0]!.installationState).toBe(storedState)
await f.inventory.ensureWritable()
expect(await f.inventory.diskVersion()).toBe(2)
} finally { await rm(f.home, { recursive: true, force: true }) }
})
test('recovery never overwrites a legitimate replacement after an interrupted enable', async () => {
const f = await fixture()
try {
await rename(join(f.path, 'SKILL.md'), join(f.path, 'SKILL.md.disabled'))
const baseline = await f.runtime.inspectToggle(f.selected, f.target, 'enabled')
if (baseline.status !== 'ready') throw new Error('Missing disabled baseline')
const accepted = await f.runtime.acceptToggle({ hostInstanceId: f.runtime.hostInstanceId, ownerId: 'owner', mode: 'new', requestKey: randomUUID(), parameters: { enable: true } }, async () => ({
namespace: 'demo', slug: 'writer', version: '1.0.0', kind: 'enable', targetLabel: 'User', targetPaths: [f.path],
context: { sourceIdentity: f.selected.registry, sourceLabel: 'Registry', sourceRevision: 'r1', hostLabel: 'Host', initiatedFrom: 'plaza' }
}))
const operations = await OperationStore.open(f.stateDirectory)
const append = operations.recordToggle.bind(operations)
operations.recordToggle = async (...args) => {
const saved = await append(...args)
if (args[3].stage === 'moved') throw new Error('Interrupted enable')
return saved
}
await expect(executeNativeToggle(operations, f.inventory, { operationId: accepted!.operationId, ownerId: 'owner', baseline,
authorize: async (_paths, phase) => { if (phase === 'rollback') throw new Error('Recovery unavailable') } })).rejects.toThrow()
await writeFile(join(f.path, 'SKILL.md'), '# Legitimate replacement\n')
const snapshot = await snapshotSkillDirectory(f.path)
const target = { ...baseline.inventoryItem.targets[0]!, version: '2.0.0', installedAt: '2026-10-29', fingerprint: snapshot.fingerprint, installationState: 'enabled' as const }
await writeFile(join(f.path, '.skillhub/metadata.json'), JSON.stringify({ ...f.selected, version: target.version, ...snapshot, agent: 'dsh', installedAt: target.installedAt }))
await f.inventory.writeAtomic({ items: [{ ...baseline.inventoryItem, targets: [target] }] })
const paths = [f.inventory.path, join(f.path, 'SKILL.md'), join(f.path, '.skillhub/metadata.json'), join(f.path, 'resource.txt')]
const before = await Promise.all(paths.map(path => readFile(path)))
const restarted = await openNativeRuntime({ inventoryHome: f.home, stateDirectory: f.stateDirectory })
expect((await restarted.recover(accepted!.operationId, 'owner', [f.path], async () => {})).outcome).toBe('unknown')
expect(await Promise.all(paths.map(path => readFile(path)))).toEqual(before)
} finally { await rm(f.home, { recursive: true, force: true }) }
})