@inneranimalmedia/agentsam-sdk 2.6.3 → 2.6.5

package/test/integration/inventory-evidence.test.mjs

@@ -0,0 +1,125 @@
+import { describe, it } 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 } from 'node:child_process';
+import { buildInventory } from '../../src/indexing/ingest/inventory.js';
+import {
+  extractStyleEvidence,
+  finalizeStyleEvidence,
+  mergeStyleEvidence,
+} from '../../src/indexing/ingest/style-evidence.js';
+import { inventory as knowledgeInventory } from '../../src/knowledge/source.js';
+
+function write(root, rel, text = '') {
+  const abs = path.join(root, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, text);
+}
+
+describe('inventory classifies by evidence', () => {
+  it('uses dominant evidence, root files, tooling LOC, and git ignore state', () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'inv-evidence-'));
+    try {
+      execFileSync('git', ['init', '-q'], { cwd: root });
+      write(root, '.gitignore', '.sites-runtime/\n');
+
+      write(root, 'app/page.tsx', Array.from({ length: 30 }, (_, i) => `export const x${i} = ${i};`).join('\n'));
+      write(root, 'db/schema.sql', 'create table t (id integer);\n');
+      write(root, 'drizzle/meta/_journal.json', '{"version":"1"}\n');
+      for (let i = 1; i <= 9; i += 1) write(root, `plans/p${i}.md`, `# plan ${i}\ntext\n`);
+      write(root, 'plans/schema.sql', 'create table plan (id integer);\n');
+      write(root, 'public/logo.png', 'x');
+      write(root, 'scripts/harvest.py', Array.from({ length: 80 }, (_, i) => `x_${i} = ${i}`).join('\n'));
+      write(root, '.sites-runtime/cache/blob.bin', 'x'.repeat(2048));
+
+      write(root, 'package.json', '{"name":"fixture"}\n');
+      write(root, 'wrangler.jsonc', '{}\n');
+      write(root, 'drizzle.config.ts', 'export default {};\n');
+      write(root, 'README.md', '# Fixture\n');
+      write(root, 'entry.ts', 'export const root = true;\n');
+      write(root, 'package-lock.json', '{"lockfileVersion":3}\n');
+      write(root, '.env', 'SECRET=do-not-index\n');
+      write(root, '.dev.vars', 'TOKEN=do-not-index\n');
+      write(root, 'tls.pem', 'private material\n');
+
+      execFileSync('git', ['add', '.'], { cwd: root });
+
+      const inventory = buildInventory({ root });
+      const categories = inventory.categories;
+
+      assert.ok(categories.source.includes('app'));
+      assert.ok(categories.source.includes('db'));
+      assert.ok(categories.docs.includes('plans'), '9 markdown + 1 SQL is dominantly docs');
+      assert.ok(categories.data.includes('drizzle'), 'JSON-only drizzle metadata is data');
+      assert.ok(categories.assets.includes('public'));
+      assert.ok(categories.operational.includes('.sites-runtime'));
+      assert.ok(categories.tooling.includes('scripts'));
+      assert.deepEqual(categories.unknown, []);
+
+      assert.ok(inventory.suggested.include.includes('scripts'), 'tracked top-2 language tooling is promoted');
+      assert.ok(inventory.top_level_details.scripts.loc >= 80);
+      assert.equal(inventory.top_level_details.scripts.dominant_language, 'Python');
+
+      assert.ok(inventory.root_files.manifest.includes('package.json'));
+      assert.ok(inventory.root_files.manifest.includes('wrangler.jsonc'));
+      assert.ok(inventory.root_files.manifest.includes('drizzle.config.ts'));
+      assert.ok(inventory.root_files.docs.includes('README.md'));
+      assert.ok(inventory.root_files.source.includes('entry.ts'));
+      assert.ok(inventory.root_files.lockfile.includes('package-lock.json'));
+      assert.ok(inventory.root_files.secret.includes('.env'));
+      assert.ok(inventory.root_files.secret.includes('.dev.vars'));
+      assert.ok(inventory.root_files.secret.includes('tls.pem'));
+
+      for (const wanted of ['package.json', 'wrangler.jsonc', 'drizzle.config.ts', 'README.md', 'entry.ts']) {
+        assert.ok(inventory.suggested.include_files.includes(wanted), wanted);
+      }
+      for (const forbidden of ['package-lock.json', '.env', '.dev.vars', 'tls.pem']) {
+        assert.ok(!inventory.suggested.include_files.includes(forbidden), forbidden);
+      }
+
+      const files = knowledgeInventory(root, { include: ['.'], exclude: [] });
+      assert.ok(files.includes('entry.ts'));
+      assert.ok(!files.includes('.env'));
+      assert.ok(!files.includes('.dev.vars'));
+      assert.ok(!files.includes('tls.pem'));
+      assert.ok(!files.includes('package-lock.json'));
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  });
+
+  it('detects coherent theme signatures from markup and CSS evidence', () => {
+    const evidence = extractStyleEvidence(`
+      <html data-theme-preset="fuel-free-time" data-header-preset="adaptive-bar">
+        <link rel="stylesheet" href="/css/heuristic-theme.css">
+        <body>
+          <header class="fnf-header fnf-header--adaptive-bar">
+            <a class="fnf-logo"></a>
+            <nav class="fnf-primary"></nav>
+          </header>
+        </body>
+      </html>
+      <style>
+        :root { --fnf-accent: #ff4d00; --fnf-logo-height: 58px; }
+        .fnf-header { color: var(--fnf-accent); }
+        .fnf-logo { height: var(--fnf-logo-height); }
+      </style>
+    `);
+
+    assert.equal(evidence.theme_presets['fuel-free-time'], 1);
+    assert.equal(evidence.header_presets['adaptive-bar'], 1);
+    assert.equal(evidence.stylesheets['/css/heuristic-theme.css'], 1);
+    const fnf = evidence.namespaces.find((row) => row.prefix === 'fnf');
+    assert.ok(fnf);
+    assert.ok(fnf.signal_kinds >= 2);
+    assert.ok(fnf.signals.class_tokens >= 3);
+    assert.ok(fnf.signals.custom_properties >= 2);
+
+    const final = finalizeStyleEvidence(mergeStyleEvidence(null, evidence));
+    const finalFnf = final.namespaces.find((row) => row.prefix === 'fnf');
+    assert.equal(final.theme_candidate, true);
+    assert.equal(finalFnf?.candidate, true);
+  });
+});

package/test/integration/local-fs.test.mjs

@@ -0,0 +1,113 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, it, before, after } from 'node:test';
+import {
+  createLocalFilesystem,
+  createTempWorkspaceRoot,
+  LOCAL_FS_ENGINE,
+} from '../../src/local-fs/index.js';
+import { resolveContainedPath } from '../../src/local-fs/paths.js';
+
+describe('local-fs path containment', () => {
+  /** @type {string} */
+  let root;
+  before(() => {
+    root = createTempWorkspaceRoot();
+    fs.writeFileSync(path.join(root, 'ok.txt'), 'hello\n');
+    fs.mkdirSync(path.join(root, 'sub'));
+  });
+  after(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('resolves relative paths inside root', () => {
+    const r = resolveContainedPath(root, 'ok.txt');
+    assert.equal(r.ok, true);
+    assert.equal(r.rel, 'ok.txt');
+  });
+
+  it('rejects traversal', () => {
+    const r = resolveContainedPath(root, '../outside.txt');
+    assert.equal(r.ok, false);
+    assert.equal(r.code, 'path_escape');
+  });
+
+  it('rejects NUL', () => {
+    const r = resolveContainedPath(root, 'a\0b.txt');
+    assert.equal(r.ok, false);
+    assert.equal(r.code, 'invalid_path');
+  });
+
+  it('rejects symlink escape when possible', () => {
+    const outside = createTempWorkspaceRoot('agentsam-fs-out-');
+    try {
+      fs.writeFileSync(path.join(outside, 'secret.txt'), 'nope');
+      const link = path.join(root, 'escape-link');
+      try {
+        fs.symlinkSync(path.join(outside, 'secret.txt'), link);
+      } catch {
+        // Windows may lack symlink privilege — skip
+        return;
+      }
+      const r = resolveContainedPath(root, 'escape-link');
+      assert.equal(r.ok, false);
+      assert.equal(r.code, 'path_escape');
+    } finally {
+      fs.rmSync(outside, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('local-fs operations', () => {
+  /** @type {string} */
+  let root;
+  /** @type {ReturnType<typeof createLocalFilesystem>} */
+  let fsApi;
+
+  before(() => {
+    root = createTempWorkspaceRoot();
+    fsApi = createLocalFilesystem(root);
+  });
+  after(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('create / read / write with version conflict detection', () => {
+    assert.equal(fsApi.engine, LOCAL_FS_ENGINE);
+    const created = fsApi.create('README.md', '# one\n');
+    assert.equal(created.ok, true);
+    const v1 = created.version;
+
+    const read1 = fsApi.read('README.md');
+    assert.equal(read1.ok, true);
+    assert.equal(read1.content, '# one\n');
+    assert.equal(read1.version, v1);
+
+    const conflict = fsApi.write('README.md', '# stale\n', { expectedVersion: 'sha256:dead' });
+    assert.equal(conflict.ok, false);
+    assert.equal(conflict.code, 'version_conflict');
+
+    const wrote = fsApi.write('README.md', '# two\n', { expectedVersion: v1 });
+    assert.equal(wrote.ok, true);
+    assert.notEqual(wrote.version, v1);
+    assert.equal(fs.readFileSync(path.join(root, 'README.md'), 'utf8'), '# two\n');
+  });
+
+  it('list / rename / remove', () => {
+    fsApi.create('a.txt', 'a');
+    fsApi.mkdir('dir');
+    const listed = fsApi.list('.');
+    assert.equal(listed.ok, true);
+    assert.ok(listed.entries.some((e) => e.path === 'a.txt'));
+
+    const renamed = fsApi.rename('a.txt', 'b.txt');
+    assert.equal(renamed.ok, true);
+    assert.ok(fs.existsSync(path.join(root, 'b.txt')));
+    assert.equal(fs.existsSync(path.join(root, 'a.txt')), false);
+
+    const removed = fsApi.remove('b.txt');
+    assert.equal(removed.ok, true);
+    assert.equal(fs.existsSync(path.join(root, 'b.txt')), false);
+  });
+});

package/test/integration/provider-env-cli.test.mjs

@@ -13,7 +13,8 @@ test('agentsam env init creates provider profile and reusable source loader', {
   const env = { ...process.env, HOME: home };
   const result = spawnSync(process.execPath, ['src/cli.js', 'env', 'init', 'openai'], { cwd: repoRoot, env, encoding: 'utf8' });
   assert.equal(result.status, 0, result.stderr);
-  assert.match(result.stdout, /source ~\/.agentsam\/load-agent-env\.sh openai/);
+  assert.match(result.stdout, /source ~\/.agentsam\/load-agent-env\.sh(?:\s|$)/);
+  assert.doesNotMatch(result.stdout, /source ~\/.agentsam\/load-agent-env\.sh openai/);
   assert.equal(fs.statSync(path.join(home, '.agentsam', 'env.d', 'openai.env')).mode & 0o777, 0o600);
   assert.equal(fs.statSync(path.join(home, '.agentsam', 'load-agent-env.sh')).mode & 0o777, 0o700);
 });

package/test/integration/runtime-status.integration.test.mjs

@@ -19,7 +19,8 @@ test('checked-in Cloudflare deployment contract resolves the real Worker and por
   assert.equal(contract.worker_name, 'agentsam-sdk');
   assert.equal(contract.config, 'apps/local-studio/backend/wrangler.jsonc');
   assert.deepEqual(contract.bindings.map((row) => row.name), [
-    'AGENTSAM_WAI', 'ASSETS', 'DB', 'EXECOS', 'HYPERDRIVE', 'IAM_CLIENT_ID',
+    'AGENTSAM_WAI', 'ASSETS', 'CLOUDFLARE_ACCOUNT_ID', 'DB', 'EXECOS',
+    'GOOGLE_CLIENT_ID', 'GOOGLE_DESKTOP_CLIENT_ID', 'HYPERDRIVE', 'IAM_CLIENT_ID',
     'IAM_OAUTH_ISSUER', 'PTY_SERVICE', 'WEBSITE_ASSETS',
   ]);
 });

package/test/integration/sam-activity-recovery.test.mjs

@@ -0,0 +1,147 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import {
+  evaluateDecisions as evaluate,
+  appendOutcome,
+  attachAction,
+  createActivityStore,
+  activityFromDecision,
+  DECISION_ACTIVITY_LABELS,
+} from '../../src/sam/index.js';
+import {
+  createErrorEnvelope,
+  planRecovery,
+  inferSideEffectState,
+  SIDE_EFFECT_STATE,
+  FAILURE_CLASS,
+} from '../../packages/agentsam-errors/src/index.js';
+
+describe('SAM decision → activity → outcome linkage', () => {
+  it('emits user-facing decision.made events without choose/score/check as primary label', async () => {
+    const activity = createActivityStore('run_test_1');
+    const seen = [];
+    activity.on((e) => seen.push(e));
+
+    const result = await evaluate({
+      state: {
+        constraints: { requires_local_files: true },
+        runtime: { terminal_lanes: { local: true, remote: true, sandbox: true } },
+      },
+      questions: ['terminal_lane', 'requires_approval'],
+      run_id: 'run_test_1',
+      step_id: 'step_plan',
+      activity,
+    });
+
+    assert.ok(result.receipt.run_id === 'run_test_1');
+    assert.ok(result.receipt.step_id === 'step_plan');
+    assert.ok(seen.some((e) => e.event === 'decision.made'));
+    const lane = seen.find((e) => e.evidence?.question_id === 'terminal_lane');
+    assert.equal(lane.label, DECISION_ACTIVITY_LABELS.terminal_lane);
+    assert.equal(lane.label.includes('choose'), false);
+    assert.ok(lane.evidence.decision_id);
+    assert.equal(lane.detail, 'local');
+  });
+
+  it('records supervised human corrections distinctly from weak passive accept', async () => {
+    const result = await evaluate({
+      state: { constraints: { requires_local_files: true }, runtime: { terminal_lanes: { local: true } } },
+      questions: ['terminal_lane'],
+      run_id: 'run_corr',
+    });
+    let receipt = attachAction(result.receipt, { kind: 'terminal.attach', summary: 'attach local pty' });
+    assert.ok(receipt.action_id);
+
+    receipt = appendOutcome(receipt, {
+      success: false,
+      disposition: 'corrected_to',
+      human_corrected: true,
+      corrected_to: 'sandbox',
+      user_override: true,
+      duration_ms: 1200,
+      retries: 0,
+    });
+    assert.equal(receipt.outcome.label_strength, 'supervised');
+    assert.equal(receipt.outcome.corrected_to, 'sandbox');
+    assert.ok(receipt.outcome_id);
+
+    const passive = appendOutcome(result.receipt, { success: true });
+    assert.equal(passive.outcome.label_strength, 'weak_passive');
+  });
+});
+
+describe('ErrorEnvelope recovery semantics', () => {
+  it('refuses blind retry when side effect is unknown', () => {
+    const error = createErrorEnvelope({
+      reason: 'transport_timeout',
+      message: 'deployment create timed out',
+      code: 'DEADLINE_EXCEEDED',
+      severity: 'transient',
+      retryable: true,
+      domain: 'deployment',
+      operation: {
+        kind: 'deployment.create',
+        idempotent: false,
+        read_only: false,
+        side_effect_state: SIDE_EFFECT_STATE.UNKNOWN,
+      },
+    });
+    assert.equal(inferSideEffectState(error), SIDE_EFFECT_STATE.UNKNOWN);
+    const plan = planRecovery(error);
+    assert.equal(plan.disposition, 'reconcile');
+    assert.ok(plan.evidence.some((e) => /reconcile_before_retry/.test(e)));
+  });
+
+  it('retries transport failures with budget when side effect is known not applied', () => {
+    const error = createErrorEnvelope({
+      reason: 'connection_reset',
+      message: 'reset',
+      code: 'UNAVAILABLE',
+      severity: 'transient',
+      retryable: true,
+      domain: 'transport',
+      operation: {
+        kind: 'fs.read',
+        read_only: true,
+        side_effect_state: SIDE_EFFECT_STATE.NONE,
+      },
+    });
+    const plan = planRecovery(error, { attempt: 1, max_attempts: 4 });
+    assert.ok(plan.disposition === 'retry' || plan.disposition === 'reconnect');
+    assert.ok(plan.delay_ms == null || plan.delay_ms >= 0);
+  });
+
+  it('treats cancellation as abort without operator incident', () => {
+    const error = createErrorEnvelope({
+      reason: 'cancelled_by_user',
+      message: 'Stopped',
+      code: 'CANCELLED',
+      severity: 'blocking_user_fixable',
+      retryable: false,
+      domain: 'runtime',
+      resolution_owner: 'user',
+      remediation: { action: 'none' },
+    });
+    // cancelled may not be in policy — use unknown path via custom
+    const plan = planRecovery({
+      ...error,
+      reason: 'cancelled_by_user',
+      failure_class: FAILURE_CLASS.CANCELLED,
+      fingerprint: error.fingerprint,
+    });
+    assert.equal(plan.disposition, 'abort');
+    assert.equal(plan.notify.operator, 'never');
+  });
+
+  it('activityFromDecision maps score to non-numeric user detail', () => {
+    const ev = activityFromDecision({
+      run_id: 'r1',
+      question_id: 'change_risk',
+      answer: { type: 'score', value: 1.7, question_id: 'change_risk' },
+      decision_id: 'dec_x',
+    });
+    assert.equal(ev.label, 'Assessing change risk');
+    assert.equal(ev.detail, 'Bounded');
+    assert.equal(ev.evidence.question_type, 'score');
+  });
+});