@inneranimalmedia/agentsam-sdk 2.6.7 → 2.6.9

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

@@ -1,227 +0,0 @@
-import assert from 'node:assert/strict';
-import path from 'node:path';
-import test from 'node:test';
-import {
-  collectCloudflareDeploymentStatus,
-  readCloudflareDeploymentContract,
-  parseWranglerToml,
-  resolveProjectD1Database,
-} from '../../src/cloudflare/runtime-status.js';
-import { collectRuntimeStatus } from '../../src/commands/runtime-status.js';
-import { readProjectConfig } from '../../src/lib/project-config.js';
-import { runStatus } from '../../src/commands/status.js';
-import { renderRuntimeStatus } from '../../src/ui/ansi.js';
-
-const root = path.resolve(new URL('../..', import.meta.url).pathname);
-
-test('Wrangler TOML parser preserves Vectorize declarations', () => {
-  const parsed = parseWranglerToml([
-    'name = "demo"',
-    '[ai]',
-    'binding = "AGENTSAM_WAI"',
-    '',
-    '[[vectorize]]',
-    'binding = "SEARCH_INDEX"',
-    'index_name = "demo-search-1024"',
-  ].join('\n'));
-  assert.deepEqual(parsed.vectorize, [{ binding: 'SEARCH_INDEX', index_name: 'demo-search-1024' }]);
-  assert.equal(parsed.ai.binding, 'AGENTSAM_WAI');
-});
-
-test('checked-in Cloudflare deployment contract resolves the real Worker and portable bindings', () => {
-  const contract = readCloudflareDeploymentContract(root, readProjectConfig(root));
-  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', 'CLOUDFLARE_ACCOUNT_ID', 'DB', 'EXECOS',
-    'GITHUB_APP_ID', 'GITHUB_CLIENT_ID', 'GOOGLE_CLIENT_ID', 'GOOGLE_DESKTOP_CLIENT_ID',
-    'HYPERDRIVE', 'IAM_CLIENT_ID',
-    'IAM_OAUTH_ISSUER', 'PTY_SERVICE', 'WEBSITE_ASSETS',
-  ]);
-});
-
-test('Cloudflare runtime status compares the active deployed version to the checked-in binding contract', async () => {
-  const projectConfig = readProjectConfig(root);
-  const contract = readCloudflareDeploymentContract(root, projectConfig);
-  const liveBindings = contract.bindings.map((row) => ({ name: row.name, type: row.type }));
-  liveBindings.push({ name: 'OPENAI_API_KEY', type: 'secret_text' });
-  const calls = [];
-  const result = await collectCloudflareDeploymentStatus({
-    root,
-    projectConfig,
-    runWrangler: async (command, input) => {
-      calls.push({ command, input });
-      if (command === 'whoami') return { data: { loggedIn: true } };
-      if (command === 'deployments.list') return { data: [{ id: 'dep_1', created_on: '2026-09-18T12:00:00Z', versions: [{ version_id: 'ver_1', percentage: 100 }] }] };
-      if (command === 'versions.list') return { data: [{ id: 'ver_1', metadata: { created_on: '2026-09-18T12:00:00Z' } }] };
-      if (command === 'versions.view') return { data: { id: 'ver_1', number: 37, metadata: { created_on: '2026-09-18T12:00:00Z', source: 'wrangler' }, resources: { bindings: liveBindings } } };
-      throw new Error(`unexpected:${command}`);
-    },
-    fetchImpl: async () => ({ ok: true, status: 200, async json() { return { ok: true, app: 'agentsam-sdk' }; } }),
-  });
-  assert.equal(result.connected, true);
-  assert.equal(result.bindings.match, true);
-  assert.equal(result.version.number, 37);
-  assert.equal(result.health.ok, true);
-  assert.equal(calls.find((row) => row.command === 'versions.view').input.version_id, 'ver_1');
-});
-
-test('unified status is ready only when account, model, terminal, deployment and health are real', async () => {
-  const local = {
-    root, project: 'agentsam-sdk', configured: true, git: { branch: 'main', revision: 'abc123', dirty: false },
-    pty: { online: false, url: 'http://127.0.0.1:3099/health' }, api: { online: false }, db: { ready: true, tables: [] },
-  };
-  const status = await collectRuntimeStatus({
-    cwd: root,
-    collectLocal: async () => local,
-    collectIdentity: async () => ({ authenticated: true, active_auth: { kind: 'browser_oauth' }, identity: { account_id: 'acct_1' }, api_key: {} }),
-    collectModels: async () => ({ providers: [{ id: 'openai', configured: true }], providerModels: { openai: [{ provider_model_id: 'gpt-test' }] }, local: { online: false, models: [] } }),
-    collectTerminal: async () => ({ connected: true, instances: [{ id: 'inst_1' }], connections: [{ id: 'conn_1', active: true, default: true, health: 'online' }], error: null }),
-    collectCloudflare: async () => ({ configured: true, connected: true, worker_name: 'agentsam-sdk', bindings: { match: true, live: [] }, health: { ok: true, status: 200 } }),
-  });
-  assert.equal(status.ready, true);
-  assert.equal(status.local_ready, true);
-  assert.equal(status.state_storage.actor_runtime, 'none');
-  assert.deepEqual(status.checks, { account: true, models: true, terminal: true, cloudflare: true });
-  assert.equal(status.model_summary.verified_provider_models, 1);
-});
-
-test('fresh local project can start before SQLite has been initialized', async () => {
-  const status = await collectRuntimeStatus({
-    cwd: root,
-    collectLocal: async () => ({ root, project: 'agentsam-sdk', configured: false, git: null, pty: { online: false }, api: {}, db: { exists: false, ready: false } }),
-    collectIdentity: async () => ({ authenticated: false, active_auth: {}, api_key: {} }),
-    collectModels: async () => ({ providers: [], providerModels: {}, local: { online: false, models: [] } }),
-    collectCloudflare: async () => ({ configured: false, bindings: { live: [] } }),
-  });
-  assert.equal(status.local_ready, true);
-  assert.equal(status.state_storage.migrated, false);
-  assert.equal(status.state_storage.runtime, 'sqlite');
-});
-
-test('unified status consumes the CLI-authorized terminal inventory returned by IAM context', async () => {
-  let legacyTerminalCalls = 0;
-  const status = await collectRuntimeStatus({
-    cwd: root,
-    collectLocal: async () => ({ root, project: 'agentsam-sdk', configured: true, git: null, pty: { online: false }, api: {}, db: {} }),
-    collectIdentity: async () => ({
-      authenticated: true,
-      active_auth: { kind: 'browser_oauth' },
-      api_key: {},
-      terminal: {
-        available: true,
-        instances: [{ id: 'inst_1', kind: 'local_device' }],
-        connections: [{ id: 'conn_1', instance_id: 'inst_1', is_active: true, is_default: true, health_status: 'online' }],
-      },
-    }),
-    collectModels: async () => ({ providers: [], providerModels: { openai: [{ provider_model_id: 'gpt-test' }] }, local: { online: false, models: [] } }),
-    collectTerminal: async () => { legacyTerminalCalls += 1; return { connected: false, instances: [], connections: [] }; },
-    collectCloudflare: async () => ({ configured: false }),
-  });
-  assert.equal(legacyTerminalCalls, 0);
-  assert.equal(status.terminal.active_connection_count, 1);
-  assert.equal(status.checks.terminal, true);
-});
-
-test('status command supports machine-readable injected runtime status', async () => {
-  const expected = { schema_version: 'agentsam-runtime-status-v1', ready: true };
-  let output = '';
-  const result = await runStatus(['--json'], { collectRuntime: async () => expected, write(value) { output += value; } });
-  assert.equal(result, expected);
-  const parsed = JSON.parse(output);
-  assert.equal(parsed.schema_version, expected.schema_version);
-  assert.equal(parsed.ready, expected.ready);
-  assert.ok(parsed.next?.actions?.length > 0);
-  assert.ok(parsed.next?.headline);
-});
-
-test('renderRuntimeStatus explicitly displays DB and other resource bindings', () => {
-  const status = {
-    local: { project: 'agentsam-sdk', root: '/path/to/project' },
-    ready: true,
-    local_ready: true,
-    checks: { account: true, models: true, terminal: true, cloudflare: true },
-    cloudflare: {
-      configured: true,
-      worker_name: 'agentsam-sdk',
-      version: { number: 43 },
-      bindings: {
-        match: true,
-        live: [
-          { name: 'DB', type: 'd1', database_name: 'inneranimalmedia-business' },
-          { name: 'WEBSITE_ASSETS', type: 'r2_bucket', bucket_name: 'agentsam-os-blueprint-content' },
-          { name: 'AGENTSAM_WAI', type: 'ai' },
-          { name: 'IAM_CLIENT_ID', type: 'plain_text' },
-          { name: 'OPENAI_API_KEY', type: 'secret_text' },
-        ],
-        declared: [
-          { name: 'DB', type: 'd1', database_name: 'inneranimalmedia-business' },
-          { name: 'WEBSITE_ASSETS', type: 'r2_bucket', bucket_name: 'agentsam-os-blueprint-content' },
-          { name: 'AGENTSAM_WAI', type: 'ai' },
-        ],
-        resources: [
-          { name: 'DB', type: 'd1', database_name: 'inneranimalmedia-business' },
-          { name: 'WEBSITE_ASSETS', type: 'r2_bucket', bucket_name: 'agentsam-os-blueprint-content' },
-          { name: 'AGENTSAM_WAI', type: 'ai' },
-        ],
-        runtime_variables: [{ name: 'IAM_CLIENT_ID', type: 'plain_text' }],
-        runtime_secrets: [{ name: 'OPENAI_API_KEY', type: 'secret_text' }],
-        missing: [],
-      },
-      health: { ok: true, status: 200 },
-    },
-  };
-
-  const stripAnsi = (text) => String(text || '').replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
-  const rendered = stripAnsi(renderRuntimeStatus(status));
-  assert.match(rendered, /bindings\s+.*5 live/);
-  assert.match(rendered, /• DB · d1 \(inneranimalmedia-business\)/);
-  assert.match(rendered, /• WEBSITE_ASSETS · r2 \(agentsam-os-blueprint-content\)/);
-  assert.match(rendered, /• AGENTSAM_WAI · ai/);
-  assert.match(rendered, /1 vars · 1 secrets/);
-});
-
-test('parseWranglerToml parses worker name, d1 databases, r2, hyperdrive, and vars', () => {
-  const sample = `
-name = "my-sample-worker"
-main = "src/index.js"
-
-[vars]
-ENVIRONMENT = "production"
-PORT = 8080
-
-[[d1_databases]]
-binding = "DB"
-database_name = "sample-production-db"
-database_id = "d1-uuid-123"
-
-[[r2_buckets]]
-binding = "UPLOADS"
-bucket_name = "sample-bucket"
-
-[[hyperdrive]]
-binding = "HYPERDRIVE"
-id = "hd-uuid-456"
-
-[ai]
-binding = "AI"
-`;
-
-  const parsed = parseWranglerToml(sample);
-  assert.equal(parsed.name, 'my-sample-worker');
-  assert.equal(parsed.vars.ENVIRONMENT, 'production');
-  assert.equal(parsed.vars.PORT, 8080);
-  assert.equal(parsed.d1_databases.length, 1);
-  assert.equal(parsed.d1_databases[0].binding, 'DB');
-  assert.equal(parsed.d1_databases[0].database_name, 'sample-production-db');
-  assert.equal(parsed.r2_buckets.length, 1);
-  assert.equal(parsed.r2_buckets[0].binding, 'UPLOADS');
-  assert.equal(parsed.hyperdrive.length, 1);
-  assert.equal(parsed.hyperdrive[0].binding, 'HYPERDRIVE');
-  assert.equal(parsed.ai.binding, 'AI');
-});
-
-test('resolveProjectD1Database discovers project DB binding from checked-in config', () => {
-  const resolved = resolveProjectD1Database(root);
-  assert.equal(resolved, 'inneranimalmedia-business');
-});

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

@@ -1,147 +0,0 @@
-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');
-  });
-});