@inneranimalmedia/agentsam-sdk 2.6.7 → 2.6.9

package/test/shell.test.mjs

@@ -1,281 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import test from 'node:test';
-import { dispatchShellLine, installPasteCollapse, renderCollapsedPaste, renderShellCatalog, renderShellPrompt, shouldCollapsePaste, tokenizeShellLine } from '../src/commands/shell.js';
-import { readCliPreferences, writeCliPreferences } from '../src/lib/cli-preferences.js';
-
-const repoRoot = path.resolve(new URL('..', import.meta.url).pathname);
-
-test('shell tokenizer preserves Windows paths and quoted arguments', () => {
-  assert.deepEqual(tokenizeShellLine('/cd C:\\Users\\conno\\fuelnreetime'), ['/cd', 'C:\\Users\\conno\\fuelnreetime']);
-  assert.deepEqual(tokenizeShellLine('/cd "C:\\Users\\Connor Smith\\repo"'), ['/cd', 'C:\\Users\\Connor Smith\\repo']);
-  assert.deepEqual(tokenizeShellLine('/agent "inspect this repo"'), ['/agent', 'inspect this repo']);
-});
-
-test('interactive prompt derives username and cwd instead of hardcoding Agent Sam identity', () => {
-  const env = { USER: 'alice', HOME: '/Users/alice' };
-  assert.equal(renderShellPrompt('/Users/alice/code/demo', env), 'alice ~/code/demo > ');
-  assert.equal(renderShellPrompt('/Users/alice', env), 'alice ~ > ');
-  assert.equal(renderShellPrompt('/tmp/demo', env), 'alice /tmp/demo > ');
-});
-
-test('shell startup stays quiet and points to the picker', () => {
-  const catalog = renderShellCatalog();
-  for (const command of ['/model', '/usage', '/help', '/exit']) {
-    assert.match(catalog, new RegExp(command.replace('/', '\\/')));
-  }
-  assert.match(catalog, /command picker/);
-  assert.match(catalog, /Type normally to work with the selected model/);
-  assert.doesNotMatch(catalog, /Slash commands \(/);
-  assert.doesNotMatch(catalog, /\/reasoning\s+Set reasoning/);
-});
-
-test('dispatch handles help, menu fallback, pwd, cd, and exit without falling through to host shell', async () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-'));
-  const child = path.join(root, 'child folder');
-  fs.mkdirSync(child);
-  let output = '';
-  const state = { cwd: root, write: (text) => { output += text; }, interactive: false };
-  let result = await dispatchShellLine('/help', state);
-  assert.equal(result.handled, true);
-  assert.match(output, /SAM = Systematic Autonomous Machinery/);
-  assert.match(output, /agentsam help <topic>/);
-  output = '';
-  await dispatchShellLine('/', state);
-  assert.match(output, /command picker/);
-  output = '';
-  await dispatchShellLine('/pwd', state);
-  assert.equal(output.trim(), root);
-  output = '';
-  await dispatchShellLine('/cd "child folder"', state);
-  assert.equal(state.cwd, child);
-  assert.equal(output.trim(), child);
-  result = await dispatchShellLine('/exit', state);
-  assert.equal(result.exit, true);
-});
-
-const stripAnsi = (text) => String(text || '').replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
-
-test('/usage renders the current session receipt without ending the session', async () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-usage-'));
-  let output = '';
-  const state = {
-    cwd: root, interactive: false, write: (text) => { output += text; },
-    session: {
-      id: 'asess_00000000-0000-4000-8000-000000000001', title: 'Usage test', model_key: 'openai:gpt-6-astra',
-      cumulative_usage: { input_tokens: 21_244, cached_input_tokens: 60_544, output_tokens: 219 },
-      total_cost_usd: 0.42, cost_breakdown_usd: { input: 0.2, cached_input: 0.02, output: 0.2 },
-    },
-  };
-  const result = await dispatchShellLine('/usage', state);
-  assert.equal(result.exit, false);
-  const clean = stripAnsi(output);
-  assert.match(clean, /AgentSam · Usage/);
-  assert.match(clean, /input\s+21\.2k/);
-  assert.match(clean, /output\s+219/);
-  assert.match(clean, /cached\s+60\.5k/);
-  assert.match(clean, /cost\s+\$0\.420/);
-  assert.match(clean, /agentsam resume asess_00000000-0000-4000-8000-000000000001/);
-});
-
-test('/logout signs out locally and emits the same resumable usage receipt', async () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-logout-'));
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-home-'));
-  let output = '';
-  const state = {
-    cwd: root, home, interactive: false, write: (text) => { output += text; },
-    session: {
-      id: 'asess_00000000-0000-4000-8000-000000000002', title: 'Logout test', model_key: 'openai:gpt-6-astra',
-      cumulative_usage: { input_tokens: 100, cached_input_tokens: 50, output_tokens: 25 },
-      total_cost_usd: 0.0125, cost_breakdown_usd: { input: 0.005, cached_input: 0.0025, output: 0.005 },
-    },
-  };
-  const result = await dispatchShellLine('/logout', state);
-  assert.equal(result.exit, false);
-  assert.match(output, /No local Agent Sam IAM session was stored/);
-  assert.match(output, /Token usage: total=125 input=100 \(\+ 50 cached\) output=25/);
-  assert.match(output, /Spent: \$0\.0125/);
-  assert.match(output, /agentsam resume asess_00000000-0000-4000-8000-000000000002/);
-});
-
-test('reasoning and service-tier commands persist only supported controls for an exact model', async () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-model-'));
-  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'model-demo' }));
-  writeCliPreferences(root, { trustedDirectory: true, modelPreference: 'openai:gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default' });
-  let output = '';
-  const state = { cwd: root, write: (text) => { output += text; }, interactive: false };
-  await dispatchShellLine('/reasoning high', state);
-  assert.equal(readCliPreferences(root).reasoningEffort, 'high');
-  await dispatchShellLine('/fast', state);
-  assert.equal(readCliPreferences(root).serviceTier, 'fast');
-  await dispatchShellLine('/flex', state);
-  assert.equal(readCliPreferences(root).serviceTier, 'flex');
-  await dispatchShellLine('/standard', state);
-  assert.equal(readCliPreferences(root).serviceTier, 'default');
-  assert.match(output, /reasoning → high/);
-  assert.match(output, /Fast is a paid latency choice/);
-  assert.match(output, /Flex trades latency/);
-});
-
-test('stale provider snapshots hydrate GPT-6 reasoning controls from the current catalog', async () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-stale-model-'));
-  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'stale-model-demo' }));
-  writeCliPreferences(root, {
-    trustedDirectory: true,
-    modelPreference: 'openai:gpt-6-luna',
-    reasoningEffort: 'auto',
-    serviceTier: 'default',
-    modelSnapshot: {
-      model_key: 'openai:gpt-6-luna',
-      provider: 'openai',
-      provider_model_id: 'gpt-6-luna',
-      label: 'gpt-6-luna',
-      availability: 'available',
-      availability_source: 'provider_api',
-      context_window: null,
-      context_window_source: 'unknown',
-      max_output_tokens: null,
-      max_output_tokens_source: 'unknown',
-      reasoning_efforts: ['auto'],
-      service_tiers: ['default'],
-      capabilities: { responses: true },
-    },
-  });
-
-  let output = '';
-  const state = { cwd: root, write: (text) => { output += text; }, interactive: false };
-  await dispatchShellLine('/reasoning', state);
-  assert.match(output, /auto \| none \| low \| medium \| high \| xhigh \| max/);
-  assert.match(output, /provider default: medium/);
-
-  output = '';
-  await dispatchShellLine('/reasoning high', state);
-  assert.equal(readCliPreferences(root).reasoningEffort, 'high');
-  assert.match(output, /reasoning → high/);
-
-  output = '';
-  await dispatchShellLine('/context', state);
-  assert.match(output, /1,050,000/);
-});
-
-test('bare /context shows truthful economics without inventing active token usage', async () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-context-'));
-  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'context-demo' }));
-  writeCliPreferences(root, { trustedDirectory: true, modelPreference: 'openai:gpt-6-astra', reasoningEffort: 'medium', serviceTier: 'default' });
-  let output = '';
-  await dispatchShellLine('/context', { cwd: root, write: (text) => { output += text; }, interactive: false });
-  assert.match(output, /1,050,000/);
-  assert.match(output, /272,000/);
-  assert.match(output, /180,000/);
-  assert.match(output, /unavailable · no provider\/local usage snapshot yet/);
-  assert.match(output, /Batch is a separate asynchronous execution lane/);
-});
-
-test('CLI supports a deterministic one-shot slash command for regression tests', () => {
-  const result = spawnSync(process.execPath, ['src/cli.js', 'shell', '--command', '/help'], { cwd: repoRoot, encoding: 'utf8' });
-  assert.equal(result.status, 0, result.stderr);
-  assert.match(result.stdout, /SAM = Systematic Autonomous Machinery/);
-  assert.match(result.stdout, /agentsam help <topic>/);
-  assert.match(result.stdout, /command picker/);
-});
-
-test('large pastes collapse into a single confirmation line', () => {
-  const pasted = ['one', 'two', 'three', 'four', 'five', 'six'].join('\n');
-  assert.equal(shouldCollapsePaste('short'), false);
-  assert.equal(shouldCollapsePaste(pasted), true);
-  assert.equal(shouldCollapsePaste('x'.repeat(301)), true);
-  assert.equal(renderCollapsedPaste(pasted), '[Pasted 6 lines — Enter to run, Backspace to clear]');
-
-  const writes = [];
-  const rl = {
-    terminal: true,
-    line: '',
-    cursor: 0,
-    _refreshLine() { writes.push(this.line); },
-    _ttyWrite(s) { this.line += s || ''; this.cursor = this.line.length; },
-  };
-  const restore = installPasteCollapse(rl);
-  rl._ttyWrite(pasted);
-  assert.equal(rl.line, '[Pasted 6 lines — Enter to run, Backspace to clear]');
-  rl._ttyWrite('', { name: 'backspace' });
-  assert.equal(rl.line, '');
-  restore();
-});
-
-test('dispatchShellLine accepts "agentsam <cmd>" and bare common verbs without slash prefix', async () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-shell-verb-'));
-  let output = '';
-  const state = { cwd: root, write: (text) => { output += text; }, interactive: false };
-
-  const r1 = await dispatchShellLine('agentsam help', state);
-  assert.equal(r1.handled, true);
-  assert.match(output, /SAM = Systematic Autonomous Machinery/);
-
-  output = '';
-  const r2 = await dispatchShellLine('help', state);
-  assert.equal(r2.handled, true);
-  assert.match(output, /SAM = Systematic Autonomous Machinery/);
-
-  const r3 = await dispatchShellLine('exit', state);
-  assert.equal(r3.exit, true);
-});
-
-test('/compact is discoverable, invokes native compaction, persists exact continuation and usage across resume', async () => {
-  const { SLASH_COMMANDS } = await import('../src/lib/slash-commands.js');
-  const { createLocalSession, loadLocalSession, loadSessionContinuation } = await import('../src/lib/local-sessions.js');
-  const { runResponsesAgent } = await import('../src/agent/responses-runner.js');
-  const { createOpenAIResponsesAdapter } = await import('../src/providers/openai-responses.js');
-  assert.ok(SLASH_COMMANDS.some(row => row.cmd === '/compact'));
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-compact-'));
-  fs.writeFileSync(path.join(root, 'package.json'), '{"name":"compact-test"}');
-  writeCliPreferences(root, { modelPreference: 'openai:gpt-6-astra', reasoningEffort: 'low', serviceTier: 'default' });
-  const session = createLocalSession({ cwd: root, project_root: root, model_key: 'openai:gpt-6-astra', reasoning_effort: 'low', requested_service_tier: 'default', provider_state: { provider: 'openai', previous_response_id: 'resp_prior' }, cumulative_usage: { input_tokens: 10 } });
-  const output = [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: 'Keep the selected architecture' }] }, { type: 'compaction', id: 'cmp_item', encrypted_content: 'opaque+/==exact' }];
-  const oldKey = process.env.OPENAI_API_KEY;
-  process.env.OPENAI_API_KEY = 'fixture-key';
-  let rendered = '', calls = 0;
-  const state = { cwd: root, projectRoot: root, interactive: false, session, write: text => { rendered += text; }, providerFetchImpl: async (url, init) => {
-    calls++;
-    assert.match(url, /responses\/compact$/);
-    assert.equal(JSON.parse(init.body).previous_response_id, 'resp_prior');
-    return { ok: true, status: 200, json: async () => ({ id: 'cmp_test', output, usage: { input_tokens: 1000, output_tokens: 100, input_tokens_details: { cached_tokens: 100 } } }) };
-  } };
-  try { await dispatchShellLine('/compact', state); }
-  finally { if (oldKey === undefined) delete process.env.OPENAI_API_KEY; else process.env.OPENAI_API_KEY = oldKey; }
-  assert.equal(calls, 1);
-  assert.match(rendered, /continuation saved/);
-  const resumed = loadLocalSession(session.id, { projectRoot: root });
-  assert.equal(resumed.cumulative_usage.input_tokens, 1010);
-  assert.equal(resumed.cumulative_usage.cached_input_tokens, 100);
-  assert.ok(resumed.total_cost_usd > 0);
-  assert.equal(resumed.latest_compaction.compaction_id, 'cmp_test');
-  const continuation = loadSessionContinuation(resumed);
-  assert.deepEqual(continuation.compacted_input, output);
-  assert.equal(resumed.provider_state.previous_response_id, undefined);
-  const adapter = createOpenAIResponsesAdapter({ apiKey: 'test', fetchImpl: async (_, init) => {
-    const body = JSON.parse(init.body);
-    assert.deepEqual(body.input.slice(0, output.length), output);
-    assert.equal(body.previous_response_id, undefined);
-    return { ok: true, status: 200, json: async () => ({ id: 'resp_next', output_text: 'done', output: [], usage: { input_tokens: 120, output_tokens: 10 } }) };
-  } });
-  await runResponsesAgent({ provider: adapter, capabilityAdapter: { toolDescriptors: () => [] }, model: 'gpt-6-astra', prompt: 'continue', cwd: root, instructions: '', previousProviderState: continuation, previousUsageSnapshot: resumed.usage_snapshot });
-  rendered = '';
-  await dispatchShellLine('/compact status', state);
-  assert.match(rendered, /180000/);
-  assert.match(rendered, /cmp_test/);
-  await dispatchShellLine('/session', state);
-  assert.match(rendered, /Latest compaction: cmp_test/);
-});
-
-test('/compact fails closed for unsupported provider without an HTTP request', async () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-compact-unsupported-'));
-  fs.writeFileSync(path.join(root, 'package.json'), '{"name":"unsupported"}');
-  writeCliPreferences(root, { modelPreference: 'gemini:test', modelSnapshot: { provider: 'gemini', model_key: 'gemini:test', provider_model_id: 'test', context_window: 128000, capabilities: {} } });
-  let rendered = '', calls = 0;
-  await dispatchShellLine('/compact', { cwd: root, interactive: false, write: text => { rendered += text; }, providerFetchImpl: async () => { calls++; } });
-  assert.equal(calls, 0);
-  assert.match(rendered, /native_compaction_unavailable:gemini/);
-});

package/test/skills.test.mjs

@@ -1,22 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { getSkill, listSkills, loadSkill } from '../src/skills/index.js';
-
-test('portable skill registry exposes AgentSam Jr Dev by id and alias', () => {
-  const listed = listSkills();
-  assert.ok(listed.some((skill) => skill.id === 'agentsam-jr-dev'));
-
-  assert.equal(getSkill('agentsam_jr_dev')?.id, 'agentsam-jr-dev');
-  assert.equal(getSkill('jr-dev')?.id, 'agentsam-jr-dev');
-});
-
-test('AgentSam Jr Dev loads compact instructions and references on demand', () => {
-  const compact = loadSkill('agentsam-jr-dev');
-  assert.match(compact.instructions, /# AgentSam Jr Dev/);
-  assert.equal('references' in compact, false);
-
-  const full = loadSkill('agentsam_jr_dev', { references: true });
-  assert.equal(full.references.length, 2);
-  assert.match(full.references[0].content, /## HTTP/);
-  assert.match(full.references[1].content, /# Real Application Logic/);
-});

package/test/smoke.mjs

@@ -1,122 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { AgentSam, routeIntent, getToolCatalog } from '../src/index.js';
-import { buildLocalScaffoldMeta, sdkDependencySpec } from '../src/lib/local-scaffold.js';
-import { writeScaffoldFiles } from '../src/lib/write-files.js';
-import { initializeLocalSqlite, createLocalSqliteDatabase } from '../src/local/sqlite.js';
-import { printContextSummary, missingForInit } from '../src/lib/detect-context.js';
-
-const app = new AgentSam({ project: 'smoke', lane: 'cms', agent: 'cms' });
-let res = await app.handle(new Request('https://example.com/api/health'));
-assert.equal(res.status, 200);
-assert.equal((await res.json()).ok, true);
-
-res = await app.handle(new Request('https://example.com/api/agentsam/info'));
-const info = await res.json();
-assert.equal(info.agent, 'cms');
-assert.ok(info.capabilities.includes('page'));
-
-res = await app.handle(new Request('https://example.com/api/agentsam/message', {
-  method: 'POST',
-  body: JSON.stringify({ message: 'create an analytics page in the cms' }),
-}));
-const message = await res.json();
-assert.equal(message.agent, 'cms');
-assert.equal(message.intent, 'cms_build');
-
-assert.equal(routeIntent({ message: 'drop table users' }).requires_approval, true);
-assert.ok(getToolCatalog('Data Solutions').some((tool) => tool.name === 'query'));
-
-const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-sdk-test-'));
-const dir = writeScaffoldFiles(path.join(tmp, 'demo-project'), [
-  { path: 'src/agent.js', content: 'export function createAgent() {}\n' },
-  { path: 'db/schema.sql', content: 'CREATE TABLE cms_pages (id TEXT PRIMARY KEY);\n' },
-  { path: '.env.example', content: 'AGENTSAM_DB=.agentsam/data/agentsam.sqlite\n' },
-]);
-assert.ok(fs.existsSync(path.join(dir, 'src/agent.js')));
-assert.ok(fs.readFileSync(path.join(dir, 'db/schema.sql'), 'utf8').includes('cms_pages'));
-assert.ok(fs.readFileSync(path.join(dir, '.env.example'), 'utf8').includes('AGENTSAM_DB'));
-
-import { SLASH_COMMANDS, listSlashCommands } from '../src/lib/slash-commands.js';
-import { createIdentityClient, AUTH_COOKIE_NAME } from '../src/index.js';
-import { finalizeInboundOAuth } from '../packages/identity/src/oauth/callback.js';
-assert.equal(AUTH_COOKIE_NAME, 'session');
-assert.equal(createIdentityClient().providers.google()?.id, 'google');
-const { GoogleProvider } = await import('@inneranimalmedia/agentsam-sdk/identity/providers/google');
-assert.equal(GoogleProvider.id, 'google');
-const { handleIdentityWorkerRequest } = await import('@inneranimalmedia/agentsam-sdk/identity/server/worker-router');
-assert.equal(typeof handleIdentityWorkerRequest, 'function');
-const { buildIdentityAppScaffold } = await import('../src/lib/identity-scaffold.js');
-assert.ok(buildIdentityAppScaffold({ projectName: 'x' })['backend/src/index.js']);
-await assert.rejects(() => finalizeInboundOAuth({}, new Request('https://x'), {}), /adapter/);
-assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/deploy'));
-assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/db'));
-assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/agent'));
-assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/model'));
-assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/providers'));
-assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/reasoning'));
-assert.ok(SLASH_COMMANDS.some((c) => c.cmd === '/fast'));
-assert.deepEqual(
-  listSlashCommands({ lane: 'deploy' }).map(({ cmd }) => cmd),
-  ['/settings', '/deploy', '/help', '/exit'],
-  'deploy lane keeps global shell controls and excludes commands from other lanes',
-);
-
-printContextSummary({
-  iam: { ready: true, source: 'api_key', detail: 'AGENTSAM_API_KEY' },
-  gcp: { source: 'vm-metadata', email: 'execos@project.iam.gserviceaccount.com' },
-  gcp_vm: true,
-  github: { source: 'gh-cli', account: 'user@example.com' },
-  cloudflare: { source: 'wrangler', account: 'user@cloudflare.test' },
-});
-assert.deepEqual(missingForInit({ iam: { ready: false } }, '', { runTarget: 'local' }), []);
-assert.deepEqual(missingForInit({ iam: { ready: false } }, '', { runTarget: 'cloudflare' }), ['iam']);
-
-assert.equal(sdkDependencySpec('2.0.0-alpha.identity.12'), '2.0.0-alpha.identity.12');
-assert.equal(sdkDependencySpec('2.1.3'), '^2.1.3');
-const prereleaseMeta = buildLocalScaffoldMeta(
-  { projectName: 'alpha-demo', lane: 'fullstack', runTarget: 'local' },
-  '2.0.0-alpha.identity.12',
-);
-const prereleasePackage = JSON.parse(prereleaseMeta.files.find((f) => f.path === 'package.json').content);
-assert.equal(
-  prereleasePackage.dependencies['@inneranimalmedia/agentsam-sdk'],
-  '2.0.0-alpha.identity.12',
-);
-
-const localMeta = buildLocalScaffoldMeta({ projectName: 'demo', lane: 'cms', runTarget: 'local' });
-assert.equal(localMeta.laneKey, 'cms');
-assert.ok(localMeta.files.some((f) => f.path === '.agentsam/start-local.md'));
-assert.ok(localMeta.files.some((f) => f.path === 'db/schema.sql'));
-assert.ok(localMeta.files.some((f) => f.path === '.env'));
-assert.ok(localMeta.files.some((f) => f.path === '.env.example'));
-assert.ok(localMeta.files.some((f) => f.path === 'src/agent.js'));
-assert.ok(!localMeta.files.some((f) => f.path === 'wrangler.toml'));
-assert.ok(!localMeta.files.some((f) => f.path.startsWith('gorilla/')));
-assert.ok(!localMeta.files.some((f) => f.path.includes('execos')));
-
-const localDir = path.join(tmp, 'local-project');
-writeScaffoldFiles(localDir, localMeta.files);
-const localDb = await initializeLocalSqlite({
-  dbPath: path.join(localDir, '.agentsam', 'data', 'agentsam.sqlite'),
-  schemaPath: path.join(localDir, 'db', 'schema.sql'),
-});
-assert.ok(localDb.tables.includes('agent_sessions'));
-const d1Like = await createLocalSqliteDatabase(localDb.dbPath);
-await d1Like.prepare('INSERT INTO agent_sessions (id, agent, lane, status) VALUES (?, ?, ?, ?)').bind(
-  'sess_test', 'cms', 'cms', 'created',
-).run();
-const persisted = await d1Like.prepare('SELECT id FROM agent_sessions WHERE id = ?').bind('sess_test').first();
-assert.equal(persisted.id, 'sess_test');
-d1Like.close();
-
-const tunnelPath = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'src', 'commands', 'tunnel.js');
-const tunnelSrc = fs.readFileSync(tunnelPath, 'utf8');
-assert.ok(tunnelSrc.includes('parseWranglerTunnelList'));
-assert.ok(tunnelSrc.includes('wrangler'));
-assert.ok(fs.existsSync(tunnelPath));
-
-console.log('SDK smoke tests passed');

package/test/telemetry.test.mjs

@@ -1,79 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { createAgentEvent, createUsageSnapshot } from '../src/telemetry/index.js';
-
-test('AgentEvent is compact serializable provider-neutral telemetry', () => {
-  const event = createAgentEvent('context.compaction.completed', { before: 181_000, after: 72_000 }, {
-    runId: 'run_test', sequence: 4, timestamp: '2026-09-12T00:00:00.000Z',
-  });
-  assert.equal(event.type, 'context.compaction.completed');
-  assert.equal(event.run_id, 'run_test');
-  assert.doesNotThrow(() => JSON.stringify(event));
-});
-
-test('current active context and cumulative run usage are different metrics', () => {
-  const usage = createUsageSnapshot({
-    current_context: { input_tokens: 48_000, window_tokens: 1_050_000 },
-    cumulative: { input_tokens: 310_000, output_tokens: 22_000, cached_input_tokens: 120_000, cache_write_tokens: 12_000, reasoning_tokens: 8_000 },
-    estimate_kind: 'provider',
-  });
-  assert.equal(usage.current_context.input_tokens, 48_000);
-  assert.equal(usage.cumulative.input_tokens, 310_000);
-  assert.equal(usage.provider_authoritative, true);
-});
-
-import {
-  createRunReceipt,
-  createUsageReceipt,
-  createApprovalReceipt,
-  createTerminalJobReceipt,
-} from '../src/telemetry/index.js';
-
-test('runtime receipts are account-owned and emit no tenant/workspace/user ownership aliases', () => {
-  const run = createRunReceipt({
-    id: 'arun_1', account_id: 'au_1', mode: 'agent', status: 'running',
-    source_client: 'cli', surface: 'cli', reasoning_effort: 'high', requested_service_tier: 'fast',
-  });
-  assert.equal(run.account_id, 'au_1');
-  assert.equal(run.source_client, 'cli');
-  assert.equal(run.requested_service_tier, 'fast');
-  assert.equal('user_id' in run, false);
-  assert.equal('tenant_id' in run, false);
-  assert.equal('workspace_id' in run, false);
-});
-
-test('usage receipt models exactly one provider call and keeps cache/reasoning economics', () => {
-  const usage = createUsageReceipt({
-    id: 'ue_1', account_id: 'au_1', agent_run_id: 'arun_1', provider: 'openai', model_key: 'gpt-6-astra',
-    model_call_index: 2, provider_request_id: 'resp_1', input_tokens: 1000, cached_input_tokens: 600,
-    cache_write_tokens: 20, output_tokens: 100, reasoning_tokens: 40, cost_usd: 0.12, cost_basis: 'provider',
-  });
-  assert.equal(usage.total_tokens, 1100);
-  assert.equal(usage.cached_input_tokens, 600);
-  assert.equal(usage.reasoning_tokens, 40);
-  assert.equal(usage.model_call_index, 2);
-});
-
-test('approval and terminal receipts preserve lineage without turning D1 into transcript storage', () => {
-  const approval = createApprovalReceipt({
-    id: 'appr_1', account_id: 'au_1', agent_run_id: 'arun_1', tool_call_id: 'call_1', terminal_job_id: 'tjob_1',
-    action_summary: 'Deploy worker', sanitizedInput: { worker: 'api' }, risk_level: 'high',
-  });
-  assert.equal(approval.terminal_job_id, 'tjob_1');
-  assert.match(approval.sanitized_input_json, /worker/);
-
-  const job = createTerminalJobReceipt({
-    id: 'tjob_1', account_id: 'au_1', instance_id: 'tinst_1', connection_id: 'conn_1',
-    execos_run_id: 'xrun_1', status: 'running', idempotency_key: 'idem_1', max_attempts: 1,
-  });
-  assert.equal(job.execos_run_id, 'xrun_1');
-  assert.equal(job.max_attempts, 1);
-  assert.equal('stdout' in job, false);
-  assert.equal('stderr' in job, false);
-  assert.equal('command' in job, false);
-});
-
-test('runtime receipts refuse model-invented account identity', () => {
-  assert.throws(() => createRunReceipt({ id: 'arun_1' }), /account_id is required/);
-  assert.throws(() => createUsageReceipt({ id: 'ue_1', provider: 'openai', model_key: 'gpt-6-astra' }), /account_id is required/);
-});

package/test/terminal/local-pty.mock.test.mjs

@@ -1,153 +0,0 @@
-import assert from 'node:assert/strict';
-import { EventEmitter } from 'node:events';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-import { pathToFileURL } from 'node:url';
-import {
-  attachLocalPtySession,
-  ensureNodePtySpawnHelperExecutable,
-  startLocalPtyServer,
-} from '../../src/local-pty/server.js';
-
-function fakeTransports() {
-  const writes = [];
-  const resizes = [];
-  let killed = 0;
-  let dataHandler = null;
-  let exitHandler = null;
-
-  const pty = {
-    spawn(shell, args, options) {
-      assert.equal(Array.isArray(args), true);
-      assert.equal(options.env.AGENTSAM_LOCAL_PTY, '1');
-      return {
-        write(value) { writes.push(value); },
-        resize(cols, rows) { resizes.push([cols, rows]); },
-        kill() { killed += 1; },
-        onData(fn) { dataHandler = fn; },
-        onExit(fn) { exitHandler = fn; },
-      };
-    },
-  };
-
-  class FakeWs extends EventEmitter {
-    OPEN = 1;
-    readyState = 1;
-    sent = [];
-    send(value) { this.sent.push(String(value)); }
-    close() {
-      if (this.readyState !== this.OPEN) return;
-      this.readyState = 3;
-      this.emit('close');
-    }
-  }
-
-  const ws = new FakeWs();
-  return {
-    pty,
-    ws,
-    writes,
-    resizes,
-    killed: () => killed,
-    emitData(value) { dataHandler?.(value); },
-    emitExit() { exitHandler?.(); },
-  };
-}
-
-test('macOS node-pty helper is made executable before runtime import', (t) => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-node-pty-helper-'));
-  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
-  const libDir = path.join(root, 'lib');
-  const helperDir = path.join(root, 'prebuilds', 'darwin-arm64');
-  fs.mkdirSync(libDir, { recursive: true });
-  fs.mkdirSync(helperDir, { recursive: true });
-  fs.writeFileSync(path.join(libDir, 'index.js'), '');
-  const helper = path.join(helperDir, 'spawn-helper');
-  fs.writeFileSync(helper, 'fake');
-  fs.chmodSync(helper, 0o644);
-
-  const result = ensureNodePtySpawnHelperExecutable({
-    platform: 'darwin',
-    arch: 'arm64',
-    resolveModule: () => pathToFileURL(path.join(libDir, 'index.js')).href,
-  });
-
-  assert.equal(result.checked, true);
-  assert.equal(result.changed, true);
-  assert.equal(result.path, helper);
-  assert.notEqual(fs.statSync(helper).mode & 0o111, 0);
-
-  const second = ensureNodePtySpawnHelperExecutable({
-    platform: 'darwin',
-    arch: 'arm64',
-    resolveModule: () => pathToFileURL(path.join(libDir, 'index.js')).href,
-  });
-  assert.equal(second.changed, false);
-});
-
-test('local PTY wire protocol is release-testable entirely in memory', () => {
-  const transport = fakeTransports();
-  const session = attachLocalPtySession({
-    ws: transport.ws,
-    pty: transport.pty,
-    shell: '/bin/test-shell',
-    cwd: '/tmp/test-project',
-    cols: 80,
-    rows: 24,
-    env: {},
-    sessionId: 'local_test',
-  });
-
-  assert.equal(session.session_id, 'local_test');
-  assert.deepEqual(JSON.parse(transport.ws.sent[0]), {
-    type: 'session_id',
-    session_id: 'local_test',
-  });
-
-  transport.ws.emit('message', Buffer.from(JSON.stringify({ type: 'resize', cols: 120, rows: 40 })));
-  transport.ws.emit('message', Buffer.from(JSON.stringify({ type: 'slash', line: '/pwd' })));
-  transport.ws.emit('message', Buffer.from('raw input'));
-
-  assert.deepEqual(transport.resizes, [[120, 40]]);
-  assert.deepEqual(transport.writes, ['/pwd\r', 'raw input']);
-
-  transport.emitData('terminal output');
-  assert.equal(transport.ws.sent.at(-1), 'terminal output');
-
-  transport.ws.close();
-  assert.equal(transport.killed(), 1);
-
-  // Cleanup is idempotent even when transport error/close paths race.
-  transport.ws.emit('error', new Error('synthetic transport close'));
-  session.cleanup();
-  assert.equal(transport.killed(), 1);
-});
-
-test('local PTY server health check uses an ephemeral local port and no ExecOS tunnel', async () => {
-  const transport = fakeTransports();
-  const server = await startLocalPtyServer({
-    cwd: process.cwd(),
-    host: '127.0.0.1',
-    port: 0,
-    pty: transport.pty,
-  });
-
-  try {
-    const health = await fetch(server.healthUrl);
-    assert.equal(health.status, 200);
-    const body = await health.json();
-    assert.equal(body.ok, true);
-    assert.equal(body.service, 'agentsam.local.runtime');
-    assert.equal(body.plane, 'local');
-    assert.equal(body.service_legacy, 'agentsam-local-pty');
-    assert.equal(body.port, server.port);
-    assert.equal(server.port > 0, true);
-  } finally {
-    await server.close();
-  }
-
-  // No WebSocket session was opened, so the PTY process was never spawned.
-  assert.equal(transport.killed(), 0);
-});