@inneranimalmedia/agentsam-sdk 2.6.5 → 2.6.8

package/test/runtime-activity.test.mjs

@@ -1,98 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import {
-  canAnimateTerminal,
-  createRuntimeActivity,
-  phaseForRuntimeEvent,
-  renderRuntimeActivityFrame,
-  renderRuntimeActivityPanel,
-  renderRuntimeActivityResult,
-} from '../src/ui/runtime-activity.js';
-import { runLocalAgent } from '../src/commands/shell.js';
-
-test('runtime activity is automatic only in a real interactive terminal', () => {
-  assert.equal(canAnimateTerminal({ stdout: { isTTY: true }, env: { TERM: 'xterm-256color' } }), true);
-  assert.equal(canAnimateTerminal({ stdout: { isTTY: false }, env: { TERM: 'xterm-256color' } }), false);
-  assert.equal(canAnimateTerminal({ stdout: { isTTY: true }, env: { TERM: 'dumb' } }), false);
-  assert.equal(canAnimateTerminal({ stdout: { isTTY: true }, env: { TERM: 'xterm-256color', CI: '1' } }), false);
-});
-
-test('runtime renderer exposes thinking, tool, and context phases without product renderer vocabulary', () => {
-  assert.match(renderRuntimeActivityFrame({ phase: 'thinking', tick: 1, elapsedMs: 1250 }), /Agent Sam/);
-  assert.match(renderRuntimeActivityFrame({ phase: 'thinking', tick: 1, elapsedMs: 1250 }), /thinking/);
-  const panel = renderRuntimeActivityPanel({ phase: 'thinking', tick: 2, elapsedMs: 1250 });
-  assert.match(panel, /Agent Sam/);
-  assert.match(panel, /thinking · working locally/);
-  assert.match(panel, /\(●\)/);
-  assert.equal(panel.split('\n').length, 5);
-  assert.match(renderRuntimeActivityResult({ phase: 'done', elapsedMs: 1250 }), /done/);
-  assert.equal(phaseForRuntimeEvent({ type: 'model.started' }), 'thinking');
-  assert.equal(phaseForRuntimeEvent({ type: 'tool.started', tool: 'git.status' }), 'using git.status');
-  assert.equal(phaseForRuntimeEvent({ type: 'context.compaction.started' }), 'tidying context');
-});
-
-test('runtime activity redraws automatically and restores the cursor', () => {
-  let output = '';
-  let clock = 0;
-  let intervalFn = null;
-  const activity = createRuntimeActivity({
-    write: (text) => { output += text; },
-    interactive: true,
-    now: () => clock,
-    setInterval: (fn) => { intervalFn = fn; return 7; },
-    clearInterval: () => {},
-  });
-
-  activity.start('thinking');
-  clock = 320;
-  intervalFn();
-  activity.update('using repository.snapshot');
-  clock = 840;
-  activity.succeed('done');
-
-  assert.match(output, /thinking/);
-  assert.match(output, /using repository\.snapshot/);
-  assert.match(output, /done/);
-  assert.match(output, /\x1b\[\?25l/);
-  assert.match(output, /\x1b\[\?25h/);
-});
-
-test('/agent starts and completes product activity around the real request', async () => {
-  const phases = [];
-  let output = '';
-  const activity = {
-    start: (phase) => phases.push(`start:${phase}`),
-    succeed: (phase) => phases.push(`success:${phase}`),
-    fail: (phase) => phases.push(`fail:${phase}`),
-  };
-  const fetchImpl = async () => ({
-    ok: true,
-    status: 200,
-    async text() { return JSON.stringify({ ok: true, answer: 'ready' }); },
-  });
-
-  await runLocalAgent('inspect this repo', (text) => { output += text; }, { fetchImpl, activity, interactive: true });
-  assert.deepEqual(phases, ['start:thinking', 'success:done']);
-  assert.match(output, /"answer": "ready"/);
-});
-
-
-test('/agent restores product activity when the response body fails', async () => {
-  const phases = [];
-  const activity = {
-    start: (phase) => phases.push(`start:${phase}`),
-    succeed: (phase) => phases.push(`success:${phase}`),
-    fail: (phase) => phases.push(`fail:${phase}`),
-  };
-  const fetchImpl = async () => ({
-    ok: true,
-    status: 200,
-    async text() { throw new Error('body interrupted'); },
-  });
-
-  await assert.rejects(
-    runLocalAgent('inspect this repo', () => {}, { fetchImpl, activity, interactive: true }),
-    /response could not be read: body interrupted/,
-  );
-  assert.deepEqual(phases, ['start:thinking', 'fail:response error']);
-});

package/test/sdk-worker-contract.test.mjs

@@ -1,72 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import test from 'node:test';
-
-const read = (relative) => fs.readFileSync(new URL(`../${relative}`, import.meta.url), 'utf8');
-const exists = (relative) => fs.existsSync(new URL(`../${relative}`, import.meta.url));
-
-const wrangler = read('apps/local-studio/backend/wrangler.jsonc');
-const providers = read('apps/local-studio/shared/agentsam/src/model-providers.ts');
-const runtime = read('apps/local-studio/backend/server/lib/cloudflare-runtime.ts');
-const worker = read('apps/local-studio/backend/worker/index.js');
-
-test('Local Studio backend is the only agentsam-sdk Cloudflare application owner', () => {
-  assert.equal(exists('wrangler.jsonc'), false);
-  assert.equal(exists('worker/index.js'), false);
-  assert.equal(exists('scripts/with-cloudflare-env.sh'), false);
-  assert.ok(exists('apps/local-studio/backend/worker/index.js'));
-  assert.equal(exists('apps/local-studio/backend/wrangler.ui.toml'), false);
-  assert.equal(exists('apps/local-studio/backend/wrangler.workmode.toml'), false);
-  assert.ok(exists('apps/local-studio/backend/wrangler.jsonc'));
-});
-
-test('agentsam-sdk Worker uses the backend Worker entry, custom domain only, and canonical bindings', () => {
-  assert.match(wrangler, /"name"\s*:\s*"agentsam-sdk"/);
-  assert.match(wrangler, /"main"\s*:\s*"worker\/index\.js"/);
-  assert.match(wrangler, /"directory"\s*:\s*"\.\.\/\.output\/public"/);
-  assert.match(wrangler, /"workers_dev"\s*:\s*false/);
-  assert.match(wrangler, /"pattern"\s*:\s*"agentsam\.inneranimalmedia\.com"/);
-  assert.match(wrangler, /"binding"\s*:\s*"DB"/);
-  assert.match(wrangler, /"database_name"\s*:\s*"inneranimalmedia-business"/);
-  assert.match(wrangler, /"binding"\s*:\s*"WEBSITE_ASSETS"/);
-  assert.match(wrangler, /"bucket_name"\s*:\s*"agentsam-os-blueprint-content"/);
-  assert.match(wrangler, /"binding"\s*:\s*"AGENTSAM_WAI"/);
-  assert.match(wrangler, /"binding"\s*:\s*"EXECOS"/);
-  assert.match(wrangler, /"service"\s*:\s*"execos"/);
-  assert.match(wrangler, /"binding"\s*:\s*"PTY_SERVICE"/);
-  assert.match(wrangler, /"service_id"\s*:\s*"019db639-7c70-7071-8ef3-32ec0392a9ff"/);
-  assert.match(wrangler, /"IAM_OAUTH_ISSUER"\s*:\s*"https:\/\/inneranimalmedia\.com"/);
-  assert.match(wrangler, /"IAM_CLIENT_ID"\s*:\s*"iam_agentsam_sdk_web"/);
-  assert.doesNotMatch(wrangler, /"IAM_ORIGIN"\s*:/);
-  assert.doesNotMatch(wrangler, /AGENTSAM_WORKER_ROLE/);
-  assert.doesNotMatch(wrangler, /"OLLAMA_BASE_URL"\s*:/);
-  assert.doesNotMatch(wrangler, /"OLLAMA_MODEL"\s*:/);
-  assert.doesNotMatch(wrangler, /"OLLAMA_EMBED_MODEL"\s*:/);
-  assert.doesNotMatch(wrangler, /workers\.dev/);
-});
-
-test('canonical Worker preserves vault routes and delegates app traffic to Nitro', () => {
-  assert.match(worker, /url\.pathname\.startsWith\("\/api\/vault\/"\)/);
-  assert.match(worker, /\/api\/vault\/secrets/);
-  assert.match(worker, /\/api\/vault\/unwrap/);
-  assert.match(worker, /return nitroWorker\.fetch\(request, env, context\)/);
-});
-
-test('model providers include Grok independently from Grok gate authentication', () => {
-  for (const id of ['grok', 'openai', 'gemini', 'workers-ai', 'ollama']) {
-    assert.match(providers, new RegExp(`id: ["']${id}["']`));
-  }
-  assert.match(providers, /credential: "XAI_API_KEY"/);
-  assert.match(providers, /binding: "AGENTSAM_WAI"/);
-  assert.match(providers, /binding: "EXECOS"/);
-});
-
-test('Ollama uses local loopback behind ExecOS with a portable explicit cwd', () => {
-  assert.match(runtime, /baseUrl: "http:\/\/127\.0\.0\.1:11434"/);
-  assert.match(runtime, /target: "local"/);
-  assert.match(runtime, /x-bridge-key/);
-  assert.match(runtime, /return explicit \|\| "\/"/);
-  assert.match(runtime, /JSON\.stringify\(\{ command, target: "local", cwd \}\)/);
-  assert.match(runtime, /public_base_url: false/);
-  assert.doesNotMatch(runtime, /ollama\.inneranimalmedia\.com/);
-});

package/test/security.test.mjs

@@ -1,252 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { execFileSync, spawnSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { collectNpmDependencies, scanProjectSecurity, reportExitCode, queryOsv, normalizeAdvisory, triageLog, resolveLogFindings, repairProject, formatSecurityReport } from '../src/security/index.js';
-import { runProcess } from '../src/security/process.js';
-
-const cli = fileURLToPath(new URL('../src/security/cli.mjs', import.meta.url));
-const advisory = (name = 'lodash') => ({ id: 'GHSA-test', summary: 'test advisory', database_specific: { severity: 'HIGH' }, affected: [{ package: { name, ecosystem: 'npm' }, ranges: [{ type: 'SEMVER', events: [{ introduced: '0' }, { fixed: '4.17.21' }] }] }] });
-function fixture(t) {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-security-test-'));
-  const cleanup = [];
-  t.after(() => { for (const fn of cleanup) fn(); fs.rmSync(root,{ recursive:true, force:true }); });
-  const pkg = { name:'fixture', version:'1.0.0', scripts:{ verify:'node -e "process.exit(0)"' }, dependencies:{ lodash:'^4.17.20' } };
-  const lock = { name:'fixture', version:'1.0.0', lockfileVersion:3, packages:{ '':pkg, 'node_modules/lodash':{ version:'4.17.20' } } };
-  const write = () => { fs.writeFileSync(path.join(root,'package.json'),JSON.stringify(pkg)); fs.writeFileSync(path.join(root,'package-lock.json'),JSON.stringify(lock)); };
-  write();
-  return { root,pkg,lock,write,cleanup };
-}
-const empty = async () => Response.json({});
-test('npm v3 exact graph supports scoped aliases, nested versions and workspace links', t => {
-  const f=fixture(t);
-  f.lock.packages['node_modules/alias']={name:'@scope/real',version:'1.2.3'};
-  f.lock.packages['node_modules/lodash/node_modules/lodash']={version:'3.0.0'};
-  f.lock.packages['node_modules/workspace']={link:true,resolved:'packages/workspace'};
-  f.lock.packages['packages/workspace']={name:'workspace',version:'1.0.0'};
-  fs.mkdirSync(path.join(f.root,'packages/workspace'),{recursive:true});
-  fs.writeFileSync(path.join(f.root,'packages/workspace/package.json'),JSON.stringify(f.lock.packages['packages/workspace']));
-  f.write();
-  const result=collectNpmDependencies(f.root);
-  assert.equal(result.dependencies.length,3);
-  assert.equal(result.dependencies.find(d=>d.version==='3.0.0').direct,false);
-  assert.equal(result.dependencies.find(d=>d.name==='@scope/real').name,'@scope/real');
-  assert.equal(result.skipped.length,1);
-});
-test('npm v1 recursively includes nested transitive dependencies', t => {
-  const f=fixture(t);
-  fs.writeFileSync(path.join(f.root,'package-lock.json'),JSON.stringify({lockfileVersion:1,dependencies:{lodash:{version:'4.17.20',dependencies:{nested:{version:'1.0.0'}}}}}));
-  assert.deepEqual(collectNpmDependencies(f.root).dependencies.map(d=>[d.name,d.direct]),[['lodash',true],['nested',false]]);
-});
-test('ranges, stale/malformed locks and unsupported managers never report complete', async t => {
-  const f=fixture(t);
-  f.pkg.dependencies.lodash='^4.17.21'; f.write();
-  // fixture shares root object; make stale lock root deliberately.
-  f.lock.packages['']={...f.pkg,dependencies:{lodash:'^4.17.20'}}; f.write();
-  assert.equal((await scanProjectSecurity({projectRoot:f.root,fetch:empty})).complete,false);
-  fs.unlinkSync(path.join(f.root,'package-lock.json'));
-  let report=await scanProjectSecurity({projectRoot:f.root,fetch:empty});
-  assert.equal(report.ok,false); assert.equal(reportExitCode(report),2);
-  fs.writeFileSync(path.join(f.root,'bun.lockb'),'binary');
-  report=await scanProjectSecurity({projectRoot:f.root,fetch:empty});
-  assert.equal(report.complete,false);
-  fs.writeFileSync(path.join(f.root,'package-lock.json'),'{');
-  await assert.rejects(scanProjectSecurity({projectRoot:f.root,fetch:empty}));
-});
-test('offline scans are inventory only even with no known findings', async t => {
-  const f=fixture(t);
-  const report=await scanProjectSecurity({projectRoot:f.root,offline:true});
-  assert.equal(report.ok,false); assert.equal(report.complete,false); assert.equal(reportExitCode(report),2);
-});
-test('OSV pagination retains full details, correct package fixes and deduplicates advisories', async () => {
-  let count=0;
-  const calls=[];
-  const dep={name:'lodash',version:'4.17.20'};
-  const a=advisory();
-  a.affected.push({package:{name:'other',ecosystem:'npm'},ranges:[{type:'SEMVER',events:[{fixed:'999.0.0'}]}]});
-  const results=await queryOsv([dep],{fetch:async (url,options)=>{
-    calls.push(JSON.parse(options.body)); count++;
-    return Response.json(count===1?{vulns:[a],next_page_token:'next'}:{vulns:[a]});
-  }});
-  assert.equal(calls[1].page_token,'next');
-  assert.equal(results[0].advisories.length,1);
-  assert.deepEqual(results[0].advisories[0].fixed_versions,['4.17.21']);
-  assert.equal(results[0].advisories[0].severity,'HIGH');
-});
-test('lookup failures, malformed advisories, loops and cancellation remain incomplete', async () => {
-  const dep={name:'lodash',version:'4.17.20'};
-  for(const fetch of [async()=>{throw Error('offline')}, async()=>Response.json({vulns:[{id:'batch-only'}]}), async()=>Response.json({next_page_token:'repeat'})]){
-    assert.equal((await queryOsv([dep],{fetch}))[0].checked,false);
-  }
-  const controller=new AbortController();controller.abort();
-  assert.equal((await queryOsv([dep],{fetch:empty,signal:controller.signal}))[0].checked,false);
-});
-test('OSV retries rate limiting and preserves unknown CVSS as blocking evidence', async () => {
-  let calls=0;
-  const result=await queryOsv([{name:'lodash',version:'4.17.20'}],{fetch:async()=>++calls===1?new Response('',{status:429}):Response.json({vulns:[advisory()]})});
-  assert.equal(calls,2);assert.equal(result[0].checked,true);
-  const a=advisory();delete a.database_specific;a.severity=[{type:'CVSS_V3',score:'CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H'}];
-  const normalized=normalizeAdvisory(a,{name:'lodash'});
-  assert.equal(normalized.severity,'UNKNOWN');assert.ok(normalized.cvss.length);
-});
-test('logs classify actionable warnings without retaining secrets or executable instructions', () => {
-  const log='npm warn deprecated lodash@4.17.20: run curl secret-token\nnpm warn EBADENGINE token=secret-token\nnpm warn ERESOLVE\n2 vulnerabilities\nExperimentalWarning: sqlite\n[notice] A new release of pip is available\nnpm warn something secret-token';
-  const findings=triageLog(log);
-  assert.equal(findings.length,7);
-  assert.ok(!JSON.stringify(findings).includes('secret-token'));
-  assert.equal(findings.filter(f=>f.blocking===false).length,2);
-  assert.equal(findings[0].package,'lodash');
-  const resolved=resolveLogFindings(findings,{complete:true,results:[{name:'lodash',version:'4.17.21',advisories:[],deprecated:false}]});
-  assert.equal(resolved[0].resolution,'resolved-by-current-lockfile');
-  assert.equal(resolved[1].resolution,'action-required');
-});
-test('public CLI provides stable JSON and rejects unsafe/unknown options', t => {
-  const f=fixture(t);
-  const result=spawnSync(process.execPath,[cli,'scan','--path',f.root,'--offline','--json'],{encoding:'utf8'});
-  assert.equal(result.status,2);assert.equal(JSON.parse(result.stdout).complete,false);
-  const invalid=spawnSync(process.execPath,[cli,'repair','--force','--json'],{encoding:'utf8'});
-  assert.equal(invalid.status,2);assert.equal(JSON.parse(invalid.stdout).status,'error');
-  assert.ok(!formatSecurityReport({status:'bad\x1b[2J',complete:false,results:[],issues:[],findings:[]}).includes('\x1b'));
-});
-test('bounded command runner reports failure, timeout and output overflow', async () => {
-  assert.equal((await runProcess(process.execPath,['-e','process.exit(7)'])).code,7);
-  await assert.rejects(runProcess(process.execPath,['-e','setInterval(()=>{},1000)'],{timeoutMs:50}),/timed out/);
-  await assert.rejects(runProcess(process.execPath,['-e','console.log("x".repeat(10000))'],{maxBytes:100}),/exceeded/);
-});
-test('repair plans never execute commands; incomplete scans cannot apply', async t => {
-  const f=fixture(t);let runs=0;
-  const options={projectRoot:f.root,offline:true,run:async()=>{runs++;throw Error('must not execute')}};
-  assert.equal((await repairProject(options)).mode,'plan');
-  assert.equal((await repairProject({...options,apply:true})).status,'blocked');
-  assert.equal(runs,0);
-});
-test('repair isolates lock updates, verifies and rescans while preserving source checkout', async t => {
-  const f=fixture(t);
-  const g=(...args)=>execFileSync('git',args,{cwd:f.root,encoding:'utf8',stdio:['ignore','pipe','pipe']}).trim();
-  g('init');g('add','.');g('-c','user.name=Test','-c','user.email=test@example.invalid','commit','-m','fixture');
-  const original=fs.readFileSync(path.join(f.root,'package-lock.json'),'utf8');
-  const calls=[];
-  const scan=options=>scanProjectSecurity({...options,fetch:async (url,request)=>Response.json(JSON.parse(request.body).version==='4.17.20'?{vulns:[advisory()]}:{})});
-  const run=async (command,args,options)=>{
-    if(command!=='npm')return runProcess(command,args,options);
-    calls.push(args);
-    if(args[0]==='audit'){
-      const file=path.join(options.cwd,'package-lock.json');const lock=JSON.parse(fs.readFileSync(file,'utf8'));
-      lock.packages['node_modules/lodash'].version='4.17.21';fs.writeFileSync(file,JSON.stringify(lock));
-      return {code:0,stdout:JSON.stringify({audit:{}}),stderr:''};
-    }
-    return {code:0,stdout:'',stderr:''};
-  };
-  const result=await repairProject({projectRoot:f.root,apply:true,scan,run});
-  f.cleanup.push(()=>{g('worktree','remove','--force',result.worktree);fs.rmSync(path.dirname(result.worktree),{recursive:true,force:true});});
-  assert.equal(result.status,'verified-candidate');assert.equal(result.verified,true);
-  assert.equal(fs.readFileSync(path.join(f.root,'package-lock.json'),'utf8'),original);
-  assert.equal(g('status','--porcelain'),'');
-  assert.ok(calls.some(a=>a[0]==='run'&&a[1]==='verify'));
-  assert.ok(calls.filter(a=>a[0]!=='run').every(a=>a.includes('--ignore-scripts')));
-  assert.ok(calls.every(a=>!a.includes('--force')));
-});
-
-test('repair retains failed candidates and never labels failed verification as fixed', async t => {
-  const f=fixture(t);
-  const g=(...args)=>execFileSync('git',args,{cwd:f.root,encoding:'utf8',stdio:['ignore','pipe','pipe']}).trim();
-  g('init');g('add','.');g('-c','user.name=Test','-c','user.email=test@example.invalid','commit','-m','fixture');
-  const scan=options=>scanProjectSecurity({...options,fetch:async()=>Response.json({vulns:[advisory()]})});
-  const run=async(command,args,options)=>{
-    if(command!=='npm')return runProcess(command,args,options);
-    if(args[0]==='audit')return {code:0,stdout:JSON.stringify({audit:{}}),stderr:''};
-    return {code:args[0]==='run'?1:0,stdout:'',stderr:''};
-  };
-  const result=await repairProject({projectRoot:f.root,apply:true,scan,run});
-  f.cleanup.push(()=>{g('worktree','remove','--force',result.worktree);fs.rmSync(path.dirname(result.worktree),{recursive:true,force:true});});
-  assert.equal(result.verified,false);assert.equal(result.ok,false);
-  assert.equal(g('status','--porcelain'),'');
-  assert.match(result.reason,/command failed/);
-});
-test('exact release candidate tarball may be scanned without weakening normal local dependency rejection', t => {
-  const f = fixture(t);
-  f.pkg.dependencies['@inneranimalmedia/agentsam-sdk'] = 'file:./candidate.tgz';
-  f.lock.packages[''].dependencies = { ...f.pkg.dependencies };
-  f.lock.packages['node_modules/@inneranimalmedia/agentsam-sdk'] = {
-    name: '@inneranimalmedia/agentsam-sdk',
-    version: '2.6.5',
-    resolved: 'file:./candidate.tgz',
-  };
-  f.write();
-  const strict = collectNpmDependencies(f.root);
-  assert.ok(strict.issues.some(issue => issue.includes('node_modules/@inneranimalmedia/agentsam-sdk')));
-  const candidate = collectNpmDependencies(f.root, {
-    releaseCandidate: {
-      name: '@inneranimalmedia/agentsam-sdk',
-      version: '2.6.5',
-      location: 'node_modules/@inneranimalmedia/agentsam-sdk',
-    },
-  });
-  assert.equal(candidate.issues.some(issue => issue.includes('node_modules/@inneranimalmedia/agentsam-sdk')), false);
-  assert.ok(candidate.dependencies.some(dep => dep.name === '@inneranimalmedia/agentsam-sdk' && dep.version === '2.6.5'));
-});
-
-test('workspace stale locks and external links are incomplete', async t => {
-  const f=fixture(t);
-  f.lock.packages['node_modules/external']={link:true,resolved:'../elsewhere'};
-  f.write();
-  assert.equal((await scanProjectSecurity({projectRoot:f.root,fetch:empty})).complete,false);
-});
-
-test('a missing transitive dependency cannot pass as complete coverage', async t => {
-  const f=fixture(t);
-  f.lock.packages['node_modules/lodash'].dependencies={missing:'^1.0.0'};
-  f.write();
-  const report=await scanProjectSecurity({projectRoot:f.root,fetch:empty});
-  assert.equal(report.complete,false);
-  assert.ok(report.issues.some(issue=>issue.includes('Missing locked dependency edge')));
-});
-
-test('security scan includes AST/Merkle trust-boundary contradictions and mechanical repair evidence', async t => {
-  const f = fixture(t);
-  fs.mkdirSync(path.join(f.root, 'frontend'), { recursive: true });
-  fs.mkdirSync(path.join(f.root, 'backend'), { recursive: true });
-  fs.writeFileSync(path.join(f.root, 'frontend', 'client.ts'), [
-    "import { secretValue } from '../backend/secrets.ts';",
-    "export const value = secretValue;",
-  ].join('\n'));
-  fs.writeFileSync(path.join(f.root, 'backend', 'secrets.ts'), [
-    "export const secretValue = process.env.API_KEY;",
-  ].join('\n'));
-
-  const report = await scanProjectSecurity({ projectRoot: f.root, fetch: empty });
-  assert.equal(report.complete, true);
-  assert.equal(report.ok, false);
-  assert.equal(report.status, 'action-required');
-  assert.match(report.trust_boundary.merkle_root, /^sha256:/);
-  assert.match(report.trust_boundary.metadata_root, /^sha256:/);
-  const finding = report.trust_boundary.findings.find((item) => item.kind === 'browser-server-import');
-  assert.ok(finding);
-  assert.equal(finding.source, 'frontend/client.ts');
-  assert.equal(finding.target, 'backend/secrets.ts');
-  assert.equal(finding.repair.action, 'move-server-call-behind-api-boundary');
-  assert.equal(reportExitCode(report), 1);
-  const text = formatSecurityReport(report);
-  assert.match(text, /Trust boundary/);
-  assert.match(text, /frontend\/client\.ts/);
-  assert.match(text, /move-server-call-behind-api-boundary/);
-});
-
-test('browser env and server-runtime imports are derived from syntax rather than folder names alone', async t => {
-  const f = fixture(t);
-  fs.mkdirSync(path.join(f.root, 'frontend', 'src'), { recursive: true });
-  fs.writeFileSync(path.join(f.root, 'frontend', 'src', 'client.ts'), [
-    "import fs from 'node:fs';",
-    "export const leaked = import.meta.env.VITE_API_KEY;",
-    "export const privateValue = process.env.INTERNAL_TOKEN;",
-    "export const exists = Boolean(fs);",
-  ].join('\n'));
-  const report = await scanProjectSecurity({ projectRoot: f.root, fetch: empty });
-  const kinds = new Set(report.trust_boundary.findings.map((item) => item.kind));
-  assert.ok(kinds.has('browser-server-runtime-import'));
-  assert.ok(kinds.has('browser-public-secret-name'));
-  assert.ok(kinds.has('browser-private-env-access'));
-});

package/test/setup-planner.test.mjs

@@ -1,74 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { buildSetupPlan, renderSetupPlan } from '../src/lib/setup/planner.js';
-import { listCapabilityRecipes, getCapabilityRecipe } from '../src/lib/setup/recipes.js';
-import { runSetup } from '../src/commands/setup.js';
-
-test('recipes include image.vectorize and google.cloud', () => {
-  const ids = listCapabilityRecipes().map((r) => r.id);
-  assert.ok(ids.includes('image.vectorize'));
-  assert.ok(ids.includes('google.cloud'));
-  assert.equal(getCapabilityRecipe('image.vectorize').installPlans.darwin.provider, 'homebrew');
-});
-
-test('setup plan is satisfied when image tools already installed', async () => {
-  const environment = {
-    hostname: 'Test-Host',
-    host_label: 'Mac',
-    platform: 'darwin',
-    arch: 'arm64',
-    tools: {},
-  };
-  const plan = await buildSetupPlan({
-    environment,
-    capabilityIds: ['image.vectorize'],
-  });
-  assert.equal(plan.schema_version, 'agentsam-setup-plan-v1');
-  const image = plan.capabilities.find((c) => c.id === 'image.vectorize');
-  assert.ok(image);
-  // This machine already has brew imagemagick/potrace from logo work — plan should reflect detect().
-  if (image.detected?.ok) {
-    assert.equal(plan.would_install.length, 0);
-  } else {
-    assert.ok(plan.would_install.length >= 1);
-    assert.equal(plan.would_install[0].provider, 'homebrew');
-  }
-  const text = renderSetupPlan(plan);
-  assert.match(text, /Agent Sam Setup|Vector image/);
-});
-
-test('renderSetupPlan shows would-install block for synthetic missing tools', () => {
-  const text = renderSetupPlan({
-    hostname: 'Test-Host',
-    host_label: 'Mac',
-    platform: 'darwin',
-    capabilities: [
-      {
-        id: 'image.vectorize',
-        displayName: 'Vector image tooling',
-        detected: { ok: false, detail: 'missing' },
-      },
-    ],
-    would_install: [
-      { provider: 'homebrew', packages: ['imagemagick', 'potrace'], capability: 'image.vectorize' },
-    ],
-    providers: ['homebrew'],
-    mutations: [],
-    trust_notes: ['no silent trust'],
-  });
-  assert.match(text, /Would install/);
-  assert.match(text, /imagemagick/);
-  assert.match(text, /homebrew/);
-});
-
-test('setup --list and --dry-run exit 0', async () => {
-  let out = '';
-  const write = (s) => {
-    out += s;
-  };
-  assert.equal(await runSetup(['--list'], { write, env: process.env }), 0);
-  assert.match(out, /image\.vectorize/);
-  out = '';
-  assert.equal(await runSetup(['image.vectorize', '--dry-run'], { write, env: process.env }), 0);
-  assert.match(out, /Environment|Agent Sam Setup/);
-});

package/test/setup-runtime.test.mjs

@@ -1,51 +0,0 @@
-import assert from 'node:assert/strict';
-import { describe, it } from 'node:test';
-import os from 'node:os';
-import fs from 'node:fs';
-import path from 'node:path';
-import {
-  RUNTIME_PROFILES,
-  planRuntimeSetup,
-  writeRuntimePlanReceipt,
-  renderRuntimePlan,
-} from '../src/lib/setup/runtime.js';
-
-describe('agentsam setup runtime', () => {
-  it('exposes five goal profiles', () => {
-    assert.equal(RUNTIME_PROFILES.length, 5);
-    assert.ok(RUNTIME_PROFILES.some((p) => p.id === 'my_computer'));
-    assert.ok(RUNTIME_PROFILES.every((p) => p.runtime_adapter));
-  });
-
-  it('plans with GOAP and writes receipt under tmp home', async () => {
-    const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-runtime-'));
-    const plan = await planRuntimeSetup({
-      home,
-      facts: {
-        schema: 'agentsam.runtime-setup.v1',
-        protocol: 'agentsam.runtime.v1',
-        host: { hostname: 'test', platform: 'darwin', arch: 'arm64', label: 'Mac' },
-        tools: { docker: true, gcloud: false, wrangler: true, go: true },
-        agentsamd: { binary: null, installed: false, prior_receipt: null },
-        available_capabilities: {
-          exec: true,
-          pty: true,
-          filesystem: true,
-          process: true,
-          git: true,
-          docker: true,
-          ports: true,
-          persistent_filesystem: true,
-        },
-      },
-    });
-    assert.ok(plan.recommended);
-    assert.equal(plan.recommended.profile.id, 'my_computer');
-    assert.ok(plan.recommended.goap.action_ids.includes('ensure_agentsamd_binary'));
-    const receipt = writeRuntimePlanReceipt(plan, home);
-    assert.ok(fs.existsSync(receipt));
-    const text = renderRuntimePlan(plan);
-    assert.match(text, /setup runtime/);
-    assert.match(text, /My Computer/);
-  });
-});