mirror of
https://github.com/iflytek/skillhub.git
synced 2026-11-18 09:41:56 +00:00
Some checks failed
Deploy Docs / build (push) Has been cancelled
Security / Dependency Review (push) Has been cancelled
Security / CodeQL (java-kotlin) (push) Has been cancelled
Security / CodeQL (javascript-typescript) (push) Has been cancelled
Security / CodeQL (python) (push) Has been cancelled
Deploy Docs / Deploy (push) Has been cancelled
Add the native SkillHub plugin for DeepSeek Harness with a scoped skill center, conversation search/install tools, exact-version installation and protected lifecycle management. Prepare the independently versioned 0.1.0 npm candidate with an empty default Registry and documented compatibility limits. Keep formal specifications and executable regression tests; remove archived development screenshots and runtime reports from the final tree. Review fixes cover independent scopes, installed references, pre-staging recovery and idempotent discovery. Signed-off-by: XiaoSeS <87064762+XiaoSeS@users.noreply.github.com>
238 lines
10 KiB
TypeScript
238 lines
10 KiB
TypeScript
import { access, chmod, lstat, mkdir, mkdtemp, readdir, rm, symlink, unlink, utimes, writeFile } from 'node:fs/promises'
|
|
import { tmpdir } from 'node:os'
|
|
import { dirname, join } from 'node:path'
|
|
import { fileURLToPath } from 'node:url'
|
|
import { describe, expect, test } from 'bun:test'
|
|
import {
|
|
acquireSkillTargetLock,
|
|
assertPrivateLockDir,
|
|
ensurePrivateLockDir,
|
|
skillTargetLockPath,
|
|
orderSkillTargetLocks
|
|
} from '../../../src/services/skill-target-lock'
|
|
|
|
async function exists(path: string): Promise<boolean> {
|
|
try {
|
|
await access(path)
|
|
return true
|
|
} catch {
|
|
return false
|
|
}
|
|
}
|
|
|
|
async function waitForFile(path: string): Promise<void> {
|
|
for (let attempt = 0; attempt < 500; attempt++) {
|
|
if (await exists(path)) return
|
|
await Bun.sleep(10)
|
|
}
|
|
throw new Error(`timed out waiting for ${path}`)
|
|
}
|
|
|
|
async function waitForExitCount(
|
|
processes: Array<{ exited: Promise<number> }>,
|
|
count: number
|
|
): Promise<number[]> {
|
|
const exitCodes: number[] = []
|
|
for (const process of processes) {
|
|
void process.exited.then(exitCode => exitCodes.push(exitCode))
|
|
}
|
|
for (let attempt = 0; attempt < 500; attempt++) {
|
|
if (exitCodes.length >= count) return exitCodes
|
|
await Bun.sleep(10)
|
|
}
|
|
throw new Error(`timed out waiting for ${count} lock contenders to exit`)
|
|
}
|
|
|
|
describe('skill target lifecycle lock', () => {
|
|
test('orders canonical targets identically through aliases and deduplicates the same lock', async () => {
|
|
const root = await mkdtemp(join(tmpdir(), 'skillhub-lock-order-'))
|
|
try {
|
|
const first = join(root, 'first')
|
|
const second = join(root, 'second')
|
|
const alias = join(root, 'alias')
|
|
await mkdir(first)
|
|
await mkdir(second)
|
|
await symlink(first, alias, 'dir')
|
|
const original = await orderSkillTargetLocks([{ rootDir: second }, { rootDir: first }], 'writer')
|
|
const reversedAliases = await orderSkillTargetLocks([{ rootDir: alias }, { rootDir: second }, { rootDir: first }], 'writer')
|
|
expect(reversedAliases).toHaveLength(2)
|
|
const keys = (targets: Array<{ rootDir: string }>) => Promise.all(targets.map(target => skillTargetLockPath(target.rootDir, 'writer')))
|
|
expect(await keys(reversedAliases)).toEqual(await keys(original))
|
|
expect(await keys(original)).toEqual((await keys(original)).sort())
|
|
} finally {
|
|
await rm(root, { recursive: true, force: true })
|
|
}
|
|
})
|
|
|
|
test('creates or repairs a private lock root and rejects unsafe roots', async () => {
|
|
const parent = await mkdtemp(join(tmpdir(), 'skillhub-lock-root-'))
|
|
const privateRoot = join(parent, 'private')
|
|
await ensurePrivateLockDir(privateRoot)
|
|
if (process.platform !== 'win32') {
|
|
expect((await lstat(privateRoot)).mode & 0o077).toBe(0)
|
|
await chmod(privateRoot, 0o755)
|
|
await ensurePrivateLockDir(privateRoot)
|
|
expect((await lstat(privateRoot)).mode & 0o077).toBe(0)
|
|
}
|
|
|
|
const fileRoot = join(parent, 'file')
|
|
await writeFile(fileRoot, 'keep')
|
|
await expect(ensurePrivateLockDir(fileRoot)).rejects.toThrow('unsafe SkillHub CLI lock directory')
|
|
expect(await Bun.file(fileRoot).text()).toBe('keep')
|
|
|
|
const symlinkTarget = join(parent, 'symlink-target')
|
|
const symlinkRoot = join(parent, 'symlink')
|
|
await mkdir(symlinkTarget)
|
|
await symlink(symlinkTarget, symlinkRoot, 'dir')
|
|
await expect(ensurePrivateLockDir(symlinkRoot)).rejects.toThrow('unsafe SkillHub CLI lock directory')
|
|
expect((await lstat(symlinkRoot)).isSymbolicLink()).toBe(true)
|
|
|
|
expect(() => assertPrivateLockDir('/foreign', {
|
|
isDirectory: () => true,
|
|
isSymbolicLink: () => false,
|
|
uid: 2000,
|
|
mode: 0o40700
|
|
}, 1000)).toThrow('owned by another user')
|
|
})
|
|
|
|
test('simultaneous stale recovery admits exactly one owner across processes', async () => {
|
|
const rootDir = await mkdtemp(join(tmpdir(), 'skillhub-target-lock-root-'))
|
|
const lockPath = await skillTargetLockPath(rootDir, 'demo')
|
|
await mkdir(lockPath)
|
|
const staleTime = new Date(Date.now() - 60_000)
|
|
await utimes(lockPath, staleTime, staleTime)
|
|
const acquisitionGatePath = `${lockPath}.acquire`
|
|
const worker = fileURLToPath(new URL('../../helpers/target-lock-worker.ts', import.meta.url))
|
|
const bunPath = (await Bun.which('bun')) ?? process.execPath
|
|
const acquiredPath = join(rootDir, 'acquired')
|
|
const releasePath = join(rootDir, 'release')
|
|
const startPath = join(rootDir, 'start')
|
|
const workerCount = 8
|
|
const readyPaths = Array.from({ length: workerCount }, (_, index) => join(rootDir, `ready-${index}`))
|
|
|
|
const processes = readyPaths.map(readyPath => Bun.spawn({
|
|
cmd: [bunPath, worker, rootDir, 'demo', readyPath, startPath, acquiredPath, releasePath],
|
|
stdout: 'pipe',
|
|
stderr: 'pipe'
|
|
}))
|
|
try {
|
|
await Promise.all(readyPaths.map(waitForFile))
|
|
await writeFile(startPath, 'start')
|
|
await waitForFile(acquiredPath)
|
|
const loserExitCodes = await waitForExitCount(processes, workerCount - 1)
|
|
expect(loserExitCodes).toEqual(Array(workerCount - 1).fill(4))
|
|
} finally {
|
|
try {
|
|
await writeFile(releasePath, 'release')
|
|
} finally {
|
|
const exited = await Promise.race([
|
|
Promise.all(processes.map(process => process.exited)).then(() => true),
|
|
Bun.sleep(5_000).then(() => false)
|
|
])
|
|
if (!exited) {
|
|
for (const process of processes) process.kill()
|
|
await Promise.all(processes.map(process => process.exited))
|
|
}
|
|
}
|
|
}
|
|
const results = await Promise.all(processes.map(async process => ({
|
|
exitCode: await process.exited,
|
|
stdout: (await new Response(process.stdout).text()).trim(),
|
|
stderr: (await new Response(process.stderr).text()).trim()
|
|
})))
|
|
|
|
expect(results.map(result => result.exitCode).sort()).toEqual([0, ...Array(workerCount - 1).fill(4)])
|
|
expect(results.filter(result => result.stdout === 'acquired')).toHaveLength(1)
|
|
for (const loser of results.filter(result => result.exitCode === 4)) {
|
|
expect(loser.stderr).toContain('install target is busy')
|
|
}
|
|
expect(await exists(lockPath)).toBe(false)
|
|
expect(await readdir(acquisitionGatePath)).toEqual([])
|
|
const releaseAfterContention = await acquireSkillTargetLock(rootDir, 'demo')
|
|
await releaseAfterContention()
|
|
if (process.platform !== 'win32') {
|
|
expect((await lstat(dirname(lockPath))).mode & 0o077).toBe(0)
|
|
}
|
|
}, 15_000)
|
|
|
|
test('does not recover a live acquisition contender solely because its file is old', async () => {
|
|
const rootDir = await mkdtemp(join(tmpdir(), 'skillhub-target-live-gate-'))
|
|
const lockPath = await skillTargetLockPath(rootDir, 'demo')
|
|
const acquisitionGatePath = `${lockPath}.acquire`
|
|
await mkdir(acquisitionGatePath)
|
|
const liveContenderPath = join(acquisitionGatePath, `choosing.${process.pid}-suspended`)
|
|
await writeFile(liveContenderPath, '')
|
|
const staleTime = new Date(Date.now() - 60_000)
|
|
await utimes(liveContenderPath, staleTime, staleTime)
|
|
|
|
const acquisition = acquireSkillTargetLock(rootDir, 'demo')
|
|
const state = await Promise.race([
|
|
acquisition.then(() => 'acquired', () => 'rejected'),
|
|
Bun.sleep(50).then(() => 'waiting')
|
|
])
|
|
expect(state).toBe('waiting')
|
|
expect(await exists(liveContenderPath)).toBe(true)
|
|
await unlink(liveContenderPath)
|
|
const release = await acquisition
|
|
await release()
|
|
})
|
|
|
|
test('does not pass a live acquisition ticket', async () => {
|
|
const rootDir = await mkdtemp(join(tmpdir(), 'skillhub-target-live-ticket-'))
|
|
const lockPath = await skillTargetLockPath(rootDir, 'demo')
|
|
const acquisitionGatePath = `${lockPath}.acquire`
|
|
await mkdir(acquisitionGatePath)
|
|
const liveTicketPath = join(acquisitionGatePath, `ticket.1.${process.pid}-suspended`)
|
|
await writeFile(liveTicketPath, '')
|
|
|
|
const acquisition = acquireSkillTargetLock(rootDir, 'demo')
|
|
const state = await Promise.race([
|
|
acquisition.then(() => 'acquired', () => 'rejected'),
|
|
Bun.sleep(50).then(() => 'waiting')
|
|
])
|
|
expect(state).toBe('waiting')
|
|
expect(await exists(liveTicketPath)).toBe(true)
|
|
await unlink(liveTicketPath)
|
|
const release = await acquisition
|
|
await release()
|
|
})
|
|
|
|
test('recovers acquisition contenders whose owner process exited', async () => {
|
|
const rootDir = await mkdtemp(join(tmpdir(), 'skillhub-target-dead-gate-'))
|
|
const lockPath = await skillTargetLockPath(rootDir, 'demo')
|
|
await mkdir(lockPath)
|
|
const staleTime = new Date(Date.now() - 60_000)
|
|
await utimes(lockPath, staleTime, staleTime)
|
|
const acquisitionGatePath = `${lockPath}.acquire`
|
|
await mkdir(acquisitionGatePath)
|
|
const bunPath = (await Bun.which('bun')) ?? process.execPath
|
|
const exitedOwner = Bun.spawn({ cmd: [bunPath, '-e', ''], stdout: 'ignore', stderr: 'ignore' })
|
|
const deadPid = exitedOwner.pid
|
|
expect(await exitedOwner.exited).toBe(0)
|
|
await writeFile(join(acquisitionGatePath, `choosing.${deadPid}-abandoned`), '')
|
|
await writeFile(join(acquisitionGatePath, `ticket.1.${deadPid}-abandoned`), '')
|
|
|
|
const release = await acquireSkillTargetLock(rootDir, 'demo')
|
|
await release()
|
|
expect(await exists(lockPath)).toBe(false)
|
|
expect(await readdir(acquisitionGatePath)).toEqual([])
|
|
})
|
|
|
|
test('keeps one lock identity when a symlink target is removed', async () => {
|
|
const rootDir = await mkdtemp(join(tmpdir(), 'skillhub-target-symlink-root-'))
|
|
const linkedDir = await mkdtemp(join(tmpdir(), 'skillhub-target-symlink-value-'))
|
|
const skillDir = join(rootDir, 'demo')
|
|
await symlink(linkedDir, skillDir, process.platform === 'win32' ? 'junction' : 'dir')
|
|
|
|
const lockPathBeforeRemoval = await skillTargetLockPath(rootDir, 'demo')
|
|
const release = await acquireSkillTargetLock(rootDir, 'demo')
|
|
try {
|
|
await unlink(skillDir)
|
|
expect(await skillTargetLockPath(rootDir, 'demo')).toBe(lockPathBeforeRemoval)
|
|
await expect(acquireSkillTargetLock(rootDir, 'demo')).rejects.toThrow('install target is busy')
|
|
} finally {
|
|
await release()
|
|
}
|
|
expect(await exists(lockPathBeforeRemoval)).toBe(false)
|
|
})
|
|
})
|