@inneranimalmedia/agentsam-sdk 2.6.3 → 2.6.5

package/src/cli/dispatch.js

@@ -0,0 +1,48 @@
+/**
+ * Catalog-backed dispatch bootstrap.
+ * Full cli.js cutover is incremental — this module is the target authority for handlers.
+ */
+
+import { getCliCommand, printAssistTip, suggestCliCommands } from './command-catalog.js';
+
+/** @type {Record<string, () => Promise<(argv: string[]) => unknown>>} */
+const HANDLERS = {
+  codebaseindex: async () => (await import('../commands/codebaseindex.js')).runCodebaseindex,
+  ingest: async () => (await import('../commands/codebaseindex.js')).runCodebaseindex,
+  'codebase-index': async () => (await import('../commands/codebaseindex.js')).runCodebaseindex,
+  skill: async () => (await import('../commands/skill.js')).runSkill,
+  skills: async () => (await import('../commands/skills.js')).runSkills,
+};
+
+/**
+ * @param {string} command
+ * @param {string[]} rest
+ * @param {{ reportError?: (e: Error) => void }} [ctx]
+ */
+export async function dispatchCatalogCommand(command, rest = [], ctx = {}) {
+  const entry = getCliCommand(command);
+  if (!entry) {
+    const suggestions = suggestCliCommands(command);
+    const err = new Error(`Unknown command: ${command}`);
+    err.code = 'AGENTSAM_UNKNOWN_COMMAND';
+    err.suggestions = suggestions;
+    throw err;
+  }
+
+  printAssistTip(entry, { json: rest.includes('--json') });
+
+  const loader = HANDLERS[entry.id] || HANDLERS[command];
+  if (!loader) {
+    const err = new Error(`Catalog entry "${entry.id}" is not yet wired to a lazy handler (legacy cli.js path).`);
+    err.code = 'AGENTSAM_HANDLER_NOT_MIGRATED';
+    err.entry = entry;
+    throw err;
+  }
+
+  const run = await loader();
+  return run(rest);
+}
+
+export function listDispatchableCommands() {
+  return Object.keys(HANDLERS);
+}

package/src/cli.js

@@ -34,22 +34,42 @@ import { runSecurity } from './commands/security.js';
 import { runRecon } from './commands/recon.js';
 import { runCad } from './commands/cad.js';
 import { runSkills } from './commands/skills.js';
+import { runSkill } from './commands/skill.js';
 import { runEval } from './commands/eval.js';
 import { runMcp } from './commands/mcp.js';
 import { runCloudflare } from './commands/cloudflare.js';
 import { runGo } from './commands/go.js';
+import { runRust } from './commands/rust.js';
 import { runWhoami } from './commands/whoami.js';
+import { runTerminal } from './commands/terminal.js';
+import { runApiKey } from './commands/api-key.js';
 import { runResume } from './commands/resume.js';
 import { runLogin, runLogout } from './commands/account-auth.js';
 import { runPlugins } from './commands/plugins.js';
+import { runCredentials } from './commands/credentials.js';
+import { runCheatSheet } from './commands/cheat-sheet.js';
+import { runCompute } from './commands/compute.js';
+import { runGoogleCloud } from './commands/google-cloud.js';
+import { runBilling } from './commands/billing.js';
+import { runUpdate } from './commands/update.js';
+import { runSetup } from './commands/setup.js';
+import { runRuntime } from './commands/runtime.js';
 import { applyPresetSelection, runAdd, runCapabilities, runDev, runInspect } from './commands/product.js';
 import { listPresets, resolvePreset } from './presets/index.js';
+import {
+  getInstallableProductChoice,
+  guidanceForRunTarget,
+  listInitProjectTypeOptions,
+  parseProjectTypeChoice,
+  RUN_TARGET_OPTIONS,
+} from './lib/init-options.js';
+import { resolveAccountAuth } from './lib/account-session.js';
 import fs from 'node:fs';
 import { repositoryRoot } from './knowledge/config.js';
-import { resolveAccountAuth } from './lib/account-session.js';
 import { renderDiagnosticError } from './errors/index.js';
 import { renderHelpOverview, runHelp } from './ui/cli/help.js';
 import { hydrateSecureCredentials } from './security/local-vault.js';
+import { getCliCommand, printAssistTip, suggestCliCommands } from './cli/command-catalog.js';
 
 const VERSION = pkg.version;
 
@@ -80,13 +100,16 @@ function printLegacyHelp() {
     agentsam deploy            Graduate an AgentSam project intentionally
 
   Capability discovery:
+    agentsam setup             Discover → plan → approve → install (Homebrew-style)
     agentsam capabilities [capability-id] [--json]
+    agentsam skill list|create|inspect|install|alias|remove|invoke
     agentsam skills [skill-id-or-alias] [--references] [--json]
 
   Power-user UX:
     agentsam context [--json]  Git repo/revision + bridge configuration from any repo
     agentsam init              Configure knowledge in this repo; --name scaffolds a new project
     agentsam index             Plan/run incremental AST and optional embeddings (--help)
+    agentsam codebaseindex     Guided ingest: materials/allowlist/embeddings/storage (alias: ingest)
     agentsam search "query"    Retrieve indexed code/text; --semantic enables embeddings
     agentsam repo snapshot     Git composition/churn; --save retains observations
     agentsam cad blender       Programmatic Blender inspect/build/render/export (--help)
@@ -104,10 +127,15 @@ function printLegacyHelp() {
     agentsam login             Sign in to Inner Animal Media and persist a secure machine-local session
     agentsam logout            Sign out locally; provider credentials stay untouched
     agentsam whoami [--json]   Authenticated account identity + safe credential status
+    agentsam terminal identity [--json]   This machine's hostname, platform, arch, and model
+    agentsam terminal enroll --instance <id> [--pair] [--json]
+                                          Needs AGENTSAM_API_KEY; --pair writes AGENTSAM_BRIDGE_KEY
+                                          (one terminal_connection in ~/.execos/profiles/)
     agentsam resume [session]  Resume a saved Agent Sam session; omit id for picker
     agentsam eval context      Offline context-strategy/economics fixtures (--help)
-    agentsam cloudflare        Native Wrangler reads + Worker CPU profile analysis (--help)
+    agentsam cloudflare        Capabilities + CF OAuth packs (agentsam cloudflare login --pack agentsam)
     agentsam go                Go runtime discovery/build/deploy (Cloudflare worker-container)
+    agentsam rust              Rust/Wasm scaffold/doctor/check/build/dev/deploy (explicit deploy)
     agentsam start-local       Local PTY on ws://127.0.0.1:3099 (no tunnel, no Cloudflare)
     agentsam ollama            Opt-in local Ollama setup/status/model management
     agentsam shell             Interactive Agent Sam slash-command shell
@@ -236,6 +264,7 @@ async function runLocalInit(config) {
   ✓ SQLite       ${db.dbPath} (${db.tables.length} tables)
   ✓ Local API    Node · http://127.0.0.1:8787
   ✓ Agent Sam     interactive CLI ready
+  ✓ Run target   ${meta.runTarget}
 
   Next:`);
   console.log(`    cd ${meta.projectName}`);
@@ -243,10 +272,19 @@ async function runLocalInit(config) {
     console.log(`    ${step}`);
   }
 
-
-  console.log(`
-  Local means local: no Worker, tunnel, IAM login, or cloud database is required.
+  if (meta.runTarget === 'local') {
+    console.log(`
+  Local is ready on this host. Cloudflare OAuth, GCP OAuth, and Docker are available when you want them:
+    agentsam connections setup · agentsam google-cloud doctor · agentsam dockerize
   `);
+  } else {
+    console.log(`
+  Guided path for ${meta.runTarget}:`);
+    for (const step of guidanceForRunTarget(meta.runTarget, { projectName: meta.projectName })) {
+      console.log(`    ${step}`);
+    }
+    console.log('');
+  }
   return { dir, meta };
 }
 
@@ -269,38 +307,83 @@ async function initInteractive(partial = {}) {
     },
   }));
 
-  const laneKey = partial.lane || pick(await select({
-    message: 'Project type',
-    initialValue: 'fullstack',
-    options: [
-      { value: 'fullstack', label: 'Full Stack' },
-      { value: 'cms', label: 'CMS' },
-      { value: 'data', label: 'Data Solutions' },
-      { value: 'crm', label: 'Customer Management' },
-      { value: 'creative', label: 'Creative & Design' },
-    ],
+  const typeOptions = listInitProjectTypeOptions();
+  const typeChoice = partial.projectType || pick(await select({
+    message: 'What do you want to build?',
+    initialValue: typeOptions[0]?.value || 'preset:fullstack',
+    options: typeOptions.map((row) => ({
+      value: row.value,
+      label: row.label,
+      hint: row.hint,
+    })),
   }));
+  const parsed = parseProjectTypeChoice(typeChoice) || { kind: 'preset', id: 'fullstack' };
+
+  if (parsed.kind === 'scaffold') {
+    const { runScaffold } = await import('./lib/scaffold/index.js');
+    await runScaffold(parsed.id);
+    outro(`Scaffold ${parsed.id} ready`);
+    return;
+  }
+
+  if (parsed.kind === 'product') {
+    const product = getInstallableProductChoice(parsed.id);
+    if (!product?.action) throw new Error(`installable product action unavailable: ${parsed.id}`);
+    if (product.action.kind === 'app') {
+      const targetDir = path.resolve(process.cwd(), projectName);
+      await runApp(['scaffold', product.action.id, targetDir]);
+      outro(`Product ${parsed.id} scaffolded at ${projectName}`);
+      return;
+    }
+    if (product.action.kind === 'scaffold') {
+      const { runScaffold } = await import('./lib/scaffold/index.js');
+      await runScaffold(product.action.id);
+      outro(`Product ${parsed.id} scaffold ready`);
+      return;
+    }
+    if (product.action.kind === 'rust-template') {
+      await runRust(['new', projectName, '--template', product.action.template || 'shared-core']);
+      outro(`Product ${parsed.id} scaffolded at ${projectName}`);
+      return;
+    }
+    throw new Error(`unsupported installable product action: ${product.action.kind}`);
+  }
+
+  if (parsed.kind === 'app') {
+    const targetDir = path.resolve(process.cwd(), projectName);
+    console.log(`\n  Scaffolding app ${parsed.id} → ${targetDir}\n`);
+    await runApp(['scaffold', parsed.id, targetDir]);
+    outro(`App ${parsed.id} scaffolded at ${projectName}`);
+    return;
+  }
+
+  const preset = resolvePreset(parsed.id);
+  const laneKey = preset.lane || preset.id;
 
   const runTarget = partial.runTarget || pick(await select({
-    message: 'Future deploy target',
+    message: 'Where will this run?',
     initialValue: 'local',
-    options: [
-      { value: 'local', label: 'Local only / decide later' },
-      { value: 'cloudflare', label: 'Cloudflare later' },
-      { value: 'gcp', label: 'GCP later' },
-    ],
+    options: RUN_TARGET_OPTIONS.map((row) => ({
+      value: row.value,
+      label: row.label,
+      hint: row.hint,
+    })),
   }));
 
   if (runTarget !== 'local') {
     const { detectContext, missingForInit } = await import('./lib/detect-context.js');
     const ctx = await detectContext();
-    if (missingForInit(ctx, resolveAccountAuth({ env: process.env }).value, { runTarget }).length) {
-      printContextSummary(ctx);
+    const missing = missingForInit(ctx, resolveAccountAuth({ env: process.env }).value, { runTarget });
+    printContextSummary(ctx);
+    if (missing.length) {
+      console.log(`  Missing for ${runTarget}: ${missing.join(', ')}`);
+      console.log('  Use the guided commands printed after scaffold — the tooling is already shipped.\n');
     }
   }
 
-  await runLocalInit({ projectName, lane: laneKey, runTarget, prompt: null });
-  outro(`Created ${projectName}`);
+  const created = await runLocalInit({ projectName, lane: laneKey, runTarget, prompt: null });
+  applyPresetSelection(created.dir, preset);
+  outro(`Created ${projectName} (${preset.id} · ${runTarget})`);
 }
 
 async function initFromArgs(argv) {
@@ -317,6 +400,11 @@ const rest = process.argv.slice(3);
 
 hydrateSecureCredentials(process.env);
 
+const catalogEntry = command && !command.startsWith('-') ? getCliCommand(command) : null;
+if (catalogEntry && command !== 'help') {
+  printAssistTip(catalogEntry);
+}
+
 if (command === '--version' || command === '-v') {
   console.log(VERSION);
 } else if (command === 'help') {
@@ -339,7 +427,7 @@ if (command === '--version' || command === '-v') {
   try {
     const opts = parseCreateArgs(rest);
     if (opts.help || !opts.projectName) {
-      console.log(`agentsam create <name> --preset <${listPresets().map((row) => row.id).join('|')}> [--target local|cloudflare|gcp]`);
+      console.log(`agentsam create <name> --preset <${listPresets().map((row) => row.id).join('|')}> [--target local|cloudflare|gcp|docker]`);
     } else {
       const preset = resolvePreset(opts.preset);
       const created = await runLocalInit({ projectName: opts.projectName, lane: preset.lane, runTarget: opts.runTarget, prompt: null });
@@ -407,6 +495,69 @@ if (command === '--version' || command === '-v') {
     reportCliError(e);
     process.exit(1);
   }
+} else if (command === 'credentials' || command === 'credential') {
+  try {
+    const code = await runCredentials(rest);
+    if (code) process.exitCode = code;
+  } catch (e) {
+    reportCliError(e);
+    process.exitCode = 1;
+  }
+} else if (command === 'cheat-sheet' || command === 'cheatsheet') {
+  try {
+    process.exitCode = runCheatSheet(rest, { version: VERSION }) || 0;
+  } catch (e) {
+    reportCliError(e);
+    process.exitCode = 1;
+  }
+} else if (command === 'setup') {
+  try {
+    const code = await runSetup(rest);
+    if (code) process.exitCode = code;
+  } catch (e) {
+    reportCliError(e);
+    process.exitCode = 1;
+  }
+} else if (command === 'runtime' || command === 'agentsamd') {
+  try {
+    const code = await runRuntime(rest);
+    if (code) process.exitCode = code;
+  } catch (e) {
+    reportCliError(e);
+    process.exitCode = 1;
+  }
+} else if (command === 'compute') {
+  try {
+    const code = await runCompute(rest);
+    if (code) process.exitCode = code;
+  } catch (e) {
+    reportCliError(e);
+    process.exitCode = 1;
+  }
+} else if (command === 'google-cloud' || command === 'gcp' || command === 'gcloud') {
+  try {
+    const code = await runGoogleCloud(rest);
+    if (code) process.exitCode = code;
+  } catch (e) {
+    reportCliError(e);
+    process.exitCode = 1;
+  }
+} else if (command === 'billing' || command === 'costs') {
+  try {
+    const code = await runBilling(rest);
+    if (code) process.exitCode = code;
+  } catch (e) {
+    reportCliError(e);
+    process.exitCode = 1;
+  }
+} else if (command === 'update') {
+  try {
+    const code = await runUpdate(rest);
+    if (code) process.exitCode = code;
+  } catch (e) {
+    reportCliError(e);
+    process.exitCode = 1;
+  }
 } else if (command === 'env') {
   try {
     await runEnv(rest);
@@ -442,6 +593,13 @@ if (command === '--version' || command === '-v') {
     if (!e?.reported) reportCliError(e);
     process.exitCode = 1;
   }
+} else if (command === 'rust' || command === 'wasm' || command === 'rapid-rust') {
+  try {
+    await runRust(rest);
+  } catch (e) {
+    if (!e?.reported) reportCliError(e);
+    process.exitCode = Number(e?.exitCode || 1);
+  }
 } else if (command === 'login') {
   try {
     await runLogin(rest);
@@ -463,6 +621,21 @@ if (command === '--version' || command === '-v') {
     reportCliError(e);
     process.exitCode = 1;
   }
+} else if (command === 'terminal') {
+  try {
+    const result = await runTerminal(rest);
+    if (result?.ok === false) process.exitCode = 1;
+  } catch (e) {
+    reportCliError(e);
+    process.exitCode = 1;
+  }
+} else if (command === 'api-key' || command === 'apikey' || command === 'api-keys') {
+  try {
+    await runApiKey(rest);
+  } catch (e) {
+    reportCliError(e);
+    process.exitCode = 1;
+  }
 } else if (command === 'resume') {
   try {
     await runResume(rest);
@@ -547,13 +720,20 @@ if (command === '--version' || command === '-v') {
   }
 } else if (command === 'security' || command === 'sca') {
   await runSecurity(rest);
-} else if (command === 'skills' || command === 'skill') {
+} else if (command === 'skills') {
   try {
     runSkills(rest);
   } catch (e) {
     reportCliError(e);
     process.exitCode = 1;
   }
+} else if (command === 'skill') {
+  try {
+    await runSkill(rest);
+  } catch (e) {
+    reportCliError(e);
+    process.exitCode = 1;
+  }
 } else if (command === 'merkle') {
   await runMerkle(rest);
 } else if (command === 'deploy-receipt') {
@@ -570,6 +750,15 @@ if (command === '--version' || command === '-v') {
 } else if (command === 'autorag') {
   try { await (await import('./commands/autorag.js')).runAutoRag(rest); }
   catch (e) { reportCliError(e); process.exitCode = 1; }
+} else if (command === 'codebaseindex' || command === 'ingest' || command === 'codebase-index') {
+  try {
+    await (await import('./commands/codebaseindex.js')).runCodebaseindex(rest);
+  } catch (e) {
+    if (e?.code !== 'AGENTSAM_CODEBASEINDEX_CANCELLED') {
+      reportCliError(e);
+      process.exitCode = 1;
+    }
+  }
 } else if (['index', 'search', 'repo'].includes(command)) {
   try {
     const commands = await import('./commands/knowledge.js');
@@ -642,6 +831,15 @@ if (command === '--version' || command === '-v') {
   }
 } else {
   console.error(`\n  Unknown command: ${command}\n`);
+  const suggestions = suggestCliCommands(command);
+  if (suggestions.length) {
+    console.error('  Did you mean:');
+    for (const row of suggestions) {
+      console.error(`    agentsam ${row.id}  — ${row.summary}`);
+      if (row.skill) console.error(`      tip: use skill ${row.skill}`);
+    }
+    console.error('');
+  }
   printHelp();
   process.exit(1);
 }

package/src/commands/account-auth.js

@@ -1,24 +1,110 @@
 import { authenticateViaBrowser } from '../lib/auth.js';
 import { clearAccountSession, readAccountSession, saveAccountSession } from '../lib/account-session.js';
-import { collectWhoami, renderWhoami } from './whoami.js';
+import { collectWhoami, renderLoginResult, renderWhoami } from './whoami.js';
+import readline from 'node:readline';
 
 function writeLine(write, value = '') { write(`${value}\n`); }
 
+/**
+ * Interactive provider picker for `agentsam login`.
+ * @returns {Promise<'inneranimalmedia'|'google'|'cloudflare'>}
+ */
+export async function promptLoginProvider(options = {}) {
+  const input = options.input || process.stdin;
+  const output = options.output || process.stdout;
+  const write = options.write || ((text) => output.write(text));
+
+  if (options.provider) {
+    const p = String(options.provider).trim().toLowerCase();
+    if (p === 'iam' || p === 'inneranimalmedia' || p === '1') return 'inneranimalmedia';
+    if (p === 'google' || p === '2') return 'google';
+    if (p === 'cloudflare' || p === 'cf' || p === '3') return 'cloudflare';
+  }
+
+  // Non-interactive / CI: default to Inner Animal Media AS (CLI OAuth).
+  if (!input?.isTTY || !output?.isTTY || options.skipPrompt === true) {
+    return 'inneranimalmedia';
+  }
+
+  writeLine(write, '');
+  writeLine(write, '  How do you want to sign in?');
+  writeLine(write, '    [1] Inner Animal Media   (IAM_CLIENT_ID + IAM_OAUTH_ISSUER)');
+  writeLine(write, '    [2] Google OAuth         (GOOGLE_CLIENT_ID or GOOGLE_DESKTOP_CLIENT_ID)');
+  writeLine(write, '    [3] Cloudflare OAuth     (CLOUDFLARE_OAUTH_CLIENT_ID)');
+  writeLine(write, '');
+
+  const rl = readline.createInterface({ input, output });
+  try {
+    const answer = await new Promise((resolve) => {
+      rl.question('  Choose [1/2/3] (default 1): ', resolve);
+    });
+    const raw = String(answer || '').trim().toLowerCase();
+    if (!raw || raw === '1' || raw === 'iam' || raw === 'inneranimalmedia') return 'inneranimalmedia';
+    if (raw === '2' || raw === 'google') return 'google';
+    if (raw === '3' || raw === 'cloudflare' || raw === 'cf') return 'cloudflare';
+    writeLine(write, `  Unknown choice "${raw}" — using Inner Animal Media.`);
+    return 'inneranimalmedia';
+  } finally {
+    rl.close();
+  }
+}
+
 export async function runLogin(argv = [], options = {}) {
-  const allowed = new Set(['--json']);
-  const unknown = argv.filter((arg) => !allowed.has(arg));
+  const allowed = new Set(['--json', '--provider', '--iam', '--google', '--cloudflare']);
+  const unknown = argv.filter((arg) => {
+    if (allowed.has(arg)) return false;
+    if (arg.startsWith('--provider=')) return false;
+    return true;
+  });
   if (unknown.length) throw new Error(`unknown login option: ${unknown[0]}`);
   const write = options.write || ((text) => process.stdout.write(text));
   const authenticate = options.authenticateImpl || authenticateViaBrowser;
-  const session = await authenticate();
+
+  let providerFlag = null;
+  for (const arg of argv) {
+    if (arg === '--iam') providerFlag = 'inneranimalmedia';
+    if (arg === '--google') providerFlag = 'google';
+    if (arg === '--cloudflare') providerFlag = 'cloudflare';
+    if (arg.startsWith('--provider=')) providerFlag = arg.slice('--provider='.length);
+  }
+
+  const provider = await promptLoginProvider({
+    ...options,
+    provider: providerFlag || options.provider,
+    write,
+    input: options.input,
+    output: options.output,
+    skipPrompt: argv.includes('--json') || options.skipPrompt === true,
+  });
+
+  const session = await authenticate({
+    home: options.home,
+    env: options.env || process.env,
+    input: options.input,
+    output: options.output,
+    loginProvider: provider,
+  });
   if (!String(session?.access_token || '').trim()) throw new Error('Agent Sam login did not return a browser session credential');
   // authenticateViaBrowser persists by default. Keep injected transports/test flows equivalent.
   if (!readAccountSession({ home: options.home })) saveAccountSession(session, { home: options.home });
   const status = await collectWhoami({ home: options.home, env: options.env || process.env, contextLoader: options.contextLoader });
-  if (argv.includes('--json')) writeLine(write, JSON.stringify(status, null, 2));
-  else {
-    writeLine(write, '');
-    writeLine(write, '  Agent Sam login complete.');
+  if (argv.includes('--json')) {
+    writeLine(write, JSON.stringify({
+      ...status,
+      login: {
+        browser_oauth_saved: true,
+        provider,
+        authoritative: status.active_auth?.kind || null,
+        oauth_authoritative:
+          status.active_auth?.kind === 'agentsam_browser_oauth'
+          || status.active_auth?.kind === 'browser_oauth',
+        api_key_shadows_oauth:
+          Boolean(status.browser_session?.configured)
+          && (status.active_auth?.kind === 'agentsam_api_key' || status.active_auth?.kind === 'api_key'),
+      },
+    }, null, 2));
+  } else {
+    write(renderLoginResult(status));
     write(renderWhoami(status));
   }
   return status;