@inneranimalmedia/agentsam-sdk 2.6.7 → 2.6.9

package/test/terminal-machine-identity.test.mjs

@@ -1,88 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-
-import { runTerminal } from '../src/commands/terminal.js';
-import { normalizeTerminalArch, normalizeTerminalPlatform } from '../src/lib/terminal/machine-identity.js';
-
-test('identity command prints this host vocabulary without calling the network', async () => {
-  const lines = [];
-  const result = await runTerminal(['identity'], {
-    write: (line) => lines.push(line),
-    collectIdentity: async () => ({
-      hostname: 'dev-machine',
-      platform: 'macos',
-      arch: 'arm64',
-      model: 'Mac16,2',
-    }),
-    postJson: async () => {
-      throw new Error('identity must not post');
-    },
-  });
-  assert.equal(result.ok, true);
-  assert.equal(result.arch, 'arm64');
-  assert.match(lines.join('\n'), /arch:\s+arm64/);
-  assert.match(lines.join('\n'), /hw_model:\s+Mac16,2/);
-});
-
-test('enroll without a target does not mint a token', async () => {
-  let posted = false;
-  const result = await runTerminal(['enroll', '--json'], {
-    write: () => {},
-    collectIdentity: async () => ({ hostname: 'box', platform: 'linux', arch: 'x86_64', model: 'container' }),
-    postJson: async () => { posted = true; return {}; },
-  });
-  assert.equal(posted, false);
-  assert.equal(result.enrolled, false);
-  assert.equal(result.arch, 'x86_64');
-});
-
-test('enroll posts canonical identity for the instance the caller named', async () => {
-  let body = null;
-  const result = await runTerminal(['enroll', '--instance', 'tinst_sams_imac', '--json'], {
-    write: () => {},
-    collectIdentity: async () => ({
-      hostname: 'dev-machine',
-      platform: 'macos',
-      arch: 'arm64',
-      model: 'Mac16,2',
-    }),
-    postJson: async (_path, posted) => {
-      body = posted;
-      return { instance_id: 'tinst_sams_imac', connection_id: 'conn_mac_local', enrollment_token_id: 'tenr_test', enrollment_token: 'tok_test' };
-    },
-  });
-  assert.equal(result.enrolled, true);
-  assert.equal(body.instance_id, 'tinst_sams_imac');
-  assert.equal(body.platform, 'macos');
-  assert.equal(body.arch, 'arm64');
-  assert.equal(body.hw_model, 'Mac16,2');
-  assert.equal(body.kind, 'local_device');
-});
-
-test('enroll --pair consumes the token via ExecOS enroll (writes AGENTSAM_BRIDGE_KEY)', async () => {
-  let pairedToken = null;
-  const result = await runTerminal(['enroll', '--instance', 'tinst_sams_imac', '--pair', '--json'], {
-    write: () => {},
-    collectIdentity: async () => ({ hostname: 'box', platform: 'macos', arch: 'arm64', model: 'Mac16,2' }),
-    postJson: async () => ({
-      instance_id: 'tinst_sams_imac',
-      connection_id: 'conn_mac_local',
-      enrollment_token: 'tok_pair',
-      endpoint_url: 'https://localpty.inneranimalmedia.com',
-    }),
-    pairImpl: async (token) => {
-      pairedToken = token;
-      return { ok: true };
-    },
-  });
-  assert.equal(pairedToken, 'tok_pair');
-  assert.equal(result.paired, true);
-  assert.equal(result.auth_mode, 'connection_token');
-});
-
-test('normalizer matches the worker vocabulary', () => {
-  assert.equal(normalizeTerminalPlatform('darwin'), 'macos');
-  assert.equal(normalizeTerminalPlatform('win32'), 'windows');
-  assert.equal(normalizeTerminalArch('x64'), 'x86_64');
-  assert.equal(normalizeTerminalArch('aarch64'), 'arm64');
-});

package/test/theme-portability.test.mjs

@@ -1,14 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-
-import { CLOUD, LOCAL, SANDBOX, getLaneThemeByName } from '../src/ui/theme.js';
-
-test('SDK terminal lane metadata is provider and operator neutral', () => {
-  const serialized = JSON.stringify([LOCAL.meta, CLOUD.meta, SANDBOX.meta]);
-  assert.doesNotMatch(serialized, /sam(smac)?|inneranimalmedia|gcp|cloudflare|MY_CONTAINER/i);
-  assert.equal(LOCAL.meta.tunnelHint, 'current machine · real shell');
-  assert.equal(CLOUD.meta.label, 'Remote');
-  assert.equal(SANDBOX.meta.tunnelHint, 'isolated disposable runtime');
-  assert.equal(getLaneThemeByName('remote'), CLOUD);
-  assert.equal(getLaneThemeByName('cloud'), CLOUD);
-});

package/test/tools-search.test.mjs

@@ -1,73 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { getToolCatalog } from '../src/lib/tools.js';
-import { hydrateToolSchemas, searchToolCards } from '../src/tools/index.js';
-import { DEFAULT_RESULT_POLICY } from '../src/context/index.js';
-
-test('every built-in SDK tool inherits a bounded result policy', () => {
-  for (const lane of ['fullstack', 'cms', 'data', 'crm', 'creative']) {
-    for (const tool of getToolCatalog(lane)) assert.deepEqual(tool.result_policy, DEFAULT_RESULT_POLICY);
-  }
-});
-
-test('tools.search returns compact cards rather than full schemas', () => {
-  const catalog = Array.from({ length: 20 }, (_, index) => ({
-    name: index === 13 ? 'code.retrieve' : `tool.${index}`,
-    description: index === 13 ? 'Find symbols, callers, and semantic code matches.' : `Capability ${index}`,
-    category: index === 13 ? 'code' : 'misc',
-    risk: 'read',
-    input_schema: { type: 'object', required: ['query'], properties: { query: { type: 'string' }, giant: { description: 'x'.repeat(5000) } } },
-  }));
-  const result = searchToolCards(catalog, 'code symbols');
-  assert.ok(result.cards.length <= 8);
-  assert.equal(result.cards[0].tool, 'code.retrieve');
-  assert.deepEqual(result.cards[0].required, ['query']);
-  assert.equal('input_schema' in result.cards[0], false);
-  assert.ok(result.receipt.chars < 24_000);
-});
-
-test('selected schemas hydrate without loading the full tool catalog', () => {
-  const catalog = Array.from({ length: 50 }, (_, index) => ({
-    name: `tool.${index}`,
-    description: `Capability ${index}`,
-    input_schema: { type: 'object', properties: { value: { type: 'string' }, padding: { description: 'x'.repeat(300) } } },
-  }));
-  const result = hydrateToolSchemas(catalog, ['tool.4', 'tool.22'], { maxTools: 4, maxChars: 5_000 });
-  assert.deepEqual(result.tools.map((tool) => tool.name), ['tool.4', 'tool.22']);
-  assert.equal(result.receipt.catalog_items, 50);
-  assert.equal(result.receipt.hydrated_tools, 2);
-  assert.ok(result.receipt.schema_chars < 5_000);
-});
-
-
-test('canonical AgentSam tool definitions participate in legacy discovery and hydration', () => {
-  const canonical = {
-    toolKey: 'completeful.order.create',
-    displayName: 'Create Completeful order',
-    description: 'Create a fulfillment order through Completeful.',
-    provider: 'completeful',
-    capabilityKey: 'completeful.order.create',
-    inputSchema: {
-      type: 'object',
-      required: ['shop_id', 'body'],
-      properties: {
-        shop_id: { type: 'string' },
-        body: { type: 'object' },
-      },
-    },
-    outputSchema: { type: 'object' },
-    riskLevel: 'high',
-    sideEffectLevel: 'billable_external_write',
-    idempotencyMode: 'required',
-  };
-
-  const searched = searchToolCards([canonical], 'completeful order');
-  assert.equal(searched.cards[0].tool, 'completeful.order.create');
-  assert.equal(searched.cards[0].category, 'completeful');
-  assert.equal(searched.cards[0].risk, 'high');
-  assert.deepEqual(searched.cards[0].required, ['shop_id', 'body']);
-
-  const hydrated = hydrateToolSchemas([canonical], ['completeful.order.create']);
-  assert.equal(hydrated.tools[0].toolKey, 'completeful.order.create');
-  assert.equal(hydrated.tools[0].inputSchema.type, 'object');
-});

package/test/unit/website-assets-bindings.test.mjs

@@ -1,60 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import {
-  resolveWebsiteAssets,
-  resolveWorkerStaticAssets,
-  resolveDb,
-  resolveSiteCacheKv,
-  suggestWebsiteAssetsBindingScaffold,
-  websitePublicKey,
-  websitePartialKey,
-  WEBSITE_ASSETS_ROLE,
-} from '../../apps/local-studio/backend/worker/bindings.js';
-
-function r2Stub() {
-  return {
-    get: async () => null,
-    put: async () => {},
-    list: async () => ({ objects: [] }),
-    head: async () => null,
-    createMultipartUpload: async () => ({}),
-  };
-}
-
-function kvStub() {
-  return {
-    get: async () => null,
-    put: async () => {},
-    getWithMetadata: async () => ({ value: null, metadata: null }),
-  };
-}
-
-test('resolveWebsiteAssets prefers canonical name then aliases', () => {
-  const bucket = r2Stub();
-  const a = resolveWebsiteAssets({ SITE_ASSETS: bucket });
-  assert.equal(a.name, 'SITE_ASSETS');
-  assert.equal(a.role, WEBSITE_ASSETS_ROLE);
-
-  const b = resolveWebsiteAssets({ WEBSITE_ASSETS: bucket, SITE_ASSETS: r2Stub() });
-  assert.equal(b.name, 'WEBSITE_ASSETS');
-});
-
-test('resolveWorkerStaticAssets only accepts fetch binding', () => {
-  assert.equal(resolveWorkerStaticAssets({ ASSETS: r2Stub() }), null);
-  const assets = { fetch: async () => new Response('ok') };
-  assert.equal(resolveWorkerStaticAssets({ ASSETS: assets }), assets);
-});
-
-test('resolveDb and site cache aliases', () => {
-  const db = { prepare: () => ({}) };
-  assert.equal(resolveDb({ DATABASE: db }).name, 'DATABASE');
-  assert.equal(resolveSiteCacheKv({ CMS_CACHE: kvStub() }).name, 'CMS_CACHE');
-});
-
-test('key helpers and scaffold', () => {
-  assert.equal(websitePublicKey('agentsam-sdk', 'home/index.html'), 'sites/agentsam-sdk/public/home/index.html');
-  assert.equal(websitePartialKey('agentsam-sdk', 'header'), 'sites/agentsam-sdk/partials/header.html');
-  const tip = suggestWebsiteAssetsBindingScaffold({ detectedBindingName: 'CONTENT' });
-  assert.equal(tip.binding, 'CONTENT');
-  assert.equal(tip.wrangler_snippet.r2_buckets[0].binding, 'CONTENT');
-});

package/test/whoami-resume.test.mjs

@@ -1,157 +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 { saveAccountSession } from '../src/lib/account-session.js';
-import { createLocalSession } from '../src/lib/local-sessions.js';
-import { collectWhoami } from '../src/commands/whoami.js';
-import { runResume } from '../src/commands/resume.js';
-
-function tempHome(t) {
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-ux-home-'));
-  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
-  return home;
-}
-
-test('whoami validates persisted IAM browser identity while never returning account or provider secrets', async t => {
-  const home = tempHome(t);
-  saveAccountSession({ access_token: 'browser_session_do_not_print', user_id: 'au_local' }, { home });
-  const envDir = path.join(home, '.agentsam', 'env.d');
-  fs.mkdirSync(envDir, { recursive: true });
-  const openaiFile = path.join(envDir, 'openai.env');
-  fs.writeFileSync(openaiFile, 'OPENAI_API_KEY=sk-never-print-this\n', { mode: 0o600 });
-  if (process.platform !== 'win32') fs.chmodSync(openaiFile, 0o600);
-
-  const status = await collectWhoami({
-    env: {}, home,
-    contextLoader: async token => {
-      assert.equal(token, 'browser_session_do_not_print');
-      return {
-        user_id: 'au_server', account_id: 'acct_server', email: 'dev@example.test',
-        cloudflare: { ok: true }, byok: { openai: { configured: true, masked: 'secret' } },
-        terminal: {
-          available: true,
-          instances: [{
-            id: 'inst_1',
-            name: 'Mac',
-            provider: 'local',
-            last_seen_at: 1789716970,
-            metadata_json: 'secret',
-          }],
-          connections: [{
-            id: 'conn_1',
-            instance_id: 'inst_1',
-            name: 'Tunnel',
-            is_active: true,
-            is_default: true,
-            transport_provider: 'cloudflare_tunnel',
-            endpoint_url: 'wss://localpty.example.test/terminal',
-            last_seen_at: 1789716970,
-          }],
-        },
-      };
-    },
-  });
-  assert.equal(status.authenticated, true);
-  assert.equal(status.identity.account_id, 'acct_server');
-  assert.equal(status.active_auth.source, 'agentsam_browser_oauth');
-  assert.equal(status.active_auth.kind, 'agentsam_browser_oauth');
-  assert.equal(status.provider_credentials.find(row => row.provider === 'openai').configured, true);
-  assert.equal(status.provider_credentials.find(row => row.provider === 'openai').owner_account_id, 'acct_server');
-  assert.equal(status.provider_credentials.find(row => row.provider === 'openai').account_id, 'acct_server');
-  assert.equal(status.identity.email, 'dev@example.test');
-  assert.equal(status.terminal.connections[0].id, 'conn_1');
-  assert.equal(status.terminal.connections[0].connection_id, 'conn_1');
-  assert.equal(status.terminal.connections[0].public_url, 'wss://localpty.example.test/terminal');
-  assert.match(status.terminal.connections[0].last_seen_at_iso || '', /^2026-/);
-  const serialized = JSON.stringify(status);
-  assert.doesNotMatch(serialized, /browser_session_do_not_print|sk-never-print-this|masked|metadata_json/);
-});
-
-test('whoami sends the exact authority returned by the resolver to the default context loader', async t => {
-  const home = tempHome(t);
-  let request = null;
-  const status = await collectWhoami({
-    env: { IAM_OAUTH_ISSUER: 'https://iam.example.test' },
-    home,
-    authorityLoader: async () => ({
-      value: 'resolved_authority_token',
-      kind: 'browser_oauth',
-      source: 'test_authority',
-    }),
-    fetchImpl: async (url, init) => {
-      request = { url, init };
-      return {
-        ok: true,
-        status: 200,
-        json: async () => ({ user_id: 'au_server', account_id: 'acct_server' }),
-      };
-    },
-  });
-  assert.equal(request.url, 'https://iam.example.test/api/sdk/context');
-  assert.equal(request.init.headers.Authorization, 'Bearer resolved_authority_token');
-  assert.equal(status.authenticated, true);
-  assert.equal(status.identity.account_id, 'acct_server');
-});
-
-test('whoami uses a valid browser session when a stale environment API key is invalid', async t => {
-  const home = tempHome(t);
-  saveAccountSession({ access_token: 'browser_session_do_not_print', user_id: 'au_local' }, { home });
-  const status = await collectWhoami({
-    env: { AGENTSAM_API_KEY: 'stale-invalid-key' },
-    home,
-    contextLoader: async token => {
-      assert.equal(token, 'browser_session_do_not_print');
-      return { user_id: 'au_server', account_id: 'acct_server' };
-    },
-  });
-  assert.equal(status.authenticated, true);
-  assert.equal(status.active_auth.kind, 'agentsam_browser_oauth');
-  assert.equal(status.api_key.valid, false);
-  assert.equal(status.api_key.error, 'invalid_api_key_prefix');
-});
-
-test('whoami refreshes an expired browser session before validating IAM context', async t => {
-  const home = tempHome(t);
-  const nowMs = Date.now();
-  saveAccountSession({
-    access_token: 'expired_browser_token',
-    refresh_token: 'refresh_token',
-    expires_in: 1,
-  }, { home, nowMs: nowMs - 120_000 });
-  let refreshed = 0;
-  const status = await collectWhoami({
-    env: {},
-    home,
-    nowMs,
-    refreshImpl: async ({ session }) => {
-      refreshed += 1;
-      return { ...session, access_token: 'fresh_browser_token', expires_at: new Date(nowMs + 3_600_000).toISOString() };
-    },
-    contextLoader: async token => {
-      assert.equal(token, 'fresh_browser_token');
-      return { user_id: 'au_server', account_id: 'acct_server' };
-    },
-  });
-  assert.equal(refreshed, 1);
-  assert.equal(status.authenticated, true);
-  assert.equal(status.active_auth.kind, 'agentsam_browser_oauth');
-});
-
-test('resume restores saved cwd and session through the canonical shell runtime', async t => {
-  const home = tempHome(t);
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-resume-project-'));
-  t.after(() => fs.rmSync(cwd, { recursive: true, force: true }));
-  const session = createLocalSession({ cwd, title: 'Run wrangler whoami', model_key: 'openai:gpt-6-astra' }, { home });
-  let called = null;
-  const restored = await runResume([session.id], {
-    home, cwd,
-    write() {},
-    runShellImpl: async (argv, options) => { called = { argv, options }; },
-  });
-  assert.equal(restored.id, session.id);
-  assert.deepEqual(called.argv, []);
-  assert.equal(called.options.cwd, cwd);
-  assert.equal(called.options.session.id, session.id);
-});