deadbyte-mcp 0.14.0 → 0.15.1

package/test/skill-plane-r44.test.mjs

@@ -0,0 +1,93 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash, createPrivateKey, sign as cryptoSign } from 'node:crypto';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { generateTrustKeypair } from '../src/trust.mjs';
+import { createSkillPlane } from '../src/skill-plane-r44.mjs';
+
+const DOMAIN=Buffer.from('DEADBYTE-SKILL-MANIFEST-V1\0','utf8');
+const sha=bytes=>createHash('sha256').update(bytes).digest('hex');
+const canonical=value=>Array.isArray(value)?value.map(canonical):value&&typeof value==='object'
+  ?Object.fromEntries(Object.keys(value).sort().map(key=>[key,canonical(value[key])])):value;
+const canonicalJson=value=>JSON.stringify(canonical(value));
+
+async function fixture(){
+  const root=await mkdtemp(path.join(os.tmpdir(),'deadbyte-r44-skill-'));
+  const registry=path.join(root,'skills');
+  const trust=path.join(root,'trust');
+  await mkdir(registry,{recursive:true});await mkdir(trust,{recursive:true});
+  const keys=await generateTrustKeypair({privateKeyPath:path.join(trust,'private.pem'),publicKeyPath:path.join(trust,'public.pem')});
+  return {root,registry,keys};
+}
+async function installSkill(f,{name='repo-audit',authorityPlanes=['coding'],requiredCapabilities=['coding.search'],extraBody={}}={}){
+  const dir=path.join(f.registry,name);await mkdir(path.join(dir,'references'),{recursive:true});
+  const skill=`---\nname: ${name}\ndescription: Audit one repository with bounded evidence\nversion: 1.0.0\naudience: agent\n---\n\n# Repo Audit\n\nInspect before mutation.\n`;
+  const ref='Use bounded search and cite exact observed files.\n';
+  await writeFile(path.join(dir,'SKILL.md'),skill,'utf8');
+  await writeFile(path.join(dir,'references','guide.md'),ref,'utf8');
+  const body={
+    schema:'deadbyte.skill-manifest.v1',name,version:'1.0.0',description:'Audit one repository with bounded evidence',audience:'agent',
+    skill_md_sha256:sha(Buffer.from(skill)),resources:[{path:'references/guide.md',sha256:sha(Buffer.from(ref)),kind:'reference'}],
+    required_capabilities:requiredCapabilities,authority_planes:authorityPlanes,
+    provenance:{source:'test-fixture',origin_url:null,source_revision:null},...extraBody
+  };
+  const bodyBytes=Buffer.from(canonicalJson(body),'utf8');
+  const privateKey=createPrivateKey(await readFile(f.keys.privateKeyPath));
+  const envelope={body,body_sha256:sha(bodyBytes),attestation:{algorithm:'ed25519',domain:'DEADBYTE-SKILL-MANIFEST-V1',
+    key_id:f.keys.keyId,signature_base64:cryptoSign(null,Buffer.concat([DOMAIN,bodyBytes]),privateKey).toString('base64')}};
+  envelope.manifest_sha256=sha(Buffer.from(canonicalJson(envelope),'utf8'));
+  await writeFile(path.join(dir,'skill.json'),`${JSON.stringify(envelope,null,2)}\n`,'utf8');
+  return {dir,skill,ref,envelope};
+}
+
+test('R44 skill catalog is metadata-only and load is signature/content bound',async()=>{
+  const f=await fixture();
+  try{
+    await installSkill(f,{});
+    const plane=await createSkillPlane({root:f.registry,verifyKeyPath:f.keys.publicKeyPath});
+    const listed=await plane.list();
+    assert.equal(listed.status,'ok');assert.equal(listed.skills.length,1);
+    assert.equal(listed.skills[0].name,'repo-audit');assert.equal(listed.skills[0].authority_planes[0],'coding');
+    assert.equal('content' in listed.skills[0],false,'catalog must not leak instructions');
+    const loaded=await plane.load({name:'repo-audit'});
+    assert.equal(loaded.status,'ok');assert.match(loaded.content,/Inspect before mutation/);
+    assert.equal(loaded.verified,true);assert.match(loaded.manifest_sha256,/^[0-9a-f]{64}$/);
+    const resource=await plane.readResource({name:'repo-audit',resourcePath:'references/guide.md'});
+    assert.equal(resource.content,'Use bounded search and cite exact observed files.\n');
+    assert.equal(typeof plane.arm,'undefined');assert.equal(typeof plane.renew,'undefined');
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});
+
+test('R44 skill plane fails closed on SKILL.md and resource tampering',async()=>{
+  const f=await fixture();
+  try{
+    const installed=await installSkill(f,{});
+    const plane=await createSkillPlane({root:f.registry,verifyKeyPath:f.keys.publicKeyPath});
+    await writeFile(path.join(installed.dir,'SKILL.md'),'tampered\n','utf8');
+    await assert.rejects(plane.load({name:'repo-audit'}),/SKILL\.md hash mismatch/);
+    await installSkill(f,{});
+    await writeFile(path.join(installed.dir,'references','guide.md'),'tampered\n','utf8');
+    await assert.rejects(plane.readResource({name:'repo-audit',resourcePath:'references/guide.md'}),/resource hash mismatch/);
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});
+
+test('R44 skill plane rejects undeclared payloads, unknown authority and signature drift',async()=>{
+  const f=await fixture();
+  try{
+    const installed=await installSkill(f,{});
+    let plane=await createSkillPlane({root:f.registry,verifyKeyPath:f.keys.publicKeyPath});
+    await writeFile(path.join(installed.dir,'hidden.ps1'),'Write-Host pwn\n','utf8');
+    await assert.rejects(plane.load({name:'repo-audit'}),/undeclared skill file/);
+    await rm(path.join(installed.dir,'hidden.ps1'));
+    await installSkill(f,{authorityPlanes:['root']});
+    await assert.rejects(plane.load({name:'repo-audit'}),/unknown authority plane/);
+    await installSkill(f,{});
+    const env=JSON.parse(await readFile(path.join(installed.dir,'skill.json'),'utf8'));
+    env.body.description='signature drift';
+    await writeFile(path.join(installed.dir,'skill.json'),JSON.stringify(env,null,2)+'\n');
+    plane=await createSkillPlane({root:f.registry,verifyKeyPath:f.keys.publicKeyPath});
+    await assert.rejects(plane.load({name:'repo-audit'}),/body hash mismatch/);
+  }finally{await rm(f.root,{recursive:true,force:true});}
+});

package/test/standing-grants.test.mjs

@@ -4,7 +4,7 @@ import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { loadCodingPolicy, codingSessionStatus } from '../src/coding-plane.mjs';
-import { loadAutonomousPolicy, autonomousSessionStatus } from '../src/autonomous-policy.mjs';
+import { assertAutonomousArmed, loadAutonomousPolicy, autonomousSessionStatus, recheckAutonomousAuthority } from '../src/autonomous-policy.mjs';
 import { loadHostPolicy, assertHostArmed } from '../src/host-plane.mjs';
 import { createHash } from 'node:crypto';
 
@@ -48,6 +48,10 @@ test('autonomous standing grant remains armed until explicit revocation', async
   assert.equal(status.armed, true);
   assert.equal(status.reason, 'standing-grant');
   assert.equal(status.expires_at_utc, null);
+  const initial = await assertAutonomousArmed(policy, 'project', farFuture);
+  const grant = JSON.parse(await import('node:fs/promises').then(fs => fs.readFile(policy.lease_file, 'utf8')));
+  await writeFile(policy.lease_file, JSON.stringify({ ...grant, instance_nonce:'d'.repeat(64) }));
+  await assert.rejects(() => recheckAutonomousAuthority(policy, initial, 'project', farFuture), /autonomous authority changed during operation/);
 });
 test('host standing grant remains armed until explicit revocation', async () => {
   const root = await mkdtemp(path.join(os.tmpdir(), 'deadbyte-host-standing-'));