@inneranimalmedia/agentsam-sdk 2.6.5 → 2.6.8

package/test/local-sessions.test.mjs

@@ -1,57 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import test from 'node:test';
-import { createLocalSession, listLocalSessions, loadLocalSession, saveLocalSession, sessionTitleFromInput } from '../src/lib/local-sessions.js';
-import { renderSessionReceipt } from '../src/commands/shell.js';
-
-function tempHome(t) {
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-session-home-'));
-  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
-  return home;
-}
-
-test('local sessions persist safe continuation, usage, cost, and an explicit title', t => {
-  const home = tempHome(t);
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-session-project-'));
-  t.after(() => fs.rmSync(cwd, { recursive: true, force: true }));
-  let session = createLocalSession({ cwd, last_input: 'Run wrangler whoami' }, { home });
-  assert.match(session.id, /^asess_[0-9a-f-]{36}$/i);
-  assert.equal(session.title, 'Agent Sam session');
-  assert.equal(session.last_input, null);
-  session = saveLocalSession({
-    ...session,
-    title: sessionTitleFromInput('Run wrangler whoami'),
-    model_key: 'openai:gpt-6-astra',
-    actual_service_tier: 'fast',
-    provider_state: { provider: 'openai', previous_response_id: 'resp_123' },
-    usage_snapshot: { current_context: { input_tokens: 21_244, window_tokens: 1_050_000 } },
-    cumulative_usage: { input_tokens: 21_244, cached_input_tokens: 60_544, output_tokens: 219, reasoning_tokens: 31 },
-    total_cost_usd: 0.123456,
-    cost_breakdown_usd: { input: 0.08, cached_input: 0.01, cache_write: 0.003456, output: 0.03 },
-    status: 'paused',
-    active_elapsed_ms: 90_000,
-    active_started_at: null,
-  }, { home });
-
-  const loaded = loadLocalSession(session.id, { home, cwd });
-  assert.equal(loaded.provider_state.previous_response_id, 'resp_123');
-  assert.equal(loaded.cumulative_usage.cached_input_tokens, 60_544);
-  assert.equal(listLocalSessions({ home, cwd })[0].id, session.id);
-  assert.equal(loaded.project_root, cwd);
-  assert.equal(loaded.storage.runtime, 'sqlite');
-  assert.equal(loaded.storage.path, '.agentsam/data/agentsam.sqlite');
-  assert.equal(loaded.storage.remote, null);
-  assert.equal(loaded.storage.capabilities.local_only, true);
-  assert.equal(fs.existsSync(path.join(home, '.agentsam', 'sessions', `${session.id}.json`)), false);
-  assert.equal(fs.existsSync(path.join(cwd, '.agentsam', 'data', 'agentsam.sqlite')), true);
-
-  const receipt = renderSessionReceipt(loaded);
-  assert.match(receipt, /Token usage: total=21,463 input=21,244 \(\+ 60,544 cached\) output=219 reasoning=31/);
-  assert.match(receipt, /Spent: \$0\.1235/);
-  assert.match(receipt, /Elapsed: 1m 30s/);
-  assert.match(receipt, /Cost breakdown: input \$0\.0800 · cached \$0\.0100 · cache write \$0\.003456 · output \$0\.0300/);
-  assert.match(receipt, new RegExp(`agentsam resume ${session.id}`));
-  assert.match(receipt, /Run wrangler whoami/);
-});

package/test/local-studio-deploy.test.mjs

@@ -1,83 +0,0 @@
-import assert from 'node:assert/strict';
-import path from 'node:path';
-import os from 'node:os';
-import fs from 'node:fs';
-import { describe, it } from 'node:test';
-import { fileURLToPath } from 'node:url';
-import {
-  DEPLOY_INPUT_GLOBS,
-  loadOptionalCloudflareEnv,
-  resolveLocalStudioDeployable,
-  wranglerDeployCommand,
-  isLocalStudioCheckout,
-  runLocalStudioDeploy,
-} from '../src/lib/deploy/local-studio.js';
-import { productionDeployBlockedReason } from '../src/lib/deploy/git-guard.js';
-
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-
-describe('local-studio deploy resolver', () => {
-  it('resolves apps/local-studio + backend/wrangler.jsonc from the repo', () => {
-    const target = resolveLocalStudioDeployable(root);
-    assert.equal(target.provider, 'cloudflare');
-    assert.equal(target.app, 'local-studio');
-    assert.equal(path.basename(path.dirname(target.wranglerConfig)), 'backend');
-    assert.deepEqual(target.wranglerArgs, ['deploy', '-c', 'backend/wrangler.jsonc']);
-    assert.equal(isLocalStudioCheckout(root), true);
-    const cmd = wranglerDeployCommand(target, { dryRun: true });
-    assert.equal(cmd.bin, process.platform === 'win32' ? 'npx.cmd' : 'npx');
-    assert.equal(cmd.cwd, target.appRoot);
-    assert.deepEqual(cmd.args, ['wrangler', 'deploy', '-c', 'backend/wrangler.jsonc', '--dry-run']);
-  });
-
-  it('fingerprints the cloudflare connector package', () => {
-    assert.equal(DEPLOY_INPUT_GLOBS.includes('packages/connectors/cloudflare'), true);
-    assert.equal(DEPLOY_INPUT_GLOBS.includes('apps/local-studio'), true);
-  });
-
-  it('treats missing .env.cloudflare as optional', () => {
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'cf-env-'));
-    const loaded = loadOptionalCloudflareEnv(tmp);
-    assert.equal(loaded.loaded, false);
-    assert.deepEqual(loaded.vars, {});
-  });
-
-  it('plan does not invoke wrangler', async () => {
-    const result = await runLocalStudioDeploy({ cwd: root, planOnly: true, execute: false });
-    assert.equal(result.plan.provider, 'cloudflare');
-    assert.equal(result.plan.wranglerConfig, 'apps/local-studio/backend/wrangler.jsonc');
-    assert.equal(result.plan.genericRootDeploy, false);
-    assert.equal(result.receipt.plan, true);
-    assert.equal(result.receipt.promoted, false);
-    assert.equal(result.receipt.wranglerConfig, 'apps/local-studio/backend/wrangler.jsonc');
-    assert.equal(result.receipt.hostname, 'agentsam.inneranimalmedia.com');
-  });
-
-  it('blocks production deploys from feat branches', () => {
-    const reason = productionDeployBlockedReason({
-      ok: true,
-      branch: 'feat/cloudflare-connector-deploy-control',
-      detached: false,
-      head: 'aaa',
-      originMain: 'aaa',
-      dirty: false,
-      tmpCheckout: false,
-      repoRoot: root,
-    });
-    assert.match(reason, /feat\/cloudflare-connector-deploy-control/);
-  });
-
-  it('allows production only when HEAD is a clean origin/main', () => {
-    const reason = productionDeployBlockedReason({
-      ok: true,
-      branch: 'main',
-      detached: false,
-      head: 'abc',
-      originMain: 'abc',
-      dirty: false,
-      tmpCheckout: false,
-      repoRoot: root,
-    });
-    assert.equal(reason, null);
-  });
-});

package/test/loopback-oauth.test.mjs

@@ -1,53 +0,0 @@
-import assert from 'node:assert/strict';
-import http from 'node:http';
-import { describe, it } from 'node:test';
-import { createLoopbackCallbackListener } from '../src/lib/auth.js';
-
-describe('loopback OAuth callback', () => {
-  it('settles waitForCallback when browser hits success page', async () => {
-    const state = 'test_state_abc';
-    const listener = await createLoopbackCallbackListener({
-      state,
-      host: '127.0.0.1',
-      timeoutMs: 5_000,
-    });
-    try {
-      const wait = listener.waitForCallback();
-      const port = new URL(listener.redirectUri).port;
-      const res = await fetch(
-        `http://127.0.0.1:${port}/callback?state=${state}&code=auth_code_xyz`,
-      );
-      assert.equal(res.status, 200);
-      const html = await res.text();
-      assert.match(html, /Authentication complete/);
-      const callback = await wait;
-      assert.equal(callback.code, 'auth_code_xyz');
-      assert.equal(callback.state, state);
-    } finally {
-      await listener.close();
-    }
-  });
-
-  it('does not settle on code-less probe so a later redirect can succeed', async () => {
-    const state = 'test_state_probe';
-    const listener = await createLoopbackCallbackListener({
-      state,
-      host: '127.0.0.1',
-      timeoutMs: 5_000,
-    });
-    try {
-      const wait = listener.waitForCallback();
-      const port = new URL(listener.redirectUri).port;
-      const probe = await fetch(`http://127.0.0.1:${port}/callback?state=${state}`);
-      assert.equal(probe.status, 400);
-      const res = await fetch(
-        `http://127.0.0.1:${port}/callback?state=${state}&code=real_code`,
-      );
-      assert.equal(res.status, 200);
-      const callback = await wait;
-      assert.equal(callback.code, 'real_code');
-    } finally {
-      await listener.close();
-    }
-  });
-});

package/test/merkle-render.test.mjs

@@ -1,31 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { renderExplorer, renderSummary, safeText, treeRows } from '../src/ui/merkle/render.js';
-
-const hash = 'sha256:' + 'a'.repeat(64);
-const entries = [
-  { path: '', type: 'directory', hash },
-  { path: 'src', type: 'directory', hash },
-  { path: 'src/app.js', type: 'file', hash, size: 12 },
-  { path: 'bad\x1b[2J.txt', type: 'file', hash, size: 1 },
-];
-const tree = { rootPath: '/tmp/project', rootHash: hash, stats: { files: 2, symlinks: 0, bytes: 13 }, entries };
-test('terminal rendering escapes file control sequences and fits a mobile terminal', () => {
-  const state = { result: { title: 'Merkle root', tree }, expanded: new Set(['', 'src']), selected: 0 };
-  const frame = renderExplorer(state, { columns: 40, rows: 24 });
-  assert.ok(!frame.includes('\x1b'));
-  assert.ok(frame.includes('\\u001b'));
-  assert.ok(frame.split('\r\n').every((line) => [...line].length <= 39));
-  assert.ok(frame.split('\r\n').length <= 23);
-  assert.ok(frame.replaceAll('\r\n', '').includes(hash), 'full selected hash wraps without truncation');
-  assert.equal(safeText('a\nb'), 'a\\u000ab');
-  assert.ok(!renderSummary({ title: 'Merkle', tree }, { inspect: true }).includes('\x1b'));
-});
-test('explorer expands folders and can filter unchanged branches', () => {
-  const result = { title: 'Verify', before: tree, tree: { ...tree, entries: entries.map((entry) => entry.path === 'src/app.js' ? { ...entry, hash: 'sha256:' + 'b'.repeat(64) } : entry) } };
-  assert.ok(!treeRows(result, new Set([''])).some((entry) => entry.path === 'src/app.js'));
-  assert.ok(treeRows(result, new Set(['', 'src'])).some((entry) => entry.path === 'src/app.js'));
-  const changed = treeRows({ ...result, tree: { ...result.tree, entries: result.tree.entries.map((entry) => entry.type === 'directory' ? { ...entry, hash: 'sha256:' + 'b'.repeat(64) } : entry) } }, new Set(['', 'src']), true);
-  assert.ok(changed.some((entry) => entry.path === 'src/app.js'));
-  assert.ok(!changed.some((entry) => entry.path.startsWith('bad')));
-});

package/test/mini.test.mjs

@@ -1,140 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import fs from 'node:fs';
-import http from 'node:http';
-import net from 'node:net';
-import os from 'node:os';
-import path from 'node:path';
-import { execFileSync, spawn } from 'node:child_process';
-import { once } from 'node:events';
-import { fileURLToPath } from 'node:url';
-import { createMini, MINI_TEMPLATES, startMiniPreview } from '../src/lib/mini/index.js';
-
-const cli = fileURLToPath(new URL('../src/cli.js', import.meta.url));
-function fixture(t) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-mini-test-'));
-  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
-  return dir;
-}
-function request(url, pathname, { method = 'GET', headers = {} } = {}) {
-  return new Promise((resolve, reject) => {
-    const req = http.request(url + pathname, { method, headers }, (res) => {
-      let body = '';
-      res.on('data', (chunk) => { body += chunk; });
-      res.on('end', () => resolve({ status: res.statusCode, headers: res.headers, body }));
-    });
-    req.on('error', reject);
-    req.end();
-  });
-}
-
-test('all mini starters are portable files; existing projects are never overwritten', (t) => {
-  const cwd = fixture(t);
-  for (const template of Object.keys(MINI_TEMPLATES)) {
-    const { root } = createMini({ name: template, template, cwd });
-    const html = fs.readFileSync(path.join(root, 'public/index.html'), 'utf8');
-    assert.ok(html.includes('<title>' + template));
-    assert.ok(!html.includes('{{NAME}}'));
-    execFileSync(process.execPath, ['--check', path.join(root, 'public/app.js')]);
-    assert.ok(fs.existsSync(path.join(root, 'public/style.css')));
-    assert.ok(!fs.existsSync(path.join(root, 'node_modules')));
-    assert.ok(!fs.existsSync(path.join(root, 'package.json')));
-    assert.throws(() => createMini({ name: template, template, cwd }), /EEXIST/);
-    assert.equal(fs.readFileSync(path.join(root, 'public/index.html'), 'utf8'), html);
-  }
-  assert.throws(() => createMini({ name: '../escape', cwd }), /name/);
-  assert.throws(() => createMini({ name: 'bad', template: 'constructor', cwd }), /Unknown template/);
-  assert.ok(!fs.existsSync(path.join(cwd, 'bad')));
-});
-
-test('preview reflects edits and protects files outside public/', async (t) => {
-  const cwd = fixture(t);
-  const { root } = createMini({ name: 'preview-test', cwd });
-  fs.writeFileSync(path.join(root, 'secret.txt'), 'private-project-file');
-  fs.writeFileSync(path.join(root, 'public/.env'), 'private-dotfile');
-  fs.writeFileSync(path.join(root, 'public/.secret.txt'), 'private-dotfile');
-  fs.symlinkSync(path.join(root, 'public/.secret.txt'), path.join(root, 'public/alias.txt'));
-  fs.symlinkSync(path.join(root, 'secret.txt'), path.join(root, 'public/linked.txt'));
-  const preview = await startMiniPreview({ root, timeoutSeconds: 30 });
-  t.after(() => preview.stop());
-  const home = await request(preview.url, '/');
-  assert.equal(home.status, 200);
-  assert.match(home.body, /focus timer/i);
-  assert.equal(home.headers['cache-control'], 'no-store');
-  assert.equal((await request(preview.url, '/app.js')).status, 200);
-  assert.equal((await request(preview.url, '/', { method: 'HEAD' })).body, '');
-  assert.equal((await request(preview.url, '/', { method: 'POST' })).status, 405);
-  for (const target of ['/mini.json', '/secret.txt', '/.env', '/%2eenv', '/linked.txt', '/alias.txt', '/%2e%2e/secret.txt', '/missing', '/%5csecret.txt']) {
-    assert.equal((await request(preview.url, target)).status, 404, target);
-  }
-  assert.equal((await request(preview.url, '/%ZZ')).status, 400);
-  assert.equal((await request(preview.url, '/', { headers: { Host: 'example.com' } })).status, 403);
-  assert.equal((await request(preview.url, '/', { headers: { Origin: 'https://example.com' } })).status, 403);
-  fs.writeFileSync(path.join(root, 'public/index.html'), '<h1>Edited locally</h1>');
-  assert.equal((await request(preview.url, '/')).body, '<h1>Edited locally</h1>');
-  await preview.stop();
-  await assert.rejects(request(preview.url, '/'));
-  assert.ok(fs.existsSync(root));
-});
-
-test('preview refuses a public directory that points outside the project', async (t) => {
-  const cwd = fixture(t);
-  const { root } = createMini({ name: 'symlink-test', cwd });
-  fs.rmSync(path.join(root, 'public'), { recursive: true });
-  fs.symlinkSync(cwd, path.join(root, 'public'), 'dir');
-  await assert.rejects(startMiniPreview({ root }), /public\/ must be inside/);
-});
-
-test('timeout shuts the listener and open connections, retaining files', async (t) => {
-  const cwd = fixture(t);
-  const { root } = createMini({ name: 'timeout-test', cwd });
-  const preview = await startMiniPreview({ root, timeoutSeconds: 1 });
-  t.after(() => preview.stop());
-  const socket = net.connect(Number(new URL(preview.url).port), '127.0.0.1');
-  t.after(() => socket.destroy());
-  const socketClosed = once(socket, 'close');
-  await once(socket, 'connect');
-  assert.equal(await preview.closed, 'timeout');
-  await socketClosed;
-  await preview.stop();
-  await assert.rejects(request(preview.url, '/'));
-  assert.ok(fs.existsSync(path.join(root, 'mini.json')));
-});
-
-test('CLI write-only exits, and invalid inputs create no project', (t) => {
-  const cwd = fixture(t);
-  const output = execFileSync(process.execPath, [cli, 'mini', 'files-only', '--write-only'], { cwd, encoding: 'utf8', timeout: 5000 });
-  assert.match(output, /Files only/);
-  assert.doesNotMatch(output, /Auto-stop in/);
-  assert.ok(fs.existsSync(path.join(cwd, 'files-only/mini.json')));
-  for (const args of [['bad', '--timeout', '0'], ['bad', '--port', '65536'], ['bad', '--typo'], ['bad', '--template'], ['bad', '--open', '--write-only']]) {
-    assert.throws(() => execFileSync(process.execPath, [cli, 'mini', ...args], { cwd, stdio: 'pipe', timeout: 5000 }));
-    assert.ok(!fs.existsSync(path.join(cwd, 'bad')));
-  }
-});
-
-for (const signal of ['SIGINT', 'SIGTERM']) {
-  test(`CLI ${signal} closes preview without deleting the mini`, { timeout: 10000 }, async (t) => {
-    const cwd = fixture(t);
-    const { root } = createMini({ name: 'signal-test', cwd });
-    const child = spawn(process.execPath, [cli, 'mini', 'preview', root, '--timeout', '30'], { stdio: ['ignore', 'pipe', 'pipe'] });
-    t.after(() => { if (child.exitCode === null && child.signalCode === null) child.kill('SIGKILL'); });
-    const exited = once(child, 'exit');
-    const url = await new Promise((resolve, reject) => {
-      let output = '';
-      child.once('error', reject);
-      child.once('exit', () => reject(new Error('Preview exited before printing its URL')));
-      child.stdout.on('data', (chunk) => {
-        output += chunk;
-        const match = output.match(/Preview: (http:\/\/127\.0\.0\.1:\d+)/);
-        if (match) resolve(match[1]);
-      });
-    });
-    assert.equal((await request(url, '/')).status, 200);
-    child.kill(signal);
-    const [code] = await exited;
-    assert.equal(code, 0);
-    await assert.rejects(request(url, '/'));
-    assert.ok(fs.existsSync(path.join(root, 'public/index.html')));
-  });
-}

package/test/model-catalog.test.mjs

@@ -1,70 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { calculateModelCost, getModelRecord, mergeModelReference } from '../src/models/index.js';
-
-test('Astra catalog separates technical window, reasoning controls, service tiers, and economics', () => {
-  const model = getModelRecord('gpt-6-astra');
-  assert.ok(model);
-  assert.equal(model.context_window, 1_050_000);
-  assert.equal(model.max_output_tokens, 128_000);
-  assert.deepEqual(model.reasoning_efforts, ['low', 'medium', 'high', 'xhigh', 'max']);
-  assert.deepEqual(model.service_tiers, ['default', 'fast', 'flex']);
-  assert.equal(model.context_policy.target_input_tokens, 120_000);
-  assert.equal(model.context_policy.compact_at_tokens, 180_000);
-  assert.equal(model.context_policy.max_normal_input_tokens, 250_000);
-  assert.equal(model.context_policy.pricing_threshold_tokens, 272_000);
-  assert.equal(model.batch.interactive, false);
-});
-
-test('cost calculation applies the long-context threshold to the full request only after crossing it', () => {
-  const atBoundary = calculateModelCost('gpt-6-astra', { input_tokens: 272_000, output_tokens: 10_000 });
-  assert.equal(atBoundary.threshold_applied, null);
-  assert.equal(atBoundary.rates_per_million.input, 10);
-  assert.equal(atBoundary.rates_per_million.output, 50);
-
-  const crossed = calculateModelCost('gpt-6-astra', { input_tokens: 272_001, output_tokens: 10_000 });
-  assert.equal(crossed.threshold_applied.input_tokens_gt, 272_000);
-  assert.equal(crossed.rates_per_million.input, 20);
-  assert.equal(crossed.rates_per_million.output, 75);
-  assert.ok(crossed.total_usd > atBoundary.total_usd);
-});
-
-test('service tier and cache pricing stay explicit rather than hidden in prompts', () => {
-  const usage = { input_tokens: 100_000, cached_input_tokens: 80_000, cache_write_tokens: 10_000, output_tokens: 20_000 };
-  const standard = calculateModelCost('gpt-6-astra', usage, { serviceTier: 'default' });
-  const fast = calculateModelCost('gpt-6-astra', usage, { serviceTier: 'fast' });
-  const flex = calculateModelCost('gpt-6-astra', usage, { serviceTier: 'flex' });
-  const batch = calculateModelCost('gpt-6-astra', usage, { serviceTier: 'batch' });
-  assert.equal(fast.total_usd, standard.total_usd * 2);
-  assert.equal(flex.total_usd, standard.total_usd * 0.5);
-  assert.equal(batch.total_usd, standard.total_usd * 0.5);
-  assert.equal(standard.rates_per_million.cached_input, 1);
-  assert.equal(standard.rates_per_million.cache_write, 12.5);
-});
-
-
-test('GPT-6 Luna reference hydrates a stale provider-verified snapshot without changing availability authority', () => {
-  const merged = mergeModelReference({
-    model_key: 'openai:gpt-6-luna',
-    provider: 'openai',
-    provider_model_id: '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 },
-  });
-  assert.equal(merged.availability, 'available');
-  assert.equal(merged.availability_source, 'provider_api');
-  assert.equal(merged.context_window, 1_050_000);
-  assert.equal(merged.context_window_source, 'sdk_reference');
-  assert.equal(merged.max_output_tokens, 128_000);
-  assert.deepEqual(merged.reasoning_efforts, ['none', 'low', 'medium', 'high', 'xhigh', 'max']);
-  assert.equal(merged.default_reasoning_effort, 'medium');
-  assert.equal(merged.capabilities.responses, true);
-  assert.equal(merged.capabilities.function_calling, true);
-});