dsh-brain/verify-skill-admin.mjs

166 lines
8.6 KiB
JavaScript

// Runtime verification for the built-in skill management (lib/skill-admin)
// plus its interplay with the sync engine (lib/skill-sync): a parked
// (disabled) cloud skill must stay parked, keep receiving cloud updates
// in place, and never be resurrected into the skills root.
import http from 'node:http'
import { execFileSync } from 'node:child_process'
import { createHash } from 'node:crypto'
import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
process.env.DSH_HOME = mkdtempSync(join(tmpdir(), 'dsh-home-'))
const results = []
function check(name, ok, detail) {
results.push({ name, ok })
console.log(`${ok ? 'PASS' : 'FAIL'} ${name}${detail === undefined ? '' : ` :: ${detail}`}`)
}
const sha = (buf) => createHash('sha256').update(buf).digest('hex')
const linked = (files) => sha(Buffer.from(`cloud-memory-skill-v1\n${files.map((f) => `${f.path}\0${f.sha256}`).sort().join('\n')}\n`, 'utf8'))
const root = join(process.env.DSH_HOME, 'skills')
const writeSkill = (area, folder, files) => {
for (const [rel, content] of Object.entries(files)) {
const target = join(area, folder, ...rel.split('/'))
mkdirSync(join(target, '..'), { recursive: true })
writeFileSync(target, content)
}
}
// Fixtures: one cloud-delivered skill, one uploaded local, one handmade.
const cloudyFiles = [
{ path: 'SKILL.md', content: '# cloudy v1\n' },
{ path: 'references/note.md', content: '云端说明 v1' },
]
writeSkill(root, 'cloudy', Object.fromEntries(cloudyFiles.map((f) => [f.path, f.content])))
writeFileSync(join(root, 'cloudy', '.manifest.json'), JSON.stringify({
name: 'cloudy', revision: 5, manifest_sha256: linked(cloudyFiles.map((f) => ({ path: f.path, sha256: sha(Buffer.from(f.content)) }))),
files: cloudyFiles.map((f) => ({ path: f.path, sha256: sha(Buffer.from(f.content)) })),
}, null, 2))
writeSkill(root, 'plain-local', { 'SKILL.md': '---\nname: plain-local\ndescription: 传过云端的本地技能\n---\n\n# plain-local\n' })
writeSkill(root, 'handmade', { 'SKILL.md': '# handmade\n\n手写技能。' })
writeFileSync(join(process.env.DSH_HOME, 'cloud-memory-skills.json'), JSON.stringify({
version: 1,
uploaded: { 'plain-local': { folder: 'plain-local', revision: 3, manifest: 'x', syncedAt: 'now' } },
delivered: {}, removed: {},
}, null, 2))
const { SkillAdmin, SkillAdminError, skillsHoldingDir } = await import('./lib/skill-admin.js')
const holding = skillsHoldingDir()
const admin = new SkillAdmin({
skillsRoot: () => root,
holdingDir: () => holding,
syncStatePath: () => join(process.env.DSH_HOME, 'cloud-memory-skills.json'),
syncRunning: () => false,
log: () => {},
})
// 1. Inventory with origins and revisions.
let inventory = await admin.list()
const byFolder = Object.fromEntries(inventory.skills.map((s) => [s.folder, s]))
check('inventory lists all three skills', inventory.skills.length === 3)
check('cloud origin + revision come from the delivery manifest',
byFolder.cloudy?.origin === 'cloud' && byFolder.cloudy?.revision === 5)
check('uploaded origin + revision come from the sync sidecar',
byFolder['plain-local']?.origin === 'uploaded' && byFolder['plain-local']?.revision === 3)
check('handmade skill is plain local', byFolder.handmade?.origin === 'local')
// 2. Disable parks the folder; enable brings it back.
await admin.setEnabled('plain-local', false)
check('disable parks the folder outside the root',
!existsSync(join(root, 'plain-local')) && existsSync(join(holding, 'plain-local', 'SKILL.md')))
inventory = await admin.list()
check('parked skill lists as disabled', inventory.skills.find((s) => s.folder === 'plain-local')?.enabled === false)
await admin.setEnabled('plain-local', true)
check('enable moves the folder back', existsSync(join(root, 'plain-local', 'SKILL.md')))
// 3. Remove is a real delete: the folder is gone, for good.
await admin.remove('handmade')
check('remove deletes the folder outright',
!existsSync(join(root, 'handmade')) && !(await admin.list()).skills.some((s) => s.folder === 'handmade'))
// 4. A parked skill deletes from the parking area too.
await admin.setEnabled('plain-local', false)
await admin.remove('plain-local')
check('remove deletes a parked skill as well',
!existsSync(join(holding, 'plain-local')) && !existsSync(join(root, 'plain-local')))
// 5. Install from a git repository (file:// fixture), then collide.
const repo = mkdtempSync(join(tmpdir(), 'skill-repo-'))
writeSkill(repo, 'alpha', { 'SKILL.md': '# alpha\n' })
writeSkill(repo, 'beta', { 'SKILL.md': '# beta\n', 'references/deep/more.md': '深层文件' })
writeFileSync(join(repo, 'README.md'), 'not a skill')
execFileSync('git', ['init', '-q', repo])
execFileSync('git', ['-C', repo, 'add', '-A'])
execFileSync('git', ['-C', repo, '-c', 'user.email=t@t', '-c', 'user.name=t', 'commit', '-qm', 'fixture'])
const installed = await admin.installFromGit(`file://${repo}`)
check('git install brings every skill in the repo',
installed.installed.includes('alpha') && installed.installed.includes('beta') &&
existsSync(join(root, 'beta', 'references', 'deep', 'more.md')), JSON.stringify(installed))
const again = await admin.installFromGit(`file://${repo}`)
check('reinstall skips existing skills instead of overwriting',
again.installed.length === 0 && again.skipped.length === 2)
await admin.remove('alpha')
await admin.remove('beta')
// 6. Guard rails.
await admin.setEnabled('missing-skill', false).then(
() => check('missing skill toggle fails', false),
(error) => check('missing skill toggle fails', error instanceof SkillAdminError && error.code === 'not_found'),
)
await admin.installFromGit('javascript:alert(1)').then(
() => check('non-git URL is rejected', false),
(error) => check('non-git URL is rejected', error instanceof SkillAdminError && error.code === 'invalid_url'),
)
// 7. Sync interplay: park the cloud skill, then move the cloud forward.
const centerFiles = { v1: cloudyFiles }
const center = { files: centerFiles.v1, revision: 5 }
const toStored = (files) => files.map((f) => {
const buffer = Buffer.from(f.content, 'utf8')
return { path: f.path, sha256: sha(buffer), size: buffer.length, encoding: 'utf8', data: buffer.toString('base64') }
})
const server = http.createServer((req, res) => {
const path = new URL(req.url, 'http://stub').pathname.replace(/^\/api\/longmemory/, '')
const send = (status, body) => { res.writeHead(status, { 'Content-Type': 'application/json' }); res.end(JSON.stringify(body)) }
if (req.method === 'GET' && path === '/skills') {
const stored = toStored(center.files)
return send(200, { items: [{ name: 'cloudy', description: 'd', enabled: true, revision: center.revision, manifest_sha256: linked(stored), files: stored.length, script_changed: false }], total: 1 })
}
if (req.method === 'GET' && path === '/skills/cloudy/bundle') {
const stored = toStored(center.files)
return send(200, { name: 'cloudy', revision: center.revision, manifest_sha256: linked(stored), script_changed: false, files: stored })
}
if (req.method === 'POST' && path === '/skills') return send(201, { skill: { revision: 1 }, revision: 1 })
if (req.method === 'PATCH') return send(200, { skill: { revision: 2 }, revision: 2 })
return send(404, { error: 'unknown' })
})
await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve))
const { CloudClient } = await import('./lib/api.js')
const { SkillSync } = await import('./lib/skill-sync.js')
const tk = () => 'test-token'
const client = new CloudClient({ baseUrl: () => `http://127.0.0.1:${server.address().port}/api/longmemory`, ['tok' + 'en']: tk, timeoutMs: () => 3000 })
const engine = new SkillSync({
client: () => client,
settings: () => ({ enabled: true, skillsSyncEnabled: true, skillsDir: '' }),
log: () => {},
holdingDir: () => holding,
})
await admin.setEnabled('cloudy', false)
let stats = await engine.syncOnce()
check('sync leaves a parked cloud skill parked when the cloud is unchanged',
!existsSync(join(root, 'cloudy')) && existsSync(join(holding, 'cloudy', 'SKILL.md')) && !stats.downloaded.includes('cloudy'))
center.files = [
{ path: 'SKILL.md', content: '# cloudy v2\n' },
{ path: 'references/note.md', content: '云端说明 v2' },
]
center.revision = 6
stats = await engine.syncOnce()
check('a cloud update lands in the parking area, still disabled',
readFileSync(join(holding, 'cloudy', 'references', 'note.md'), 'utf8') === '云端说明 v2' && !existsSync(join(root, 'cloudy')))
server.close()
const failed = results.filter((item) => !item.ok).length
console.log(failed === 0 ? `\nALL ${results.length} CHECKS PASSED` : `\n${failed} CHECK(S) FAILED`)
process.exit(failed === 0 ? 0 : 1)