@masstensor/diagnose 0.3.2 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (107) hide show
  1. package/DEVELOPMENT_PLAN.md +69 -0
  2. package/KNOWLEDGE_SECURITY.md +47 -0
  3. package/PAIRING_PROTOCOL.md +37 -0
  4. package/README.md +56 -9
  5. package/USER_GUIDE.md +460 -20
  6. package/deploy/Caddyfile +1 -1
  7. package/deploy/ecosystem.config.cjs +1 -1
  8. package/dist/agent-command.d.ts +4 -0
  9. package/dist/agent-command.js +33 -0
  10. package/dist/agent.d.ts +1 -1
  11. package/dist/agent.js +48 -8
  12. package/dist/cases.d.ts +118 -0
  13. package/dist/cases.js +115 -0
  14. package/dist/cli.js +187 -25
  15. package/dist/crypto.d.ts +7 -0
  16. package/dist/crypto.js +16 -1
  17. package/dist/discover.js +1 -1
  18. package/dist/engine.d.ts +3 -0
  19. package/dist/engine.js +49 -9
  20. package/dist/history.d.ts +13 -0
  21. package/dist/history.js +57 -0
  22. package/dist/journal.d.ts +23 -1
  23. package/dist/journal.js +82 -5
  24. package/dist/knowledge-cli.d.ts +2 -0
  25. package/dist/knowledge-cli.js +164 -0
  26. package/dist/knowledge-drafts.d.ts +47 -0
  27. package/dist/knowledge-drafts.js +76 -0
  28. package/dist/knowledge-mcp.d.ts +5 -0
  29. package/dist/knowledge-mcp.js +65 -0
  30. package/dist/maintenance.d.ts +2 -0
  31. package/dist/maintenance.js +46 -0
  32. package/dist/mcp.d.ts +1 -1
  33. package/dist/mcp.js +42 -20
  34. package/dist/operator.d.ts +4 -0
  35. package/dist/operator.js +33 -8
  36. package/dist/pairing.d.ts +40 -0
  37. package/dist/pairing.js +92 -0
  38. package/dist/peer.d.ts +13 -0
  39. package/dist/peer.js +87 -11
  40. package/dist/relay-main.js +1 -1
  41. package/dist/relay.d.ts +1 -0
  42. package/dist/relay.js +27 -4
  43. package/dist/resources.js +47 -26
  44. package/dist/schema.d.ts +2 -0
  45. package/dist/schema.js +2 -2
  46. package/dist/short-pairing.d.ts +25 -0
  47. package/dist/short-pairing.js +73 -0
  48. package/dist/skill-library.d.ts +27 -0
  49. package/dist/skill-library.js +226 -0
  50. package/dist/skill.d.ts +9 -0
  51. package/dist/skill.js +59 -0
  52. package/dist/transfers.js +28 -11
  53. package/dist/util.d.ts +2 -0
  54. package/dist/util.js +17 -3
  55. package/dist/vault-crypto.d.ts +11 -0
  56. package/dist/vault-crypto.js +30 -0
  57. package/dist/vault-server.d.ts +10 -0
  58. package/dist/vault-server.js +156 -0
  59. package/dist/vault.d.ts +19 -0
  60. package/dist/vault.js +72 -0
  61. package/examples/skills/device-troubleshooting/SKILL.md +35 -0
  62. package/examples/skills/device-troubleshooting/references/device-profile.md +16 -0
  63. package/examples/skills/owon.md +27 -0
  64. package/npm-shrinkwrap.json +209 -3
  65. package/package.json +15 -5
  66. package/scripts/setup-node.ps1 +54 -0
  67. package/scripts/setup-node.sh +52 -0
  68. package/src/agent-command.ts +25 -0
  69. package/src/agent.ts +37 -7
  70. package/src/cases.ts +74 -0
  71. package/src/cli.ts +57 -22
  72. package/src/crypto.ts +14 -1
  73. package/src/discover.ts +1 -1
  74. package/src/engine.ts +28 -7
  75. package/src/history.ts +43 -0
  76. package/src/journal.ts +41 -5
  77. package/src/knowledge-cli.ts +67 -0
  78. package/src/knowledge-drafts.ts +55 -0
  79. package/src/knowledge-mcp.ts +35 -0
  80. package/src/maintenance.ts +30 -0
  81. package/src/mcp.ts +26 -18
  82. package/src/operator.ts +25 -9
  83. package/src/pairing.ts +64 -0
  84. package/src/peer.ts +42 -14
  85. package/src/relay-main.ts +1 -1
  86. package/src/relay.ts +18 -6
  87. package/src/resources.ts +35 -13
  88. package/src/schema.ts +4 -4
  89. package/src/short-pairing.ts +57 -0
  90. package/src/skill-library.ts +162 -0
  91. package/src/skill.ts +45 -0
  92. package/src/transfers.ts +14 -3
  93. package/src/util.ts +15 -3
  94. package/src/vault-crypto.ts +25 -0
  95. package/src/vault-server.ts +72 -0
  96. package/src/vault.ts +51 -0
  97. package/test/agent.test.ts +79 -7
  98. package/test/cli.test.ts +3 -3
  99. package/test/knowledge-mcp.test.ts +37 -0
  100. package/test/knowledge.test.ts +112 -0
  101. package/test/mcp.test.ts +1 -1
  102. package/test/pairing.test.ts +124 -0
  103. package/test/review.test.ts +129 -0
  104. package/test/setup.test.ts +16 -0
  105. package/test/short-pairing.test.ts +100 -0
  106. package/test/skill-library.test.ts +62 -0
  107. package/test/skill.test.ts +25 -0
package/src/vault.ts ADDED
@@ -0,0 +1,51 @@
1
+ import { readFile, writeFile, mkdir, rm } from 'node:fs/promises';
2
+ import { homedir } from 'node:os';
3
+ import { join } from 'node:path';
4
+ import { SkillLibrary } from './skill-library.js';
5
+ import { MAX_VAULT_OBJECT, newRecovery, vaultKeys, objectId, sealBundle, openBundle } from './vault-crypto.js';
6
+
7
+ export class Vault {
8
+ constructor(readonly library = new SkillLibrary(), readonly root = join(homedir(), '.diagnose', 'vault'), readonly relay = 'https://diagnose.fenginwind.com') {
9
+ const url = new URL(relay);
10
+ if (url.username || url.password || url.search || url.hash || !['', '/'].includes(url.pathname) || !(url.protocol === 'https:' || (url.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname)))) throw new Error('Library relay must be an HTTPS origin (HTTP allowed only for loopback tests)');
11
+ }
12
+ private async key(): Promise<string> { const value = (await readFile(join(this.root, 'recovery'), 'utf8')).trim(); vaultKeys(value); return value; }
13
+ async initialize(recovery = newRecovery()): Promise<void> {
14
+ vaultKeys(recovery); await mkdir(this.root, { recursive: true, mode: 0o700 });
15
+ await writeFile(join(this.root, 'recovery'), recovery + '\n', { flag: 'wx', mode: 0o600, flush: true });
16
+ }
17
+ async backup(path: string): Promise<void> { await writeFile(path, await this.key() + '\n', { flag: 'wx', mode: 0o600, flush: true }); }
18
+ private async request(method: string, suffix = '', body?: Buffer): Promise<Buffer> {
19
+ const auth = vaultKeys(await this.key()).auth;
20
+ const response = await fetch(new URL('/v1/library' + suffix, this.relay), { method, headers: { Authorization: 'Bearer ' + auth, ...(body ? { 'Content-Type': 'application/octet-stream', 'Content-Length': String(body.length) } : {}) }, body: body ? new Uint8Array(body) : undefined, redirect: 'error', signal: AbortSignal.timeout(45000) });
21
+ if (!response.ok) { await response.body?.cancel(); throw new Error(`Library ${method} failed (${response.status}); no action was retried`); }
22
+ const chunks: Buffer[] = []; let total = 0;
23
+ if (response.body) for await (const chunk of response.body) { total += chunk.length; if (total > MAX_VAULT_OBJECT) throw new Error('Library response too large'); chunks.push(Buffer.from(chunk)); }
24
+ return Buffer.concat(chunks);
25
+ }
26
+ async list(): Promise<{ id: string; bytes: number }[]> {
27
+ const response = JSON.parse((await this.request('GET')).toString());
28
+ if (!Array.isArray(response.objects) || response.objects.length > 128 || response.objects.some((item: { id?: unknown; bytes?: number }) => typeof item.id !== 'string' || !/^[a-f0-9]{64}$/.test(item.id) || !Number.isInteger(item.bytes) || item.bytes! > MAX_VAULT_OBJECT || item.bytes! < 29)) throw new Error('Invalid library inventory');
29
+ return response.objects;
30
+ }
31
+ async push(reference: string): Promise<void> {
32
+ const recovery = await this.key(), bundle = await this.library.bundle(reference), id = objectId(recovery, reference);
33
+ const existing = (await this.list()).some(item => item.id === id);
34
+ if (existing) {
35
+ const bytes = openBundle(recovery, id, await this.request('GET', '/' + id));
36
+ if (bytes.toString() !== JSON.stringify(bundle)) throw new Error('Remote immutable version conflicts with local bundle'); return;
37
+ }
38
+ await this.request('PUT', '/' + id, sealBundle(recovery, id, Buffer.from(JSON.stringify(bundle))));
39
+ }
40
+ async pull(): Promise<string[]> {
41
+ const recovery = await this.key(), references: string[] = [];
42
+ for (const { id } of await this.list()) {
43
+ const bundle = JSON.parse(openBundle(recovery, id, await this.request('GET', '/' + id)).toString());
44
+ if (typeof bundle.reference !== 'string' || objectId(recovery, bundle.reference) !== id) throw new Error('Library object identity mismatch');
45
+ references.push(await this.library.restore(bundle));
46
+ }
47
+ return references;
48
+ }
49
+ async revoke(): Promise<void> { await this.request('DELETE'); }
50
+ async forget(): Promise<void> { await rm(join(this.root, 'recovery')); }
51
+ }
@@ -1,16 +1,18 @@
1
1
  import { test } from 'node:test';
2
2
  import assert from 'node:assert/strict';
3
- import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
3
+ import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, realpathSync } from 'node:fs';
4
4
  import { tmpdir } from 'node:os';
5
- import { join, resolve } from 'node:path';
5
+ import { dirname, join, resolve } from 'node:path';
6
6
  import { spawn } from 'node:child_process';
7
7
  import { createRequire } from 'node:module';
8
8
  import { pathToFileURL } from 'node:url';
9
+ import { PairingStore } from '../dist/pairing.js';
10
+ import { createCode } from '../dist/crypto.js';
9
11
  const require = createRequire(import.meta.url);
10
- const cli = resolve('dist/cli.js');
12
+ const cli = realpathSync(process.env.DIAGNOSE_TEST_CLI ?? resolve('dist/cli.js'));
11
13
 
12
14
  function fixture() {
13
- const root = mkdtempSync(join(tmpdir(), 'diagnose agent test ')), capture = join(root, 'capture.json'), settings = join(root, '.gemini', 'settings.json');
15
+ const root = realpathSync(mkdtempSync(join(tmpdir(), 'diagnose agent test '))), capture = join(root, 'capture.json'), settings = join(root, '.gemini', 'settings.json');
14
16
  mkdirSync(join(root, '.gemini'));
15
17
  writeFileSync(settings, JSON.stringify({ security: { marker: 'preserve-admin-policy' }, mcpServers: { existing: { command: 'unchanged' } } }));
16
18
  for (const name of ['.codex', '.claude', '.gemini']) { mkdirSync(join(root, name), { recursive: true }); writeFileSync(join(root, name, 'sentinel'), 'unchanged'); }
@@ -21,9 +23,12 @@ const fs=require('node:fs'), args=process.argv.slice(2), agent=require('node:pat
21
23
  if(agent==='codex'){const overrides=args.filter((_,i)=>args[i-1]==='-c');server={command:JSON.parse(overrides[0].split('=').slice(1).join('=')),args:JSON.parse(overrides[1].split('=').slice(1).join('='))};}
22
24
  else if(agent==='claude')server=JSON.parse(args[args.indexOf('--mcp-config')+1]).mcpServers.diagnose;
23
25
  else{settingsPath=require('node:path').join(process.env.GEMINI_CLI_HOME,'.gemini','settings.json');const settings=JSON.parse(fs.readFileSync(settingsPath,'utf8'));server=settings.mcpServers.diagnose;admin=settings.security; if(settings.mcpServers.existing.command!=='unchanged')throw Error('Existing MCP lost');}
26
+ let task,taskPath,taskMode;const initial=agent==='gemini'?args[args.indexOf('--prompt-interactive')+1]:args.at(-1);if(initial?.includes('Task snapshot path (JSON):')){const marker=initial.split('\\n').find(x=>x.startsWith('Task snapshot path (JSON): '));taskPath=JSON.parse(marker.slice('Task snapshot path (JSON): '.length));task=JSON.parse(fs.readFileSync(taskPath,'utf8'));taskMode=fs.statSync(taskPath).mode&511;}
24
27
  const {Client}=await import(${JSON.stringify(client)}),{StdioClientTransport}=await import(${JSON.stringify(transport)});
25
- const client=new Client({name:'launcher-acceptance',version:'1'});await client.connect(new StdioClientTransport(server));const tools=(await client.listTools()).tools.map(t=>t.name);await client.close();
26
- fs.writeFileSync(process.env.TEST_CAPTURE,JSON.stringify({args,server,tools,settingsPath,admin}));if(process.env.TEST_WAIT){process.on('SIGTERM',()=>process.exit(23));setInterval(()=>{},1000)}else process.exit(Number(process.env.TEST_EXIT||0));
28
+ const client=new Client({name:'launcher-acceptance',version:'1'});await client.connect(new StdioClientTransport(server));const tools=(await client.listTools()).tools.map(t=>t.name);let workflow;
29
+ if(process.env.TEST_PAIR_CODE){if(!task?.instructions.includes('STARTUP_WORKFLOW_ACCEPTANCE'))throw Error('Selected task was not read');const call=async(name,args)=>{const r=await client.callTool({name,arguments:args});if(r.isError)throw Error(r.content[0].text);return JSON.parse(r.content[0].text);};await call('diagnose_pair',{code:process.env.TEST_PAIR_CODE,label:'Explicitly authorized fixture agent'});const {id}=await call('diagnose_batch',{reason:'Selected startup task: fix and verify scratch configuration',steps:[{operation:'file.write',arguments:{path:process.env.TEST_REMOTE_TARGET,content:'fixed'}},{operation:'file.read',arguments:{path:process.env.TEST_REMOTE_TARGET}}]});workflow=await call('diagnose_wait',{id,timeoutMs:5000,release:true});await call('diagnose_disconnect',{});}
30
+ await client.close();
31
+ fs.writeFileSync(process.env.TEST_CAPTURE,JSON.stringify({args,server,tools,settingsPath,admin,task,taskPath,taskMode,workflow}));if(process.env.TEST_WAIT){process.on('SIGTERM',()=>process.exit(23));setInterval(()=>{},1000)}else process.exit(Number(process.env.TEST_EXIT||0));
27
32
  })().catch(e=>{console.error(e);process.exit(99)});
28
33
  `;
29
34
  for (const agent of ['codex', 'claude', 'gemini']) writeFileSync(join(root, agent), stub, { mode: 0o700 });
@@ -36,7 +41,7 @@ for (const agent of ['codex', 'claude', 'gemini']) test(`agent ${agent} loads re
36
41
  const f = fixture(), before = readFileSync(f.settings, 'utf8');
37
42
  const result = await run(['agent', agent, '--relay', 'https://relay.example.test', '--', '--model', 'a model with spaces', 'literal $(do-not-execute)'], { ...process.env, HOME: f.root, PATH: f.root + ':' + process.env.PATH, GEMINI_CLI_HOME: f.root, TEST_CAPTURE: f.capture, TEST_EXIT: '7' });
38
43
  assert.equal(result.code, 7, result.output); const captured = JSON.parse(readFileSync(f.capture, 'utf8'));
39
- assert.equal(captured.server.command, process.execPath); assert.deepEqual(captured.server.args, [cli, 'mcp', 'https://relay.example.test']); assert.equal(captured.tools.length, 11); assert.ok(captured.tools.includes('diagnose_pair')); assert.ok(captured.tools.includes('diagnose_process'));
44
+ assert.equal(captured.server.command, process.execPath); assert.deepEqual(captured.server.args, [cli, 'mcp', 'https://relay.example.test']); assert.equal(captured.tools.length, 15); assert.ok(captured.tools.includes('diagnose_pair')); assert.ok(captured.tools.includes('diagnose_process'));
40
45
  assert.deepEqual(captured.args.slice(-3), ['--model', 'a model with spaces', 'literal $(do-not-execute)']);
41
46
  assert.equal(readFileSync(f.settings, 'utf8'), before); for (const name of ['.codex', '.claude', '.gemini']) assert.equal(readFileSync(join(f.root, name, 'sentinel'), 'utf8'), 'unchanged');
42
47
  if (agent === 'gemini') { assert.equal(captured.admin.marker, 'preserve-admin-policy'); assert.equal(existsSync(captured.settingsPath), false); }
@@ -55,3 +60,70 @@ test('agent forwards termination and cleans the Gemini overlay', { skip: process
55
60
  try { for (let i = 0; i < 100 && !existsSync(f.capture); i++) await new Promise(resolveWait => setTimeout(resolveWait, 20)); assert.ok(existsSync(f.capture)); const captured = JSON.parse(readFileSync(f.capture, 'utf8')); child.kill('SIGTERM'); assert.equal(await exit, 23); assert.equal(existsSync(captured.settingsPath), false); assert.ok(existsSync(f.settings)); }
56
61
  finally { child.kill('SIGKILL'); }
57
62
  });
63
+
64
+ for (const agent of ['codex', 'claude', 'gemini']) test(`agent ${agent} loads the same selected Markdown task at startup without exposing its body in argv`, { skip: process.platform === 'win32', timeout: 15000 }, async () => {
65
+ const f = fixture(), source = join(f.root, 'device "profile".md'), body = '# Device task\nPRIVATE_TASK_MARKER\nRead references/profile.md and diagnose the selected device.\nLiteral $(do-not-execute).'; writeFileSync(source, body);
66
+ new PairingStore(join(f.root, '.diagnose', 'pairings')).add({ role: 'operator', name: 'alice-pc', label: 'test', relay: 'https://relay.example.test', code: createCode() });
67
+ const result = await run(['agent', agent, '--device', 'alice-pc', '--skill', source, '--', '--model', 'selected-model'], { ...process.env, HOME: f.root, PATH: f.root + ':' + process.env.PATH, GEMINI_CLI_HOME: f.root, TEST_CAPTURE: f.capture });
68
+ assert.equal(result.code, 0, result.output); const captured = JSON.parse(readFileSync(f.capture, 'utf8'));
69
+ assert.deepEqual(captured.server.args.slice(-2), ['--device', 'alice-pc']); assert.match(captured.args.at(-1), /do not ask for a pairing code/);
70
+ assert.equal(captured.task.instructions, body); assert.equal(captured.task.sourceFile, source); assert.equal(captured.task.baseDirectory, f.root); assert.equal(captured.taskMode, 0o600); assert.equal(existsSync(captured.taskPath), false); assert.ok(captured.tools.includes('diagnose_pair'));
71
+ const scopeFlag = agent === 'gemini' ? '--include-directories' : '--add-dir';
72
+ assert.equal(captured.args[captured.args.indexOf(scopeFlag) + 1], dirname(captured.taskPath));
73
+ assert.notEqual(dirname(captured.taskPath), f.root);
74
+ if (captured.settingsPath) assert.ok(!captured.settingsPath.startsWith(dirname(captured.taskPath) + '/'));
75
+ assert.ok(!captured.args.join(' ').includes('PRIVATE_TASK_MARKER')); assert.ok(!result.output.includes('PRIVATE_TASK_MARKER')); assert.ok(captured.args.includes('selected-model'));
76
+ const prompt = captured.args.at(-1); assert.match(prompt, /Start the remote troubleshooting task/); assert.match(prompt, /do not merely summarize/); assert.match(prompt, /approval/);
77
+ if (agent === 'gemini') assert.equal(captured.args.at(-2), '--prompt-interactive'); else assert.equal(captured.args.at(-2), '--');
78
+ });
79
+
80
+ test('skill directory is accepted, and invalid skills fail before launching an agent', { skip: process.platform === 'win32', timeout: 15000 }, async () => {
81
+ const f = fixture(), skill = join(f.root, 'device-skill'); mkdirSync(skill); writeFileSync(join(skill, 'SKILL.md'), '# Device skill\nInspect first.');
82
+ const env = { ...process.env, HOME: f.root, PATH: f.root + ':' + process.env.PATH, GEMINI_CLI_HOME: f.root, TEST_CAPTURE: f.capture };
83
+ const result = await run(['agent', 'codex', '--skill', skill], env); assert.equal(result.code, 0, result.output); assert.equal(JSON.parse(readFileSync(f.capture, 'utf8')).task.sourceFile, join(skill, 'SKILL.md'));
84
+ const missing = await run(['agent', 'codex', '--skill', join(f.root, 'missing.md')], { ...env, TEST_CAPTURE: join(f.root, 'must-not-run') }); assert.equal(missing.code, 1); assert.equal(existsSync(join(f.root, 'must-not-run')), false);
85
+ const conflict = await run(['agent', 'gemini', '--skill', skill, '--', '--prompt', 'another task'], env); assert.equal(conflict.code, 1); assert.match(conflict.output, /initial task/);
86
+ });
87
+
88
+ for (const agent of ['codex', 'claude', 'gemini']) test(`agent ${agent} launches a pinned library bundle through the CLI`, { skip: process.platform === 'win32', timeout: 15000 }, async () => {
89
+ const f = fixture(), source = join(f.root, 'source'); mkdirSync(source); mkdirSync(join(source, 'references'));
90
+ writeFileSync(join(source, 'SKILL.md'), '# Library task\nRead references/profile.md.'); writeFileSync(join(source, 'references/profile.md'), 'Model A');
91
+ const env = { ...process.env, HOME: f.root, PATH: f.root + ':' + process.env.PATH, GEMINI_CLI_HOME: f.root, TEST_CAPTURE: f.capture };
92
+ const imported = await run(['skills', 'import', 'gateway', source], env); assert.equal(imported.code, 0, imported.output);
93
+ const reference = imported.output.trim(); assert.match(reference, /^library:gateway@[a-f0-9]{64}$/);
94
+ const listed = await run(['skills', 'list'], env); assert.deepEqual(JSON.parse(listed.output), [reference]);
95
+ const launched = await run(['agent', agent, '--skill', reference], env); assert.equal(launched.code, 0, launched.output);
96
+ const captured = JSON.parse(readFileSync(f.capture, 'utf8'));
97
+ assert.equal(captured.task.instructions, '# Library task\nRead references/profile.md.');
98
+ assert.equal(readFileSync(join(captured.task.baseDirectory, 'references/profile.md'), 'utf8'), 'Model A');
99
+ assert.ok(captured.task.baseDirectory.includes(reference.split('@')[1]));
100
+ });
101
+
102
+ test('termination also removes the skill snapshot', { skip: process.platform === 'win32', timeout: 10000 }, async () => {
103
+ const f = fixture(), source = join(f.root, 'task.md'); writeFileSync(source, '# Test task');
104
+ const child = spawn(process.execPath, [cli, 'agent', 'codex', '--skill', source], { env: { ...process.env, HOME: f.root, PATH: f.root + ':' + process.env.PATH, TEST_CAPTURE: f.capture, TEST_WAIT: '1' }, stdio: 'ignore' }); const exit = new Promise<number | null>(resolveExit => child.once('close', resolveExit));
105
+ try { for (let i = 0; i < 100 && !existsSync(f.capture); i++) await new Promise(resolveWait => setTimeout(resolveWait, 20)); assert.ok(existsSync(f.capture)); const captured = JSON.parse(readFileSync(f.capture, 'utf8')); child.kill('SIGTERM'); assert.equal(await exit, 23); assert.equal(existsSync(captured.taskPath), false); }
106
+ finally { child.kill('SIGKILL'); }
107
+ });
108
+
109
+ for (const agent of ['codex', 'claude', 'gemini']) test(`selected startup task reaches a remote repair and verification over real MCP for ${agent}`, { skip: process.platform === 'win32', timeout: 15000 }, async () => {
110
+ const { createRelay } = await import('../dist/relay.js'), { createCode } = await import('../dist/crypto.js'), { Peer } = await import('../dist/peer.js'), { ProbeEngine } = await import('../dist/engine.js'), { Audit } = await import('../dist/util.js');
111
+ const f = fixture(), task = join(f.root, 'repair.md'), target = join(f.root, 'remote-config.txt'); writeFileSync(task, '# STARTUP_WORKFLOW_ACCEPTANCE\nRepair the scratch configuration and read it back to verify.'); writeFileSync(target, 'broken');
112
+ const relay = createRelay({ port: 0 }), url = `ws://127.0.0.1:${await relay.listen()}`, code = createCode(), stages: string[] = [];
113
+ const host = new Peer({ role: 'host', code, relay: url, accept: async () => true }); const engine = new ProbeEngine(host, async request => { stages.push(request.stage); return request.task.operation === 'batch.run' && request.task.arguments.steps.every(step => 'path' in step.arguments && step.arguments.path === target); }, new Audit(join(f.root, 'audit.jsonl')), () => {}); await host.open();
114
+ try {
115
+ const result = await run(['agent', agent, '--skill', task, '--relay', url], { ...process.env, HOME: f.root, PATH: f.root + ':' + process.env.PATH, GEMINI_CLI_HOME: f.root, TEST_CAPTURE: f.capture, TEST_PAIR_CODE: code, TEST_REMOTE_TARGET: target });
116
+ assert.equal(result.code, 0, result.output); const captured = JSON.parse(readFileSync(f.capture, 'utf8')); assert.equal(captured.workflow.result.status, 'ok'); assert.equal(captured.workflow.outputs['1.file'], 'fixed'); assert.equal(readFileSync(target, 'utf8'), 'fixed'); assert.deepEqual(stages, ['execute', 'send']); assert.ok(!captured.args.join(' ').includes(code));
117
+ } finally { engine.cancelAll(); host.close(); await relay.close(); }
118
+ });
119
+
120
+ for (const agent of ['codex', 'claude', 'gemini']) test(`agent ${agent} starts the selected case with its pinned skill`, { skip: process.platform === 'win32', timeout: 15000 }, async () => {
121
+ const { Cases } = await import('../dist/cases.js'), { SkillLibrary } = await import('../dist/skill-library.js');
122
+ const f = fixture(), source = join(f.root, 'task.md'); writeFileSync(source, '# Case procedure');
123
+ const reference = await new SkillLibrary(join(f.root, '.diagnose', 'skills')).import('gateway', source);
124
+ const selected = new Cases(join(f.root, '.diagnose', 'cases')).create({ goal: 'Check device logs', target: { name: 'Gateway', interface: 'serial' }, skill: reference });
125
+ const env = { ...process.env, HOME: f.root, PATH: f.root + ':' + process.env.PATH, GEMINI_CLI_HOME: f.root, TEST_CAPTURE: f.capture };
126
+ const result = await run(['agent', agent, '--case', selected.id], env); assert.equal(result.code, 0, result.output);
127
+ const captured = JSON.parse(readFileSync(f.capture, 'utf8')); assert.equal(captured.task.libraryReference, reference); assert.deepEqual(captured.server.args.slice(-2), ['--case', selected.id]);
128
+ const conflict = await run(['agent', agent, '--case', selected.id, '--skill', source], env); assert.equal(conflict.code, 1); assert.match(conflict.output, /revision differs/);
129
+ });
package/test/cli.test.ts CHANGED
@@ -17,7 +17,7 @@ test('actual host CLI displays and enforces pairing, execution and transfer prom
17
17
  let codeResolve!: (value: string) => void;
18
18
  const code = new Promise<string>(resolve => { codeResolve = resolve; });
19
19
  child.stdout.on('data', bytes => {
20
- text += bytes.toString(); const match = /D1\.[A-Za-z0-9_-]{16}\.[A-Za-z0-9_-]{43}/.exec(text); if (match) codeResolve(match[0]);
20
+ text += bytes.toString(); const match = /\b[a-z]{3}-[a-z]{3}-[a-z]{3}\b/.exec(text); if (match) codeResolve(match[0]);
21
21
  if (!pairing && text.includes('Allow this temporary diagnostic session?')) { pairing = true; child.stdin.write('y\n'); }
22
22
  if (!executing && text.includes('Allow exactly this operation?')) { executing = true; child.stdin.write('y\n'); }
23
23
  if (!sending && text.includes('Send these results (')) { sending = true; child.stdin.write('y\n'); }
@@ -39,7 +39,7 @@ test('host CLI auto selection skips task prompts, can revoke, and requires local
39
39
  const code = new Promise<string>(resolve => { resolveCode = resolve; });
40
40
  child.stderr.resume();
41
41
  child.stdout.on('data', bytes => {
42
- output += bytes.toString(); const match = /D1\.[A-Za-z0-9_-]{16}\.[A-Za-z0-9_-]{43}/.exec(output); if (match) resolveCode(match[0]);
42
+ output += bytes.toString(); const match = /\b[a-z]{3}-[a-z]{3}-[a-z]{3}\b/.exec(output); if (match) resolveCode(match[0]);
43
43
  if (!paired && output.includes('Allow this temporary diagnostic session?')) { paired = true; child.stdin.write('a\n'); }
44
44
  const executionCount = output.split('Allow exactly this operation?').length - 1;
45
45
  if (executionCount > executionPrompts) { executionPrompts = executionCount; child.stdin.write('n\n'); }
@@ -75,7 +75,7 @@ test('host CLI re-pairs after disconnect and resumes retained process without re
75
75
  const childHome = mkdtempSync(join(tmpdir(), 'diagnose-repair-')), relay = createRelay({ port: 0 }), url = `ws://127.0.0.1:${await relay.listen()}`;
76
76
  const child = spawn('/bin/sh', ['-c', 'cat | /usr/bin/script -q /dev/null "$@"', 'repair-test', process.execPath, 'dist/cli.js', 'start', url], { detached: true, env: { ...process.env, HOME: childHome }, stdio: ['pipe', 'pipe', 'pipe'] });
77
77
  let output = '', approvals = 0; child.stderr.resume(); child.stdout.on('data', bytes => { output += bytes.toString(); const count = output.split('Allow this temporary diagnostic session?').length - 1; if (count > approvals) { approvals = count; child.stdin.write('a\n'); } });
78
- const codes = () => [...new Set(output.match(/D1\.[A-Za-z0-9_-]{16}\.[A-Za-z0-9_-]{43}/g) ?? [])];
78
+ const codes = () => [...new Set(output.match(/\b[a-z]{3}-[a-z]{3}-[a-z]{3}\b/g) ?? [])];
79
79
  const until = async (predicate: () => boolean) => { for (let n = 0; n < 200 && !predicate(); n++) await new Promise(resolve => setTimeout(resolve, 20)); assert.ok(predicate(), output); };
80
80
  let peer: Peer | undefined;
81
81
  try {
@@ -0,0 +1,37 @@
1
+ import { test } from 'node:test';
2
+ import assert from 'node:assert/strict';
3
+ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
4
+ import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
5
+ import { mkdtemp, rm } from 'node:fs/promises';
6
+ import { tmpdir } from 'node:os';
7
+ import { join, resolve } from 'node:path';
8
+ import { createRelay } from '../dist/relay.js';
9
+ import { createCode } from '../dist/crypto.js';
10
+ import { Peer } from '../dist/peer.js';
11
+ import { ProbeEngine } from '../dist/engine.js';
12
+ import { Audit } from '../dist/util.js';
13
+
14
+ test('real MCP case records received tasks, reports verification and proposes an unaccepted skill', async t => {
15
+ const root = await mkdtemp(join(tmpdir(), 'diagnose-case-mcp-')); t.after(() => rm(root, { recursive: true, force: true }));
16
+ const relay = createRelay({ port: 0 }), url = 'ws://127.0.0.1:' + await relay.listen(), code = createCode();
17
+ const host = new Peer({ role: 'host', code, relay: url, accept: async () => true });
18
+ new ProbeEngine(host, async request => request.task.operation === 'system.inspect', new Audit(join(root, 'audit.jsonl'))); await host.open();
19
+ const client = new Client({ name: 'knowledge-workflow', version: '1' });
20
+ const transport = new StdioClientTransport({ command: process.execPath, args: [resolve('dist/cli.js'), 'mcp', url], env: { ...process.env, HOME: root, USERPROFILE: root } as Record<string, string>, stderr: 'pipe' });
21
+ const call = async (name: string, args: Record<string, unknown>) => { const value = await client.callTool({ name, arguments: args }); assert.ok(!value.isError, JSON.stringify(value)); return JSON.parse((value.content as { text: string }[])[0].text); };
22
+ try {
23
+ await client.connect(transport);
24
+ const names = (await client.listTools()).tools.map(item => item.name); assert.ok(!names.some(name => name.includes('accept') || name.includes('vault')));
25
+ const capabilities = await call('diagnose_capabilities', { operation: 'serial.capture' }); assert.ok(capabilities.operations[0].arguments.properties.baudRate);
26
+ const selected = await call('diagnose_case', { action: 'create', input: { goal: 'Verify interface inspection', host: 'workshop-laptop', target: { name: 'Gateway', model: 'SEG-X3-C', interface: 'serial' } } });
27
+ await call('diagnose_pair', { code, label: 'Acceptance test' });
28
+ for (let i = 0; i < 2; i++) { const task = await call('diagnose_start', { operation: 'system.inspect', arguments: {}, reason: 'Read-only interface inventory' }); const result = await call('diagnose_wait', { id: task.id, timeoutMs: 5000 }); assert.equal(result.result.status, 'ok'); }
29
+ const snapshot = await call('diagnose_case', { action: 'show' }), results = snapshot.case.evidence.filter((item: { kind: string }) => item.kind === 'task.result');
30
+ assert.equal(results.length, 2); assert.ok(!('data' in results[0]));
31
+ const status = await call('diagnose_case', { action: 'status' }); assert.equal(status.probe, 'connected'); assert.equal(status.target.model, 'SEG-X3-C');
32
+ const report = await call('diagnose_case', { action: 'finish', conclusion: { outcome: 'resolved', summary: 'Interface inspection works; device functionality not tested', baseline: results[0].id, verification: results[1].id } }); assert.equal(report.report.conclusion.outcome, 'resolved');
33
+ const draft = await call('diagnose_skill_draft', { name: 'interface-check', caseId: selected.case.id, evidence: [results[0].id], title: 'Inspect gateway interfaces', applicability: 'Gateway attached to an on-site host', prerequisites: 'User consent', identityChecks: 'Confirm model and serial number', readOnlyChecks: 'Use system.inspect; do not scan or open ports automatically', repairConditions: 'No repair authorized by this procedure', recovery: 'Stop if identity differs', verification: 'Confirm selected interface is listed', failedApproaches: 'An interface listing does not verify gateway health' });
34
+ assert.equal(draft.state, 'pending'); assert.deepEqual((await call('diagnose_skills', {})).references, []);
35
+ await call('diagnose_disconnect', {});
36
+ } finally { await client.close(); host.close(); await relay.close(); }
37
+ });
@@ -0,0 +1,112 @@
1
+ import { test } from 'node:test';
2
+ import assert from 'node:assert/strict';
3
+ import { mkdtemp, mkdir, writeFile, readFile, readdir, rm } from 'node:fs/promises';
4
+ import { join } from 'node:path';
5
+ import { tmpdir } from 'node:os';
6
+ import { randomUUID } from 'node:crypto';
7
+ import { Cases } from '../dist/cases.js';
8
+ import { Drafts } from '../dist/knowledge-drafts.js';
9
+ import { SkillLibrary } from '../dist/skill-library.js';
10
+ import { Vault } from '../dist/vault.js';
11
+ import { newRecovery, vaultKeys, objectId, sealBundle, openBundle } from '../dist/vault-crypto.js';
12
+ import { createRelay } from '../dist/relay.js';
13
+
14
+ async function fixture(t: { after: (fn: () => Promise<void>) => void }) { const root = await mkdtemp(join(tmpdir(), 'diagnose-knowledge-')); t.after(() => rm(root, { recursive: true, force: true })); return root; }
15
+ test('case records actual evidence, excludes credentials and requires later verification', async t => {
16
+ const root = await fixture(t), cases = new Cases(join(root, 'cases'));
17
+ const value = cases.create({ goal: 'Restore readings', host: 'site-pc', target: { name: 'Gateway', model: 'SEG-X3-C', interface: 'serial', address: '/dev/private-address' } });
18
+ const baseline = cases.record(value.id, 'task.result', { result: { status: 'ok' }, outputs: { log: 'No readings' }, resumeToken: 'private-resume-token' }, randomUUID())!;
19
+ assert.throws(() => cases.finish(value.id, { outcome: 'resolved', summary: 'Fixed', baseline: baseline.id, verification: baseline.id, changes: [], remaining: [] }), /distinct/);
20
+ const after = cases.record(value.id, 'task.result', { result: { status: 'ok' }, outputs: { log: 'Readings received' } }, randomUUID())!;
21
+ cases.finish(value.id, { outcome: 'resolved', summary: 'Readings verified', baseline: baseline.id, verification: after.id, changes: ['Reconnected sensor'], remaining: [] });
22
+ assert.equal(cases.get(value.id).target.model, 'SEG-X3-C');
23
+ assert.ok(!JSON.stringify(cases.get(value.id)).includes('private-resume-token'));
24
+ const report = JSON.stringify(cases.report(value.id)); assert.ok(!report.includes('/dev/private-address')); assert.ok(!report.includes('Readings received')); assert.ok(report.includes(after.id));
25
+ const bytes = await readFile(join(root, 'cases', value.id + '.meta')); assert.ok(!bytes.includes(Buffer.from('SEG-X3-C')));
26
+ });
27
+
28
+ test('reviewed drafts preserve references, retain base revision and detect conflicting versions', async t => {
29
+ const root = await fixture(t), source = join(root, 'source'); await mkdir(join(source, 'references'), { recursive: true });
30
+ await writeFile(join(source, 'SKILL.md'), '# Original\n'); await writeFile(join(source, 'references/profile.md'), 'Model SEG-X3-C');
31
+ const library = new SkillLibrary(join(root, 'skills')), base = await library.import('owon', source), cases = new Cases(join(root, 'cases'));
32
+ const value = cases.create({ goal: 'Observe logs', target: { name: 'Gateway', interface: 'serial' }, skill: base });
33
+ const evidence = cases.record(value.id, 'task.result', { result: { status: 'ok' }, outputs: { serial: 'fixture evidence only' } })!;
34
+ const drafts = new Drafts(library, cases, join(root, 'drafts'));
35
+ const input = { name: 'owon', caseId: value.id, base, evidence: [evidence.id], title: 'OWON checks', applicability: 'SEG-X3-C', prerequisites: 'Authorized serial adapter', identityChecks: 'Confirm serial number', readOnlyChecks: 'Capture logs without writes', repairConditions: 'Only after approval', recovery: 'Stop capture', verification: 'Repeat original check', failedApproaches: 'USB power alone is not diagnostic access' };
36
+ const first = await drafts.create(input), conflicting = await drafts.create(input);
37
+ assert.match(await drafts.review(first.id), /- # Original/);
38
+ assert.deepEqual(await library.list(), [base]);
39
+ const accepted = await drafts.accept(first.id); assert.notEqual(accepted, base);
40
+ assert.equal(await readFile(join((await library.load(accepted)).baseDirectory, 'references/profile.md'), 'utf8'), 'Model SEG-X3-C');
41
+ assert.ok(!(await library.load(accepted)).instructions.includes('fixture evidence only'));
42
+ await assert.rejects(drafts.accept(conflicting.id), /versions changed/); assert.equal(drafts.get(conflicting.id).state, 'pending');
43
+ drafts.reject(conflicting.id); assert.equal(drafts.get(conflicting.id).state, 'rejected');
44
+ await assert.rejects(drafts.create({ ...input, evidence: [randomUUID()] }), /belong/);
45
+ });
46
+
47
+ test('vault AEAD binds key, object and namespace; pairing codes are not recovery keys', () => {
48
+ const recovery = newRecovery(), id = objectId(recovery, 'reference'), bytes = Buffer.from('private skill');
49
+ const sealed = sealBundle(recovery, id, bytes); assert.deepEqual(openBundle(recovery, id, sealed), bytes);
50
+ assert.throws(() => openBundle(newRecovery(), id, sealed)); assert.throws(() => openBundle(recovery, '0'.repeat(64), sealed));
51
+ const altered = Buffer.from(sealed); altered[15] ^= 1; assert.throws(() => openBundle(recovery, id, altered));
52
+ assert.throws(() => vaultKeys('D1.' + 'a'.repeat(16) + '.' + 'b'.repeat(43)), /recovery/);
53
+ assert.notEqual(vaultKeys(recovery).auth, recovery.slice(3));
54
+ });
55
+
56
+ test('two isolated clients sync encrypted complete versions, preserve divergence, revoke and recover offline', async t => {
57
+ const root = await fixture(t), relay = createRelay({ port: 0, vaultPath: join(root, 'relay') }); const origin = 'http://127.0.0.1:' + await relay.listen(); t.after(() => relay.close());
58
+ const libraryA = new SkillLibrary(join(root, 'a-skills')), libraryB = new SkillLibrary(join(root, 'b-skills'));
59
+ const a = new Vault(libraryA, join(root, 'a-key'), origin), b = new Vault(libraryB, join(root, 'b-key'), origin), recovery = newRecovery(); await a.initialize(recovery); await b.initialize(recovery);
60
+ const source = join(root, 'source'); await mkdir(join(source, 'scripts'), { recursive: true }); await writeFile(join(source, 'SKILL.md'), '# Private device procedure'); await writeFile(join(source, 'scripts/check.sh'), 'echo safe');
61
+ const first = await libraryA.import('gateway', source); await a.push(first); await a.push(first);
62
+ assert.deepEqual(await b.pull(), [first]); assert.equal(await readFile(join((await libraryB.load(first)).baseDirectory, 'scripts/check.sh'), 'utf8'), 'echo safe');
63
+ await writeFile(join(source, 'SKILL.md'), '# Client A improvement'); const second = await libraryA.import('gateway', source);
64
+ await writeFile(join(source, 'SKILL.md'), '# Client B improvement'); const third = await libraryB.import('gateway', source);
65
+ await Promise.all([a.push(second), b.push(third)]); assert.deepEqual((await a.pull()).sort(), [first, second, third].sort());
66
+ const namespace = vaultKeys(recovery).namespace;
67
+ for (const name of await readdir(join(root, 'relay', namespace))) { const bytes = await readFile(join(root, 'relay', namespace, name)); assert.ok(!bytes.includes(Buffer.from('Private device'))); assert.ok(!bytes.includes(Buffer.from('gateway'))); }
68
+ const unauthenticated = await fetch(origin + '/v1/library'); assert.equal(unauthenticated.status, 401);
69
+ const backup = join(root, 'recovery-backup'); await a.backup(backup); assert.equal((await readFile(backup, 'utf8')).trim(), recovery);
70
+ await a.revoke(); await assert.rejects(b.list(), /403/); await assert.rejects(b.push(first), /403/);
71
+ assert.ok((await libraryB.load(first)).instructions.includes('Private device')); // cache survives revocation
72
+ });
73
+
74
+ test('vault rejects tampered ciphertext before importing and server never replaces immutable objects', async t => {
75
+ const root = await fixture(t), relay = createRelay({ port: 0, vaultPath: join(root, 'relay') }); const origin = 'http://127.0.0.1:' + await relay.listen(); t.after(() => relay.close());
76
+ const recovery = newRecovery(), keys = vaultKeys(recovery), id = 'a'.repeat(64), headers = { Authorization: 'Bearer ' + keys.auth, 'Content-Type': 'application/octet-stream' };
77
+ assert.equal((await fetch(origin + '/v1/library/' + id, { method: 'PUT', headers, body: Buffer.alloc(30) })).status, 201);
78
+ assert.equal((await fetch(origin + '/v1/library/' + id, { method: 'PUT', headers, body: Buffer.alloc(30, 1) })).status, 409);
79
+ const library = new SkillLibrary(join(root, 'skills')), vault = new Vault(library, join(root, 'key'), origin); await vault.initialize(recovery);
80
+ await assert.rejects(vault.pull(), /Invalid encrypted/); assert.deepEqual(await library.list(), []);
81
+ });
82
+
83
+ test('relay rejects over-quota and interrupted uploads without publishing partial objects', async t => {
84
+ const { createServer, request } = await import('node:http');
85
+ const { VaultServer } = await import('../dist/vault-server.js');
86
+ const root = await fixture(t), store = new VaultServer(join(root, 'relay'), 40);
87
+ const server = createServer((req, res) => { void store.handle(req, res); });
88
+ await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve)); t.after(() => new Promise<void>(resolve => server.close(() => resolve())));
89
+ const origin = 'http://127.0.0.1:' + (server.address() as { port: number }).port, recovery = newRecovery(), headers = { Authorization: 'Bearer ' + vaultKeys(recovery).auth };
90
+ const incompleteId = 'b'.repeat(64);
91
+ await new Promise<void>(resolve => { const req = request(origin + '/v1/library/' + incompleteId, { method: 'PUT', headers: { ...headers, 'Content-Length': '40' } }); req.on('error', () => resolve()); req.write(Buffer.alloc(30)); setTimeout(() => { req.destroy(); resolve(); }, 30); });
92
+ await new Promise(resolve => setTimeout(resolve, 30));
93
+ assert.deepEqual((await (await fetch(origin + '/v1/library', { headers })).json() as { objects: unknown[] }).objects, []);
94
+ assert.equal((await fetch(origin + '/v1/library/' + incompleteId, { method: 'PUT', headers, body: Buffer.alloc(30) })).status, 201);
95
+ assert.equal((await fetch(origin + '/v1/library/' + 'c'.repeat(64), { method: 'PUT', headers, body: Buffer.alloc(30) })).status, 507);
96
+ assert.equal((await (await fetch(origin + '/v1/library', { headers })).json() as { objects: unknown[] }).objects.length, 1);
97
+ });
98
+
99
+ test('received bundles cannot traverse directories or import a forged content revision', async t => {
100
+ const root = await fixture(t), library = new SkillLibrary(join(root, 'skills'));
101
+ const reference = 'library:gateway@' + 'a'.repeat(64);
102
+ await assert.rejects(library.restore({ reference, files: [{ path: '../escape.md', data: Buffer.from('# bad').toString('base64') }] }), /path/);
103
+ await assert.rejects(library.restore({ reference, files: [{ path: 'SKILL.md', data: Buffer.from('# valid but wrong digest').toString('base64') }] }), /integrity/);
104
+ assert.deepEqual(await library.list(), []);
105
+ });
106
+
107
+ test('a selected case refuses a second writer and cannot be removed while active', async t => {
108
+ const root = await fixture(t), first = new Cases(join(root, 'cases')), second = new Cases(join(root, 'cases'));
109
+ const value = first.create({ goal: 'Inspect device', target: { name: 'Gateway', interface: 'serial' } });
110
+ const release = first.claim(value.id); assert.throws(() => second.claim(value.id), /writer/); assert.throws(() => second.remove(value.id), /in use/); assert.throws(() => second.unlock(value.id), /still alive/);
111
+ release(); const releaseSecond = second.claim(value.id); releaseSecond(); second.remove(value.id); assert.deepEqual(first.list(), []);
112
+ });
package/test/mcp.test.ts CHANGED
@@ -19,7 +19,7 @@ test('real stdio MCP client pairs, starts, waits and disconnects', async () => {
19
19
  const client = new Client({ name: 'acceptance', version: '1.0.0' });
20
20
  const text = (result: any) => { assert.ok(!result.isError, JSON.stringify(result)); return JSON.parse(result.content[0].text); };
21
21
  try {
22
- await client.connect(transport); assert.deepEqual((await client.listTools()).tools.map(tool => tool.name).sort(), ['diagnose_batch', 'diagnose_cancel', 'diagnose_disconnect', 'diagnose_forward', 'diagnose_pair', 'diagnose_process', 'diagnose_resource', 'diagnose_resume', 'diagnose_start', 'diagnose_transfer', 'diagnose_wait']);
22
+ await client.connect(transport); assert.deepEqual((await client.listTools()).tools.map(tool => tool.name).sort(), ['diagnose_batch', 'diagnose_cancel', 'diagnose_capabilities', 'diagnose_case', 'diagnose_disconnect', 'diagnose_forward', 'diagnose_pair', 'diagnose_process', 'diagnose_resource', 'diagnose_resume', 'diagnose_skill_draft', 'diagnose_skills', 'diagnose_start', 'diagnose_transfer', 'diagnose_wait']);
23
23
  assert.equal(text(await client.callTool({ name: 'diagnose_pair', arguments: { code, label: 'MCP test' } })).connected, true);
24
24
  const { id } = text(await client.callTool({ name: 'diagnose_start', arguments: { operation: 'system.inspect', arguments: {}, reason: 'Verify MCP execution' } }));
25
25
  const result = text(await client.callTool({ name: 'diagnose_wait', arguments: { id, timeoutMs: 5000, release: true } }));
@@ -0,0 +1,124 @@
1
+ import { test } from 'node:test';
2
+ import assert from 'node:assert/strict';
3
+ import { mkdtempSync, readFileSync, readdirSync, statSync } from 'node:fs';
4
+ import { tmpdir } from 'node:os';
5
+ import { join } from 'node:path';
6
+ import { PairingStore, automatic, RememberedConnection } from '../dist/pairing.js';
7
+ import { createCode } from '../dist/crypto.js';
8
+ import { createRelay } from '../dist/relay.js';
9
+ import { Peer } from '../dist/peer.js';
10
+ import { ProbeEngine } from '../dist/engine.js';
11
+ import { Audit } from '../dist/util.js';
12
+ const scratch = () => mkdtempSync(join(tmpdir(), 'diagnose-pairing-'));
13
+
14
+ test('pairing credentials survive restart encrypted; grants expire by wall clock; deletion revokes local record', () => {
15
+ const root = scratch(), store = new PairingStore(root), code = createCode();
16
+ const value = store.add({ role: 'operator', name: 'alice-pc', code, relay: 'https://diagnose.fenginwind.com', label: 'support / AI' });
17
+ value.autoUntil = 2000; store.save(value);
18
+ assert.equal(automatic(value, 1999), true); assert.equal(automatic(value, 2000), false);
19
+ value.autoUntil = null; assert.equal(automatic(value), true); value.paused = true; assert.equal(automatic(value), false);
20
+ const restarted = new PairingStore(root); assert.equal(restarted.get('alice-pc', 'operator').code, code);
21
+ for (const name of readdirSync(root).filter(name => name.endsWith('.meta'))) { assert.equal(readFileSync(join(root, name)).includes(Buffer.from(code)), false); if (process.platform !== 'win32') assert.equal(statSync(join(root, name)).mode & 0o777, 0o600); }
22
+ assert.throws(() => store.add({ ...value, name: 'alice-pc' }));
23
+ restarted.remove(value.id); assert.deepEqual(store.list(), []);
24
+ });
25
+
26
+ test('remembered connection reconnects with fresh encryption and never replays a command', { timeout: 15000 }, async () => {
27
+ const root = scratch(), frames: Buffer[] = [], relay = createRelay({ port: 0, observeCiphertext: bytes => frames.push(Buffer.from(bytes)) });
28
+ const url = `ws://127.0.0.1:${await relay.listen()}`, code = createCode();
29
+ const record = new PairingStore(root).add({ role: 'operator', name: 'alice', label: 'test', relay: url, code });
30
+ const connection = new RememberedConnection(record, 3000);
31
+ let approvals = 0;
32
+ const host = () => { const peer = new Peer({ role: 'host', code, relay: url, accept: async () => true }); new ProbeEngine(peer, async () => { approvals++; return true; }, new Audit(join(root, `audit-${Math.random()}`))); return peer; };
33
+ let probe = host(); await probe.open();
34
+ try {
35
+ const first = await connection.connect(), fingerprint = first.peer.fingerprint;
36
+ const result = await first.run({ operation: 'system.inspect', arguments: {}, reason: 'First task' }); assert.equal(result.result.status, 'ok');
37
+ first.peer.close(); await probe.ended; probe.close(); await new Promise(resolve => setTimeout(resolve, 80));
38
+ probe = host(); await probe.open();
39
+ const second = await connection.connect(); assert.notEqual(second, first); assert.notEqual(second.peer.fingerprint, fingerprint);
40
+ assert.equal(approvals, 2, 'reconnection must not replay completed task');
41
+ assert.equal((await second.run({ operation: 'system.inspect', arguments: {}, reason: 'Second task' })).result.status, 'ok'); assert.equal(approvals, 4);
42
+ assert.equal(Buffer.concat(frames).includes(Buffer.from(code)), false);
43
+ connection.close(); await assert.rejects(connection.connect(), /ended/);
44
+ } finally { connection.close(); probe.close(); await relay.close(); }
45
+ });
46
+
47
+ test('actual host survives probe and relay restarts, pauses access, and revokes pairing', { skip: process.platform !== 'darwin', timeout: 25000 }, async () => {
48
+ const { spawn } = await import('node:child_process'); const { resolve } = await import('node:path');
49
+ const root = scratch(); let relay = createRelay({ port: 0 }); const port = await relay.listen(), url = `ws://127.0.0.1:${port}`;
50
+ let output = '', pairPrompts = 0;
51
+ const start = () => {
52
+ const child = spawn('/bin/sh', ['-c', 'cat | /usr/bin/script -q /dev/null "$@"', 'remember-test', process.execPath, resolve('dist/cli.js'), 'start', url], { detached: true, env: { ...process.env, HOME: root }, stdio: ['pipe', 'pipe', 'pipe'] });
53
+ child.stderr.resume(); child.stdout.on('data', bytes => { output += bytes.toString(); if (output.includes('Remember and allow this diagnostician?') && !pairPrompts) { pairPrompts++; child.stdin.write('a\n'); } }); return child;
54
+ };
55
+ let child = start(), peer: Peer | undefined;
56
+ const until = async (predicate: () => boolean) => { for (let i = 0; i < 300 && !predicate(); i++) await new Promise(resolve => setTimeout(resolve, 20)); assert.ok(predicate(), output); };
57
+ const stop = async () => { const ended = new Promise(resolve => child.once('exit', resolve)); if (child.pid) try { process.kill(-child.pid, 'SIGTERM'); } catch {} await ended; };
58
+ try {
59
+ await until(() => /\b[a-z]{3}-[a-z]{3}-[a-z]{3}\b/.test(output));
60
+ const invitation = output.match(/\b[a-z]{3}-[a-z]{3}-[a-z]{3}\b/)![0];
61
+ peer = new Peer({ role: 'join', code: invitation, relay: url, label: 'Remembered support / test AI', remember: true }); await peer.open();
62
+ const credential = peer.rememberedCode!; assert.ok(credential); assert.notEqual(credential, invitation);
63
+ peer.close(); await until(() => output.includes('Waiting for connections'));
64
+ const store = new PairingStore(join(root, '.diagnose', 'pairings')); const record = store.list('host')[0]; assert.equal(record.code, credential);
65
+ await stop(); output = ''; child = start(); await until(() => output.includes('Waiting for connections'));
66
+ const connection = new RememberedConnection({ ...record, role: 'operator' }, 2000);
67
+ let operator = await connection.connect(); assert.equal((await operator.run({ operation: 'system.inspect', arguments: {}, reason: 'Restart without pairing or approval' })).result.status, 'ok'); assert.equal(pairPrompts, 1);
68
+ child.stdin.write('pause\n'); await until(() => output.includes('Remote access is paused'));
69
+ await operator.peer.ended; await assert.rejects(connection.connect());
70
+ child.stdin.write('resume\n'); await until(() => output.split('Waiting for connections').length >= 3);
71
+ operator = await connection.connect(); assert.equal((await operator.run({ operation: 'system.inspect', arguments: {}, reason: 'Resume without a new code' })).result.status, 'ok');
72
+ await relay.close(); await operator.peer.ended; relay = createRelay({ port }); await relay.listen();
73
+ operator = await connection.connect(); assert.equal((await operator.run({ operation: 'system.inspect', arguments: {}, reason: 'Relay restarted; same pairing and unexpired permission' })).result.status, 'ok');
74
+ child.stdin.write('unpair\n'); await operator.peer.ended; await until(() => output.includes('Pairing revoked'));
75
+ assert.deepEqual(store.list('host'), []); await assert.rejects(connection.connect()); connection.close();
76
+ assert.equal(output.includes(credential), false, 'durable credential must never be printed');
77
+ } finally { peer?.close(); await stop(); await relay.close(); }
78
+ });
79
+
80
+ test('real MCP sessions reuse a saved device; a broken request is not replayed after reconnect', { timeout: 15000 }, async () => {
81
+ const { Client } = await import('@modelcontextprotocol/sdk/client/index.js'); const { StdioClientTransport } = await import('@modelcontextprotocol/sdk/client/stdio.js'); const { resolve } = await import('node:path');
82
+ const root = scratch(), relay = createRelay({ port: 0 }), url = `ws://127.0.0.1:${await relay.listen()}`, code = createCode();
83
+ new PairingStore(join(root, '.diagnose', 'pairings')).add({ role: 'operator', name: 'alice', label: 'test', relay: url, code });
84
+ let count = 0;
85
+ const host = () => { const peer = new Peer({ role: 'host', code, relay: url, accept: async () => true }); new ProbeEngine(peer, async () => true, new Audit(join(root, `audit-${Math.random()}`))); peer.on('message', message => { if (message.type === 'task.request') count++; }); return peer; };
86
+ let probe = host(); await probe.open();
87
+ const session = async () => { const client = new Client({ name: 'remembered-test', version: '1' }); await client.connect(new StdioClientTransport({ command: process.execPath, args: [resolve('dist/cli.js'), 'mcp', '--device', 'alice'], env: { ...process.env, HOME: root } as Record<string, string>, stderr: 'pipe' })); return client; };
88
+ const value = (result: any) => { assert.ok(!result.isError, JSON.stringify(result)); return JSON.parse(result.content[0].text); };
89
+ let client = await session();
90
+ try {
91
+ const task = value(await client.callTool({ name: 'diagnose_start', arguments: { operation: 'system.inspect', arguments: {}, reason: 'Saved device, no code' } })); assert.equal(value(await client.callTool({ name: 'diagnose_wait', arguments: { id: task.id, timeoutMs: 3000 } })).result.status, 'ok');
92
+ await client.close(); await probe.ended; await new Promise(resolve => setTimeout(resolve, 80)); probe = host(); await probe.open(); client = await session();
93
+ const slow = value(await client.callTool({ name: 'diagnose_start', arguments: { operation: 'process.script', arguments: { interpreter: process.execPath, script: 'setTimeout(()=>{},10000)' }, reason: 'Interrupt without replay' } }));
94
+ probe.close(); await probe.ended; await new Promise(resolve => setTimeout(resolve, 80)); probe = host(); await probe.open();
95
+ const next = value(await client.callTool({ name: 'diagnose_start', arguments: { operation: 'system.inspect', arguments: {}, reason: 'Reconnect for new work only' } })); assert.equal(value(await client.callTool({ name: 'diagnose_wait', arguments: { id: next.id, timeoutMs: 3000 } })).result.status, 'ok');
96
+ assert.equal(count, 3); const lost = await client.callTool({ name: 'diagnose_wait', arguments: { id: slow.id } }); assert.equal(lost.isError, true);
97
+ } finally { await client.close(); probe.close(); await relay.close(); }
98
+ });
99
+
100
+ test('pair CLI saves a separately provisioned credential and lists only safe metadata', { skip: process.platform !== 'darwin', timeout: 12000 }, async () => {
101
+ const { spawn } = await import('node:child_process'); const { resolve } = await import('node:path');
102
+ const root = scratch(), relay = createRelay({ port: 0 }), url = `ws://127.0.0.1:${await relay.listen()}`, code = createCode(), credential = createCode();
103
+ let requestedRemember = false;
104
+ const host = new Peer({ role: 'host', code, relay: url, provision: () => credential, accept: async ({ remember }) => { requestedRemember = remember; return true; } }); await host.open();
105
+ const child = spawn('/bin/sh', ['-c', 'cat | /usr/bin/script -q /dev/null "$@"', 'pair-cli-test', process.execPath, resolve('dist/cli.js'), 'pair', url, '--name', 'alice-pc'], { detached: true, env: { ...process.env, HOME: root }, stdio: ['pipe', 'pipe', 'pipe'] });
106
+ let output = '', stage = 0; child.stderr.resume(); child.stdout.on('data', bytes => { output += bytes.toString(); if (!stage && output.includes('Pairing code:')) { stage = 1; child.stdin.write(code + '\n'); } if (stage === 1 && output.includes('Your label')) { stage = 2; child.stdin.write('Support / AI provider\n'); } if (stage === 2 && output.includes('Paired. Start diagnosis')) { stage = 3; child.stdin.end(); } });
107
+ const timer = setTimeout(() => { if (child.pid) try { process.kill(-child.pid, 'SIGTERM'); } catch {} }, 8000);
108
+ try {
109
+ const exit = await new Promise(resolve => child.once('exit', resolve)); assert.equal(exit, 0, output); assert.equal(requestedRemember, true);
110
+ const saved = new PairingStore(join(root, '.diagnose', 'pairings')).get('alice-pc', 'operator'); assert.equal(saved.code, credential); assert.equal(output.includes(credential), false);
111
+ const listing = spawn(process.execPath, [resolve('dist/cli.js'), 'devices'], { env: { ...process.env, HOME: root } }); let metadata = ''; listing.stdout.on('data', bytes => metadata += bytes); await new Promise(resolve => listing.once('exit', resolve)); assert.equal(JSON.parse(metadata)[0].name, 'alice-pc'); assert.equal(metadata.includes(credential), false);
112
+ } finally { clearTimeout(timer); host.close(); if (child.pid) try { process.kill(-child.pid, 'SIGTERM'); } catch {} await relay.close(); }
113
+ });
114
+
115
+ for (const lifetime of [-1, 1500]) test(`remembered auto grant (${lifetime > 0 ? 'timer expiry' : 'already expired'}) requires approval after probe restart`, { skip: process.platform !== 'darwin', timeout: 12000 }, async () => {
116
+ const { spawn } = await import('node:child_process'); const { resolve } = await import('node:path');
117
+ const root = scratch(), relay = createRelay({ port: 0 }), url = `ws://127.0.0.1:${await relay.listen()}`, code = createCode();
118
+ const store = new PairingStore(join(root, '.diagnose', 'pairings')), record = store.add({ role: 'host', name: 'diagnostician', label: 'test', relay: url, code }); record.autoUntil = Date.now() + lifetime; store.save(record);
119
+ const child = spawn('/bin/sh', ['-c', 'cat | /usr/bin/script -q /dev/null "$@"', 'expiry-test', process.execPath, resolve('dist/cli.js'), 'start', url], { detached: true, env: { ...process.env, HOME: root }, stdio: ['pipe', 'pipe', 'pipe'] });
120
+ let output = '', prompts = 0; child.stderr.resume(); child.stdout.on('data', bytes => { output += bytes.toString(); if (output.includes('Allow exactly this operation?') && !prompts) { prompts++; child.stdin.write('n\n'); } });
121
+ const connection = new RememberedConnection({ ...record, role: 'operator' }, 4000);
122
+ try { const operator = await connection.connect(); if (lifetime > 0) { for (let i = 0; i < 150 && !output.includes('Permission mode: ask'); i++) await new Promise(resolve => setTimeout(resolve, 20)); assert.ok(output.includes('Permission mode: ask')); } const result = await operator.run({ operation: 'system.inspect', arguments: {}, reason: 'Expired auto must not renew' }); assert.equal(result.result.status, 'denied'); assert.equal(prompts, 1); assert.equal(output.includes('Pairing code ('), false); }
123
+ finally { connection.close(); if (child.pid) try { process.kill(-child.pid, 'SIGTERM'); } catch {} await relay.close(); }
124
+ });