@inneranimalmedia/agentsam-sdk 2.6.4 → 2.6.5

package/src/cli/command-catalog.js

@@ -14,12 +14,15 @@ export const CLI_COMMAND_CATALOG = Object.freeze([
   { id: 'dev', summary: 'Run this project’s npm dev script', topic: 'work', skill: 'agentsam-app-fundamentals' },
   { id: 'inspect', summary: 'Bounded repository inspect / authority view', topic: 'work', skill: 'agentsam-app-fundamentals', operation: 'repository.inspect', common: true },
   { id: 'capabilities', summary: 'Inspect capability contracts', topic: 'create', skill: 'agentsam-app-fundamentals' },
+  { id: 'setup', summary: 'Discover → plan → approve → install capabilities (Homebrew-style)', topic: 'start', skill: 'agentsam-app-fundamentals', common: true },
   { id: 'skills', aliases: ['skill'], summary: 'List or load portable skill instructions', topic: 'create', skill: 'agentsam-app-fundamentals', common: true },
   { id: 'context', summary: 'Git + bridge context from any repo', topic: 'work', skill: 'agentsam-app-fundamentals' },
   { id: 'status', summary: 'Account, models, terminal, and live deploy awareness', topic: 'runtime', skill: 'agentsam-progression-guard', common: true },
   { id: 'db', summary: 'Project-local SQLite status/init', topic: 'runtime', skill: 'agentsam-app-fundamentals' },
   { id: 'models', summary: 'Probe hosted/local model availability', topic: 'start', skill: 'agentsam-app-fundamentals', common: true },
   { id: 'providers', summary: 'Configure machine provider credentials', topic: 'start', skill: 'agentsam-app-fundamentals' },
+  { id: 'credentials', aliases: ['credential'], summary: 'Audit credentials, drift, and failure remediation (never prints secrets)', topic: 'start', skill: 'agentsam-app-fundamentals', common: true },
+  { id: 'cheat-sheet', aliases: ['cheatsheet'], summary: 'Organized command groups (gcloud-like)', topic: 'start', skill: 'agentsam-app-fundamentals', common: true },
   { id: 'env', summary: 'Provider profile / shell loader helpers', topic: 'start', skill: 'agentsam-app-fundamentals' },
   { id: 'api-key', aliases: ['apikey', 'api-keys'], summary: 'Create/list/rotate AgentSam API keys (aak_*)', topic: 'start', skill: 'agentsam-app-fundamentals', common: true },
   { id: 'login', summary: 'Sign in and persist machine-local session', topic: 'start', skill: 'agentsam-app-fundamentals' },
@@ -31,10 +34,15 @@ export const CLI_COMMAND_CATALOG = Object.freeze([
   { id: 'ollama', summary: 'Local Ollama setup/status/models', topic: 'runtime', skill: 'agentsam-app-fundamentals' },
   { id: 'tunnel', summary: 'Cloudflare Tunnel via Wrangler', topic: 'runtime', skill: 'agentsam-cloudflare-workers' },
   { id: 'connections', aliases: ['connection'], summary: 'Inspect execution connections', topic: 'runtime', skill: 'agentsam-cloudflare-workers' },
+  { id: 'compute', summary: 'Alias for google-cloud compute/iam helpers', topic: 'runtime', skill: 'agentsam-app-fundamentals' },
+  { id: 'google-cloud', aliases: ['gcp', 'gcloud'], summary: 'Google Cloud auth, projects, compute, IAM SAs, billing, doctor', topic: 'runtime', skill: 'agentsam-app-fundamentals', common: true },
+  { id: 'billing', aliases: ['costs'], summary: 'Billing account relationships (not --billing-project)', topic: 'runtime', skill: 'agentsam-app-fundamentals' },
+  { id: 'update', summary: 'Component update preview (gcloud-like)', topic: 'runtime', skill: 'agentsam-app-fundamentals' },
   { id: 'deploy', summary: 'Graduate intentionally to cloud', topic: 'runtime', skill: 'agentsam-progression-guard', common: true },
   { id: 'deploy-receipt', summary: 'Merkle deploy/checkpoint receipts', topic: 'runtime', skill: 'agentsam-progression-guard' },
   { id: 'cloudflare', aliases: ['cf'], summary: 'Wrangler reads + Worker CPU profiles', topic: 'runtime', skill: 'agentsam-cloudflare-workers' },
   { id: 'go', summary: 'Go product discover/build/deploy', topic: 'runtime', skill: 'agentsam-cloudflare-workers' },
+  { id: 'rust', aliases: ['wasm', 'rapid-rust'], summary: 'Rust/Wasm scaffold, doctor, check, build, dev, explicit deploy', topic: 'runtime', skill: 'agentsam-cloudflare-workers' },
   { id: 'mcp', summary: 'MCP server catalog and client adapters', topic: 'runtime', skill: 'agentsam-cloudflare-workers' },
   { id: 'eval', summary: 'Context fixtures and live eval telemetry', topic: 'runtime', skill: 'agentsam-app-fundamentals' },
   { id: 'index', summary: 'Plan/run incremental AST (+ optional embeddings)', topic: 'work', skill: 'agentsam-codebaseindex', operation: 'codebaseindex.ingest' },

package/src/cli.js

@@ -39,16 +39,33 @@ 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';
@@ -83,6 +100,7 @@ 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]
@@ -109,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
@@ -241,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}`);
@@ -248,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 };
 }
 
@@ -274,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) {
@@ -349,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 });
@@ -417,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);
@@ -452,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);
@@ -473,6 +621,14 @@ 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);

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;