@inneranimalmedia/agentsam-sdk 2.6.4 → 2.6.7

package/test/integration/hosted-work-host-authority.test.mjs

@@ -0,0 +1,47 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "../..");
+
+test("LocalStudioWorkPage defaults to HTTP WorkHost, not populated fixture", () => {
+  const source = readFileSync(
+    join(root, "apps/local-studio/frontend/src/components/work/LocalStudioWorkPage.tsx"),
+    "utf8",
+  );
+  assert.match(source, /createHttpWorkHost/);
+  assert.match(source, /resolveWorkHostMode/);
+  assert.match(source, /VITE_WORK_FIXTURE/);
+  // Fixture must be opt-in only
+  assert.match(source, /fixture === "populated"/);
+  assert.doesNotMatch(
+    source,
+    /createFixtureWorkHost\(populatedWorkFixture\)\s*,\s*\[\s*\]/,
+  );
+});
+
+test("agentsam-work theme does not hardcode Inter", () => {
+  const css = readFileSync(
+    join(root, "packages/agentsam-work/src/frontend/theme.css"),
+    "utf8",
+  );
+  assert.doesNotMatch(css, /font-family:\s*Inter/);
+  assert.match(css, /--font-sans/);
+});
+
+test("worker mounts /api/work/snapshot", () => {
+  const index = readFileSync(
+    join(root, "apps/local-studio/backend/worker/index.js"),
+    "utf8",
+  );
+  const service = readFileSync(
+    join(root, "apps/local-studio/backend/worker/work-service.js"),
+    "utf8",
+  );
+  assert.match(index, /handleWorkRequest/);
+  assert.match(service, /\/api\/work\/snapshot/);
+  assert.match(service, /fixtureName: 'live'/);
+  assert.doesNotMatch(service, /Companions of CPAS|AgentSamRemix|runtime-receipts\.md/);
+});

package/test/integration/inspect-path-cli.test.mjs

@@ -0,0 +1,46 @@
+import test 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 { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const CLI = path.join(ROOT, 'bin/agentsam');
+
+function run(args, cwd = ROOT) {
+  return spawnSync(process.execPath, [CLI, ...args], {
+    cwd,
+    encoding: 'utf8',
+    env: { ...process.env, NO_COLOR: '1' },
+  });
+}
+
+function jsonFrom(text) {
+  const start = text.indexOf('{');
+  assert.notEqual(start, -1, `expected JSON output, received: ${text}`);
+  return JSON.parse(text.slice(start));
+}
+
+test('agentsam inspect --help documents the positional path world-state contract', () => {
+  const result = run(['inspect', '--help']);
+  assert.equal(result.status, 0, result.stderr);
+  assert.match(result.stdout, /agentsam inspect \[path\]/);
+  assert.match(result.stdout, /deterministic repository world state/i);
+  assert.match(result.stdout, /No model, embeddings, network, provider spend/i);
+});
+
+test('agentsam inspect accepts a repository path as the first positional argument', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-inspect-path-'));
+  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'inspect-fixture', version: '1.0.0' }));
+  fs.mkdirSync(path.join(root, 'src'));
+  fs.writeFileSync(path.join(root, 'src/index.js'), 'export function fixture() { return 42; }\n');
+
+  const result = run(['inspect', root, '--json', '--index']);
+  assert.equal(result.status, 0, result.stderr || result.stdout);
+  const output = jsonFrom(result.stdout);
+  assert.ok(output.snapshot_id);
+  assert.ok(output.merkle_root || output.tree?.merkle_root);
+  assert.match(JSON.stringify(output), /inspect-fixture|src\/index\.js/);
+});

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

@@ -0,0 +1,59 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { discoverOpenAIModels, discoverGeminiModels, discoverCursorModels } from '../../src/models/discovery.js';
+import { sanitizeInventoryForClient } from '../../src/models/inventory-core.js';
+
+function json(body) {
+  return new Response(JSON.stringify(body), { status: 200, headers: { 'content-type': 'application/json' } });
+}
+
+function sanitized(models) {
+  return sanitizeInventoryForClient({
+    providers: [],
+    discovery: {},
+    availableModels: models,
+  }).availableModels;
+}
+
+test('known OpenAI Responses reference is selectable while unknown live models stay visible', async () => {
+  const result = await discoverOpenAIModels('user-key', async () => json({
+    data: [{ id: 'gpt-5.6-sol' }, { id: 'brand-new-unclassified-model' }],
+  }));
+  const rows = sanitized(result.models);
+  assert.equal(rows.length, 2);
+  assert.equal(rows.find((row) => row.model_id === 'gpt-5.6-sol')?.chat_eligible, true);
+  const unknown = rows.find((row) => row.model_id === 'brand-new-unclassified-model');
+  assert.equal(unknown?.chat_eligible, false);
+  assert.equal(unknown?.eligibility_reason, 'capability_unknown');
+});
+
+test('Cursor inventory is preserved but reports adapter unavailability', async () => {
+  const result = await discoverCursorModels('cursor-key', async () => json({
+    items: [{ id: 'gpt-5.6-sol', displayName: 'GPT-5.6 Sol', parameters: [] }],
+  }));
+  const [row] = sanitized(result.models);
+  assert.equal(row.provider, 'cursor');
+  assert.equal(row.model_id, 'gpt-5.6-sol');
+  assert.equal(row.chat_eligible, false);
+  assert.equal(row.eligibility_reason, 'provider_adapter_unavailable');
+});
+
+test('Gemini provider description keeps TTS visible outside the chat picker', async () => {
+  const result = await discoverGeminiModels('gemini-key', async () => json({
+    models: [{
+      name: 'models/gemini-tts-fixture',
+      baseModelId: 'gemini-tts-fixture',
+      displayName: 'Voice fixture',
+      description: 'Preview Text-to-Speech model',
+      supportedGenerationMethods: ['generateContent'],
+      inputTokenLimit: 8192,
+      outputTokenLimit: 8192,
+    }],
+  }));
+  const [row] = sanitized(result.models);
+  assert.equal(row.model_id, 'gemini-tts-fixture');
+  assert.equal(row.chat_eligible, false);
+  assert.equal(row.eligibility_reason, 'specialized_output_model');
+  assert.equal(row.eligibility_source, 'provider_api');
+});

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-provider-bridge.test.mjs

@@ -0,0 +1,65 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { executeLocalProviderBridge } from '../../packages/agentsam-desktop-shell/scripts/local-provider-bridge.mjs';
+
+const CANARY = 'sk-test-CANARY-123456';
+
+function json(body, status = 200) {
+  return new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json' } });
+}
+
+function openAiFetch(url, init = {}) {
+  assert.equal(init.headers?.authorization, `Bearer ${CANARY}`);
+  if (String(url).endsWith('/v1/models')) {
+    return Promise.resolve(json({ data: [{ id: 'gpt-5.6-sol', object: 'model' }] }));
+  }
+  if (String(url).endsWith('/v1/responses')) {
+    return Promise.resolve(json({
+      id: 'resp_local_fixture',
+      status: 'completed',
+      output_text: 'offline bridge works',
+      output: [],
+      usage: { input_tokens: 3, output_tokens: 4 },
+    }));
+  }
+  throw new Error(`unexpected_url:${url}`);
+}
+
+test('device OpenAI credential discovers live inventory without leaking the key', async () => {
+  const result = await executeLocalProviderBridge({
+    operation: 'inventory',
+    credentials: { openai: CANARY },
+  }, { fetchImpl: openAiFetch });
+  assert.equal(result.ok, true);
+  assert.equal(result.credential_plane, 'device_keychain');
+  assert.equal(result.providers.find((row) => row.id === 'openai')?.configured, true);
+  assert.equal(result.availableModels.some((row) => row.provider === 'openai' && row.model_id === 'gpt-5.6-sol'), true);
+  assert.equal(JSON.stringify(result).includes(CANARY), false);
+});
+
+test('device OpenAI credential chats through canonical Responses adapter without leaking the key', async () => {
+  const result = await executeLocalProviderBridge({
+    operation: 'chat',
+    provider: 'openai',
+    model_id: 'gpt-5.6-sol',
+    messages: [{ role: 'user', content: 'hello' }],
+    credentials: { openai: CANARY },
+  }, { fetchImpl: openAiFetch });
+  assert.deepEqual(result, {
+    ok: true,
+    provider: 'openai',
+    model_id: 'gpt-5.6-sol',
+    text: 'offline bridge works',
+  });
+  assert.equal(JSON.stringify(result).includes(CANARY), false);
+});
+
+test('provider rejection is sanitized and never echoes credential material', async () => {
+  const result = await executeLocalProviderBridge({
+    operation: 'inventory',
+    credentials: { openai: CANARY },
+  }, {
+    fetchImpl: async () => json({ error: { message: `bad ${CANARY}` } }, 401),
+  });
+  assert.equal(JSON.stringify(result).includes(CANARY), false);
+});

package/test/integration/local-studio-settings-production.test.mjs

@@ -0,0 +1,40 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+function read(path) {
+  return readFileSync(new URL(`../../${path}`, import.meta.url), 'utf8');
+}
+
+const settingsPage = read('apps/local-studio/frontend/src/components/settings/LocalStudioSettingsPage.tsx');
+const settingsHost = read('apps/local-studio/frontend/src/components/settings/localStudioSettingsHost.ts');
+const shell = read('apps/local-studio/frontend/agentsam/AgentSamShell.tsx');
+const keysPage = read('apps/local-studio/frontend/src/components/settings/LiveKeysSettingsPage.tsx');
+const apiKeys = read('apps/local-studio/frontend/src/components/settings/ApiKeysTable.tsx');
+const settingsFrontend = read('packages/agentsam-settings/src/frontend/index.tsx');
+
+test('production Settings never mounts fixture data', () => {
+  assert.doesNotMatch(settingsPage, /createFixtureSettingsHost|getSettingsFixture|SettingsFixtureName/);
+  assert.doesNotMatch(settingsHost, /demo-app|Demo Org|health:\s*["']healthy["']/i);
+  assert.match(settingsHost, /repositoryLabel:\s*["']Not connected["']/);
+  assert.match(settingsHost, /browser:\s*["']Not checked["']/);
+  assert.match(settingsHost, /health:\s*["']unknown["']/);
+  assert.doesNotMatch(settingsFrontend, /demo-app|Demo Org/);
+});
+
+test('Settings route suppresses the outer application sidenav', () => {
+  assert.match(shell, /const isSettings = pathname === ['"]\/settings['"] \|\| pathname\.startsWith\(['"]\/settings\/['"]\)/);
+  assert.match(shell, /!isSettings \? <Nav\.Sidenav \/> : null/);
+});
+
+test('Keys page has a visible explicit AgentSam key trigger', () => {
+  assert.match(keysPage, /variant="secondary"/);
+  assert.match(keysPage, /Create AgentSam key/);
+});
+
+test('account provider rows show live discovery trust status', () => {
+  assert.match(apiKeys, /accountInventoryRequest/);
+  assert.match(apiKeys, /Connected · \$\{count\} model/);
+  assert.match(apiKeys, /rejected this key/);
+  assert.match(apiKeys, /Not selected/);
+});

package/test/integration/lockfile-sync.test.mjs

@@ -0,0 +1,26 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+
+test('every workspace and link path in package-lock.json exists on disk', () => {
+  const lock = JSON.parse(fs.readFileSync(path.join(root, 'package-lock.json'), 'utf8'));
+  const paths = new Set();
+  for (const [key, value] of Object.entries(lock.packages)) {
+    if (key && !key.includes('node_modules/')) paths.add(key);
+    if (value.link && value.resolved) paths.add(value.resolved);
+  }
+  const missing = [...paths].filter((p) => !fs.existsSync(path.join(root, p)));
+  assert.deepEqual(missing, []);
+});
+
+test('package.json bin map matches package-lock packages[""].bin', () => {
+  const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+  const lock = JSON.parse(fs.readFileSync(path.join(root, 'package-lock.json'), 'utf8'));
+  const pkgBin = pkg.bin || {};
+  const lockBin = (lock.packages && lock.packages[''] && lock.packages[''].bin) || {};
+  assert.deepEqual(lockBin, pkgBin);
+});

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

@@ -6,11 +6,20 @@ import { spawnSync } from 'node:child_process';
 import test from 'node:test';
 
 const repoRoot = path.resolve(new URL('../..', import.meta.url).pathname);
+/** Repo bin first — clean CI has no global `agentsam`; loader requires it on PATH. */
+function testEnv(home, extra = {}) {
+  return {
+    ...process.env,
+    ...extra,
+    HOME: home,
+    PATH: `${path.join(repoRoot, 'bin')}${path.delimiter}${process.env.PATH || ''}`,
+  };
+}
 
 test('agentsam env init creates provider profile and reusable source loader', { skip: process.platform === 'win32' }, t => {
   const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-env-cli-'));
   t.after(() => fs.rmSync(home, { recursive: true, force: true }));
-  const env = { ...process.env, HOME: home };
+  const env = testEnv(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(?:\s|$)/);
@@ -40,11 +49,12 @@ test('Cloudflare env init backfills exactly one Wrangler account without printin
 test('generated loader exports the selected provider profile into the caller shell', { skip: process.platform === 'win32' }, t => {
   const home = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-env-source-'));
   t.after(() => fs.rmSync(home, { recursive: true, force: true }));
-  const env = { ...process.env, HOME: home };
+  const env = testEnv(home);
   let result = spawnSync(process.execPath, ['src/cli.js', 'env', 'init', 'openai'], { cwd: repoRoot, env, encoding: 'utf8' });
   assert.equal(result.status, 0, result.stderr);
   fs.writeFileSync(path.join(home, '.agentsam', 'env.d', 'openai.env'), 'export OPENAI_API_KEY="sentinel-provider-key"\
 ', { mode: 0o600 });
-  result = spawnSync('bash', ['-lc', 'source "$HOME/.agentsam/load-agent-env.sh" openai && test "$OPENAI_API_KEY" = "sentinel-provider-key"'], { env, encoding: 'utf8' });
+  // Use bash -c (not -lc): a login shell resets PATH and drops the repo bin/agentsam needed on clean CI.
+  result = spawnSync('bash', ['-c', 'source "$HOME/.agentsam/load-agent-env.sh" openai && test "$OPENAI_API_KEY" = "sentinel-provider-key"'], { env, encoding: 'utf8' });
   assert.equal(result.status, 0, result.stderr);
 });

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

@@ -14,12 +14,28 @@ 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', 'DB', 'EXECOS', 'HYPERDRIVE', 'IAM_CLIENT_ID',
+    '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',
   ]);
 });

package/test/integration/theme-package-registry.test.mjs

@@ -0,0 +1,31 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  listThemePackages,
+  resolveThemePackage,
+} from "../../packages/theme-scenes/src/registry.js";
+
+test("theme registry resolves donor aliases to neutral canonical ids", () => {
+  const companions = resolveThemePackage("companions-of-caddo");
+  assert.equal(companions?.id, "violet");
+  assert.equal(companions?.packageName, "@inneranimalmedia/theme-violet");
+  assert.equal(companions?.packageNameLegacy, "@inneranimalmedia/theme-companions-site");
+
+  const fuel = resolveThemePackage("fuelnfreetime");
+  assert.equal(fuel?.id, "ember");
+  assert.equal(fuel?.packageName, "@inneranimalmedia/theme-ember");
+
+  const cypress = resolveThemePackage("cypress");
+  assert.equal(cypress?.path, "packages/theme-church-site");
+
+  const scenes = resolveThemePackage("theme-scenes");
+  assert.equal(scenes?.kind, "scenes");
+});
+
+test("site themes remain distinct packages (not flattened)", () => {
+  const sites = listThemePackages("site-theme");
+  assert.ok(sites.length >= 7);
+  assert.ok(sites.every((entry) => entry.path.startsWith("packages/theme-")));
+  assert.ok(sites.every((entry) => entry.packageName.startsWith("@inneranimalmedia/theme-")));
+  assert.ok(sites.every((entry) => !entry.packageName.includes("-site") || entry.id === "docs"));
+});

package/test/knowledge.test.mjs

@@ -6,7 +6,7 @@ import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { defaultConfig, initRepository, readConfig, scopeKey, embeddingProfileId, openSqliteStore, runIndex, planIndex, retrieve, createGeminiEmbedder, KnowledgeClient } from '../src/knowledge/index.js';
-import { parseSource } from '../src/knowledge/source.js';
+import { inventory, parseSource } from '../src/knowledge/source.js';
 
 const cli = fileURLToPath(new URL('../src/cli.js', import.meta.url));
 const write = (root, name, content) => { fs.mkdirSync(path.dirname(path.join(root, name)), { recursive: true }); fs.writeFileSync(path.join(root, name), content); };
@@ -34,6 +34,40 @@ test('AST parser observes real syntax, spans and unresolved edges; text is label
   assert.throws(() => parseSource('bad.ts', 'export function {'), /bad.ts/);
 });
 
+test('Rust sources survive knowledge inventory and persist in the active SQLite generation', async t => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agentsam-knowledge-rust-'));
+  execFileSync('git', ['init', '-q'], { cwd: root });
+  write(root, 'core/src/lib.rs', 'pub fn core_value() -> u32 { 7 }\n');
+  write(root, 'worker/src/lib.rs', 'pub fn worker_value() -> u32 { 8 }\n');
+  write(root, 'docs/MACHINE-PIPELINE.md', '# Machine pipeline\n');
+  write(root, 'target/generated.rs', 'pub fn generated() {}\n');
+
+  const config = defaultConfig({ include: ['core', 'worker', 'docs'], exclude: ['target'] });
+  const store = await openSqliteStore(path.join(root, '.agentsam/knowledge/index.sqlite'));
+  t.after(async () => {
+    await store.close();
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  const files = inventory(root, config.scope);
+  assert.ok(files.includes('core/src/lib.rs'));
+  assert.ok(files.includes('worker/src/lib.rs'));
+  assert.ok(files.includes('docs/MACHINE-PIPELINE.md'));
+  assert.equal(files.includes('target/generated.rs'), false);
+
+  const result = await runIndex({ root, config, store, embed: false });
+  assert.equal(result.published, true);
+  assert.ok(result.changes.added.includes('core/src/lib.rs'));
+  assert.ok(result.changes.added.includes('worker/src/lib.rs'));
+
+  const generation = await store.getGeneration(scopeKey(config), result.generation_id);
+  const persisted = generation.files.map(file => file.path);
+  assert.ok(persisted.includes('core/src/lib.rs'));
+  assert.ok(persisted.includes('worker/src/lib.rs'));
+  assert.ok(persisted.includes('docs/MACHINE-PIPELINE.md'));
+  assert.equal(generation.files.find(file => file.path === 'core/src/lib.rs')?.parser, 'text:1');
+});
+
 test('incremental indexing reuses unchanged functions, moves and deletions; old knowledge remains retrievable', async t => {
   const f = await fixture(t), args = { ...f, embed: true };
   const plan = await planIndex(args);

package/test/loopback-oauth.test.mjs

@@ -0,0 +1,53 @@
+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/ollama.test.mjs

@@ -24,6 +24,28 @@ test('Ollama defaults are local-only and match the SDK local-dev contract', () =
   assert.deepEqual(resolveOllamaConfig({}, {}), OLLAMA_DEFAULTS);
 });
 
+test('Ollama endpoints normalize host-only values and honor AgentSam precedence', () => {
+  assert.equal(resolveOllamaConfig({}, { OLLAMA_HOST: '0.0.0.0:11434' }).baseUrl, 'http://127.0.0.1:11434');
+  assert.equal(resolveOllamaConfig({}, { OLLAMA_HOST: '127.0.0.1:11434' }).baseUrl, 'http://127.0.0.1:11434');
+  assert.equal(resolveOllamaConfig({}, { OLLAMA_HOST: 'localhost:11434' }).baseUrl, 'http://localhost:11434');
+  assert.equal(resolveOllamaConfig({}, { OLLAMA_HOST: 'http://localhost:11434' }).baseUrl, 'http://localhost:11434');
+
+  assert.equal(resolveOllamaConfig({}, {
+    AGENTSAM_OLLAMA_ENDPOINT: '127.0.0.1:2244',
+    OLLAMA_BASE_URL: 'localhost:3344',
+    OLLAMA_HOST: '0.0.0.0:4444',
+  }).baseUrl, 'http://127.0.0.1:2244');
+
+  assert.equal(resolveOllamaConfig({}, {
+    OLLAMA_BASE_URL: 'localhost:3344',
+    OLLAMA_HOST: '0.0.0.0:4444',
+  }).baseUrl, 'http://localhost:3344');
+
+  assert.equal(resolveOllamaConfig({}, {
+    OLLAMA_HOST: '0.0.0.0:4444',
+  }).baseUrl, 'http://127.0.0.1:4444');
+});
+
 test('Ollama setup args require explicit install/pull/start opt-ins', () => {
   assert.deepEqual(parseOllamaArgs(['setup']), {
     command: 'setup',