dsh-brain/verify-skill-import.mjs

145 lines
8.2 KiB
JavaScript

// Verification for 「从其他软件导入」 (import a skill from another tool).
//
// The promises asserted here are the ones the card makes: the source
// directory is never modified, a same-name skill in DSH (enabled or
// parked) is never overwritten, and the copy is as strict as a git
// install — symlinks and `.git` never travel.
import http from 'node:http'
import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, symlinkSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
process.env.DSH_HOME = mkdtempSync(join(tmpdir(), 'brain-import-'))
const results = []
function check(name, ok, detail) {
results.push({ name, ok })
console.log(`${ok ? 'PASS' : 'FAIL'} ${name}${detail === undefined ? '' : ` :: ${detail}`}`)
}
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)
}
}
const root = join(process.env.DSH_HOME, 'skills')
const holding = join(process.env.DSH_HOME, 'skills-disabled')
const foreignRoot = join(tmpdir(), `foreign-codex-${Date.now()}`)
mkdirSync(root, { recursive: true })
mkdirSync(holding, { recursive: true })
mkdirSync(foreignRoot, { recursive: true })
writeSkill(foreignRoot, 'good-skill', {
'SKILL.md': '---\nname: good-skill\ndescription: 好技能\n---\n\n# good-skill\n',
'references/notes.md': 'notes',
})
writeSkill(foreignRoot, 'with-link', { 'SKILL.md': '# with-link\n' })
symlinkSync(join(foreignRoot, 'good-skill', 'SKILL.md'), join(foreignRoot, 'with-link', 'escape.md'))
writeSkill(foreignRoot, 'with-git', { 'SKILL.md': '# with-git\n', '.git/objects/pack': 'x' })
writeSkill(foreignRoot, 'no-marker', { 'README.md': 'no skill marker' })
writeSkill(foreignRoot, 'real-target', { 'SKILL.md': '# real\n' })
symlinkSync(join(foreignRoot, 'real-target'), join(foreignRoot, 'link-skill'))
writeSkill(holding, 'parked-one', { 'SKILL.md': '# parked\n' })
writeSkill(foreignRoot, 'parked-one', { 'SKILL.md': '# parked clone\n' })
const { SkillAdmin } = await import('./lib/skill-admin.js')
const { SkillGroupManager } = await import('./lib/skill-groups.js')
const { SettingsStore } = await import('./lib/store.js')
const { Reporter } = await import('./lib/reporter.js')
const { createRoutes } = await import('./lib/routes.js')
const admin = new SkillAdmin({
skillsRoot: () => root,
holdingDir: () => holding,
syncStatePath: () => join(process.env.DSH_HOME, 'dsh-brain-skills.json'),
syncRunning: () => false,
log: () => {},
})
const sources = () => [
{ id: 'dsh', label: 'DSH', root, writable: true, manager: 'DSH' },
{ id: 'codex', label: 'Codex', root: foreignRoot, writable: false, manager: 'Codex' },
]
const manager = new SkillGroupManager({ sources, admin, storePath: () => join(process.env.DSH_HOME, 'dsh-brain-skill-groups.json'), log: () => {} })
const codeOf = async (promise) => {
try {
await promise
return 'no-throw'
} catch (error) {
return error.code ?? error.message
}
}
// ── happy path ────────────────────────────────────────────────────────
const imported = await manager.importSkill('codex', 'good-skill')
check('import returns the folder', imported.folder === 'good-skill')
check('the skill lands in the DSH root with its files',
readFileSync(join(root, 'good-skill', 'references', 'notes.md'), 'utf8') === 'notes' &&
readFileSync(join(root, 'good-skill', 'SKILL.md'), 'utf8').includes('good-skill'))
check('the source directory is untouched',
existsSync(join(foreignRoot, 'good-skill', 'SKILL.md')) && !existsSync(join(foreignRoot, 'good-skill', 'references', 'moved')))
const listed = await admin.list()
check('the imported skill shows in the DSH inventory', listed.skills.some((skill) => skill.folder === 'good-skill'))
// ── refusals ──────────────────────────────────────────────────────────
check('a second import of the same skill is refused', await codeOf(manager.importSkill('codex', 'good-skill')) === 'already_exists')
check('importing over a parked same-name skill is refused', await codeOf(manager.importSkill('codex', 'parked-one')) === 'already_exists')
check('importing from the DSH source itself is refused', await codeOf(manager.importSkill('dsh', 'good-skill')) === 'import_from_self')
check('a traversal folder name is refused', await codeOf(manager.importSkill('codex', '../escape')) === 'invalid_name')
check('a skill without SKILL.md is refused', await codeOf(manager.importSkill('codex', 'no-marker')) === 'invalid_skill')
check('a symlinked skill directory is refused', await codeOf(manager.importSkill('codex', 'link-skill')) === 'invalid_skill')
check('an unknown source is refused', await codeOf(manager.importSkill('nope', 'good-skill')) === 'unknown_source')
check('a missing skill is a 404-style refusal', await codeOf(manager.importSkill('codex', 'ghost')) === 'not_found')
// ── copy hygiene ──────────────────────────────────────────────────────
await manager.importSkill('codex', 'with-link')
check('symlinks inside a skill are dropped, not copied',
existsSync(join(root, 'with-link', 'SKILL.md')) && !existsSync(join(root, 'with-link', 'escape.md')))
await manager.importSkill('codex', 'with-git')
check('.git never travels with an import',
existsSync(join(root, 'with-git', 'SKILL.md')) && !existsSync(join(root, 'with-git', '.git')))
// ── route surface ─────────────────────────────────────────────────────
const store = new SettingsStore({ baseUrl: 'https://memory.example.org/api/longmemory' }, join(process.env.DSH_HOME, 'dsh-brain.json'))
const reporter = new Reporter({
client: () => ({ reportTurn: async () => ({ ok: true, status: 200, data: {} }) }),
settings: () => ({ enabled: true, clientId: 'import' }),
activityToken: () => '',
summary: () => ({ enabled: false, maxChars: 1000 }),
summaryToken: () => '',
log: () => {},
})
const routes = createRoutes({ version: 'test', store, reporter, client: () => ({ reach: async () => ({ ok: false, status: 0, message: 'stub' }) }), admin, groups: manager })
const server = http.createServer((req, res) => {
const path = (req.url ?? '/').split('?')[0]
for (const route of routes) {
if (route.kind === 'exact' && path === route.path) return route.handler(req, res)
if (route.kind === 'prefix' && (path === route.path || path.startsWith(`${route.path}/`))) return route.handler(req, res)
}
res.writeHead(404, { 'content-type': 'application/json' })
res.end('{"ok":false}')
})
await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve))
const origin = `http://127.0.0.1:${server.address().port}`
async function call(method, path, body) {
const response = await fetch(`${origin}${path}`, {
method,
headers: { accept: 'application/json', ...(body === undefined ? {} : { 'content-type': 'application/json' }) },
body: body === undefined ? undefined : JSON.stringify(body),
})
return { status: response.status, body: await response.json().catch(() => null) }
}
writeSkill(foreignRoot, 'route-skill', { 'SKILL.md': '# route\n' })
const viaRoute = await call('POST', '/dsh-brain/skills/import', { sourceId: 'codex', folder: 'route-skill' })
check('POST /skills/import imports through the real route', viaRoute.status === 200 && viaRoute.body?.ok === true && existsSync(join(root, 'route-skill', 'SKILL.md')))
const dupe = await call('POST', '/dsh-brain/skills/import', { sourceId: 'codex', folder: 'route-skill' })
check('the route maps a duplicate import to a client error', dupe.status >= 400 && dupe.body?.code === 'already_exists')
server.close()
const failed = results.filter((item) => !item.ok)
console.log(failed.length === 0 ? `ALL ${results.length} CHECKS PASSED` : `${failed.length}/${results.length} CHECKS FAILED`)
process.exit(failed.length === 0 ? 0 : 1)