@inneranimalmedia/agentsam-sdk 2.6.2 → 2.6.4

package/src/commands/connections.js

@@ -9,6 +9,7 @@ import {
   resolveCloudflareOAuthClient,
 } from '../../packages/connectors/cloudflare/src/index.js';
 import { resolveIamIssuer } from '../../packages/identity/src/contracts/auth-config.js';
+import { collectRuntimeStatus } from './runtime-status.js';
 
 const PRODUCTION_CALLBACK = `https://agentsam.inneranimalmedia.com${CLOUDFLARE_CALLBACK_PATH}`;
 
@@ -45,49 +46,145 @@ function printSetup(env = process.env) {
   return 0;
 }
 
-export async function runConnections(args = []) {
+function bindingKey(row = {}) {
+  return String(row.name || '').trim();
+}
+
+function bindingTypeLabel(type = '') {
+  switch (String(type || '').trim()) {
+    case 'plain_text': return 'Variable';
+    case 'json': return 'Variable (JSON)';
+    case 'secret_text': return 'Secret';
+    case 'secret_key': return 'Secret key';
+    case 'ai': return 'Workers AI';
+    case 'd1': return 'D1 database';
+    case 'service': return 'Service binding';
+    case 'hyperdrive': return 'Hyperdrive';
+    case 'vpc_service': return 'VPC Service';
+    case 'r2_bucket': return 'R2 bucket';
+    case 'assets': return 'Assets';
+    default: return String(type || 'Binding');
+  }
+}
+
+function bindingTarget(row = {}) {
+  if (row.type === 'secret_text' || row.type === 'secret_key') return 'Value encrypted';
+  if (row.value != null) return String(row.value);
+  if (row.database_name) return row.database_name;
+  if (row.bucket_name) return row.bucket_name;
+  if (row.service) return row.environment ? `${row.service} · ${row.environment}` : row.service;
+  if (row.index_name) return row.index_name;
+  if (row.database_id) return row.database_id;
+  if (row.service_id) return row.service_id;
+  if (row.id) return row.id;
+  if (row.namespace) return row.namespace;
+  if (row.store_id && row.secret_name) return `${row.store_id} · ${row.secret_name}`;
+  return '';
+}
+
+function renderBindingRows(rows = []) {
+  if (!rows.length) return ['    none'];
+  const width = Math.min(32, Math.max(4, ...rows.map((row) => bindingKey(row).length)));
+  return rows.map((row) => {
+    const name = bindingKey(row).padEnd(width);
+    const type = bindingTypeLabel(row.type);
+    const target = bindingTarget(row);
+    return `    ${name}  ${type}${target ? ` · ${target}` : ''}`;
+  });
+}
+
+function renderWorkerBindings(status) {
+  const cloudflare = status.cloudflare || {};
+  const bindings = cloudflare.bindings;
+  if (!bindings) return ['  Worker runtime    not verified'];
+
+  const variables = Array.isArray(bindings.runtime_variables) ? bindings.runtime_variables : [];
+  const secrets = Array.isArray(bindings.runtime_secrets) ? bindings.runtime_secrets : [];
+  const resources = Array.isArray(bindings.resources) ? bindings.resources : [];
+  const declared = Array.isArray(bindings.declared) ? bindings.declared : [];
+  const missing = Array.isArray(bindings.missing) ? bindings.missing : [];
+  const mismatches = Array.isArray(bindings.type_mismatches) ? bindings.type_mismatches : [];
+
+  const lines = [];
+  if (cloudflare.version?.id || cloudflare.version?.number != null) {
+    const versionLabel = cloudflare.version?.number != null ? `v${cloudflare.version.number}` : 'version';
+    lines.push(`  live Worker       ${versionLabel}${cloudflare.version?.id ? ` · ${cloudflare.version.id}` : ''}`);
+  }
+
+  lines.push('');
+  lines.push(`  Runtime variables and secrets  ${variables.length} variables · ${secrets.length} secrets`);
+  lines.push(...renderBindingRows([...variables, ...secrets].sort((a, b) => bindingKey(a).localeCompare(bindingKey(b)))));
+
+  lines.push('');
+  lines.push(`  Bindings          ${resources.length} live resources`);
+  lines.push(...renderBindingRows(resources.sort((a, b) => bindingKey(a).localeCompare(bindingKey(b)))));
+
+  lines.push('');
+  lines.push(`  Config comparison ${declared.length} declared locally · ${missing.length} missing live · ${mismatches.length} type mismatch`);
+  if (cloudflare.config) lines.push(`    source           ${cloudflare.config}`);
+  if (missing.length) {
+    for (const row of missing) lines.push(`    ✗ ${bindingKey(row)} · declared ${row.type || 'unknown'} · missing from live version`);
+  }
+  if (mismatches.length) {
+    for (const row of mismatches) lines.push(`    ! ${bindingKey(row)} · declared ${row.declared || 'unknown'} · live ${row.live || 'unknown'}`);
+  }
+
+  return lines;
+}
+
+function renderConnections(status) {
+  const lines = ['', '  Agent Sam · connections', ''];
+  lines.push(`  IAM account       ${status.identity?.authenticated ? 'connected' : 'not connected'}`);
+  lines.push(`  active auth       ${status.identity?.active_auth?.kind || 'none'}`);
+  lines.push(`  model providers   ${(status.model_summary?.configured_providers || []).join(', ') || 'none configured'}`);
+  lines.push(`  terminal registry ${status.terminal?.connected ? `${status.terminal.active_connection_count} active / ${status.terminal.connections.length} total` : `unavailable · ${status.terminal?.error || 'not authenticated'}`}`);
+  for (const row of status.terminal?.connections || []) {
+    lines.push(`    ${row.default ? '★' : '•'} ${row.name || row.id} · ${row.kind || 'terminal'} · ${row.active ? 'active' : 'inactive'} · ${row.health}`);
+  }
+  lines.push(`  Worker            ${status.cloudflare?.connected ? `${status.cloudflare.worker_name} · live` : status.cloudflare?.configured ? `${status.cloudflare.worker_name} · not verified` : 'not configured'}`);
+  lines.push(...renderWorkerBindings(status));
+  lines.push('');
+  lines.push('  Live Cloudflare binding names/targets are shown; secret values and terminal endpoint credentials are never printed.');
+  lines.push('');
+  return lines.join('\n');
+}
+
+export async function runConnections(args = [], options = {}) {
   const argv = args.filter((a) => a !== '--json');
   const jsonMode = args.includes('--json');
-  const env = process.env;
+  const env = options.env || process.env;
+  const write = options.write || ((value) => process.stdout.write(value));
   if (argv[0] === 'cloudflare' && argv[1] === 'setup') {
     if (jsonMode) {
-      console.log(JSON.stringify({
+      write(`${JSON.stringify({
         callback: PRODUCTION_CALLBACK,
         authorize: 'https://dash.cloudflare.com/oauth2/auth',
         token: 'https://dash.cloudflare.com/oauth2/token',
         revoke: 'https://dash.cloudflare.com/oauth2/revoke',
         mintsRealClient: false,
         client: resolveCloudflareOAuthClient(env),
-      }, null, 2));
+      }, null, 2)}\n`);
       return 0;
     }
     return printSetup(env);
   }
-  const report = doctor(env);
+  if (argv.length) throw new Error(`unknown connections option: ${argv[0]}`);
+  const status = await (options.collectRuntime || collectRuntimeStatus)({
+    ...options,
+    env,
+    cwd: options.cwd || process.cwd(),
+    discoverModels: true,
+  });
   if (jsonMode) {
-    console.log(JSON.stringify({ identity: report.identity, cloudflare: report.cloudflare }, null, 2));
-    return 0;
+    write(`${JSON.stringify({
+      schema_version: status.schema_version,
+      identity: status.identity,
+      providers: status.models?.providers || [],
+      terminal: status.terminal,
+      cloudflare: status.cloudflare,
+    }, null, 2)}\n`);
+    return status;
   }
-  const iam = report.identity;
-  const cf = report.cloudflare;
-  const client = report.client;
-  console.log('AgentSam Identity');
-  console.log('');
-  console.log('IAM client');
-  console.log(`  ${iam.clientId ? '✓' : '•'} client id`);
-  console.log(`  ✓ issuer ${iam.issuer}`);
-  console.log(`  ${iam.serverSecret ? '✓' : '•'} server secret configured`);
-  if (iam.originAlias) console.log('Compatibility\n  IAM_ORIGIN -> deprecated alias');
-  console.log('');
-  console.log('Cloudflare connection');
-  console.log('');
-  console.log('OAuth client');
-  console.log(`  client id: ${cf.clientId}`);
-  console.log(`  secret: ${cf.secret}`);
-  console.log(`  status: ${client.status}`);
-  if (client.fixture) {
-    console.log('  OAuth client fixture configured');
-    console.log('  real Cloudflare OAuth client still required');
-  }
-  return 0;
+  write(renderConnections(status));
+  return status;
 }

package/src/commands/context-economics.js

@@ -58,6 +58,8 @@ export function buildContextEconomicsReport(cwd, options = {}) {
     model: model.provider_model_id,
     model_key: model.model_key,
     resolved: true,
+    compaction_supported: ['openai', 'grok'].includes(model.provider) && model.capabilities?.compaction === true,
+    auto_compact: options.autoCompact !== false,
     reasoning_effort: preferences.reasoningEffort || 'auto',
     service_tier: preferences.serviceTier || 'default',
     active_input_tokens: active,
@@ -117,6 +119,12 @@ export function renderContextEconomics(report) {
     `    intervene at    ${formatInteger(report.intervene_at_tokens)}`,
     `    max normal      ${formatInteger(report.max_normal_input_tokens)}`,
     '',
+    '  Compaction',
+    `    support         ${report.compaction_supported ? 'native' : 'unavailable'}`,
+    `    automatic       ${report.compaction_supported && report.auto_compact ? 'enabled' : 'disabled'}`,
+    `    threshold       ${formatInteger(report.compact_at_tokens)}`,
+    '    command         /compact · /compact status',
+    '',
     '  Economics',
     `    price threshold ${formatInteger(report.pricing_threshold_tokens)}`,
     `    remaining       ${remaining}`,

package/src/commands/db.js

@@ -1,3 +1,4 @@
+import { discoverProjectStores, selectKnowledgeStore } from '../knowledge/store-discovery.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { createLocalSqliteDatabase, initializeLocalSqlite, inspectLocalSqlite } from '../local/sqlite.js';
@@ -24,6 +25,12 @@ function resolveDb(root, config) {
 
 export async function runDb(argv = [], opts = {}) {
   const sub = argv[0] || 'status';
+  if (sub === 'sources' || sub === 'select') {
+    if (sub === 'select' && (argv[1] !== 'knowledge' || !argv[2] || argv.length > 4)) throw new Error('Usage: /db select knowledge sqlite|postgres [CONNECTION_ENV]');
+    const result = sub === 'sources' ? await discoverProjectStores(opts.cwd || process.cwd()) : selectKnowledgeStore(opts.cwd || process.cwd(), argv[2], argv[3]);
+    (opts.write || console.log)(JSON.stringify(result, null, 2) + '\n');
+    return result;
+  }
   if (!['init', 'migrate', 'status'].includes(sub)) {
     throw new Error(`unknown db command: ${sub}`);
   }

package/src/commands/env.js

@@ -1,23 +1,72 @@
 import { spawnSync } from 'node:child_process';
-import { describeProviderCredential, ensureProviderEnvProfile, providerCredentialSpec } from '../lib/provider-credentials.js';
+import {
+  describeProviderCredential,
+  ensureProviderEnvProfile,
+  exportProviderEnvProfile,
+  providerCredentialSpec,
+  listProviderCredentialStatus,
+  ensureAgentEnvLoader,
+  agentEnvLoaderPath,
+  renderEnvShellExports,
+} from '../lib/provider-credentials.js';
 
-const PROVIDERS = Object.freeze(['openai', 'anthropic', 'gemini', 'grok', 'cloudflare']);
+const PROVIDERS = Object.freeze([
+  'openai',
+  'anthropic',
+  'gemini',
+  'grok',
+  'xai',
+  'cursor',
+  'cloudflare',
+  'inneranimalmedia',
+]);
 
-function writeLine(write, value = '') { write(`${value}\n`); }
+const PROVIDER_ALIASES = Object.freeze({
+  grok: 'xai',
+  iam: 'inneranimalmedia',
+  agentsam: 'inneranimalmedia',
+  'agentsam-api': 'inneranimalmedia',
+});
 
-function detectCloudflareAccounts(options = {}) {
+function writeLine(write, value = '') {
+  write(`${value}\n`);
+}
+
+function normalizeEnvProvider(raw) {
+  const id = String(raw || '')
+    .trim()
+    .toLowerCase();
+  return PROVIDER_ALIASES[id] || id;
+}
+
+export function detectCloudflareAccounts(options = {}) {
   const env = options.env || process.env;
-  const explicit = String(options.accountId || env.ACCOUNT_ID || env.CLOUDFLARE_ACCOUNT_ID || '').trim();
+  const explicit = String(options.accountId || env.CLOUDFLARE_ACCOUNT_ID || '').trim();
   if (explicit) return { accounts: [{ id: explicit, name: null }], source: 'environment' };
   const spawn = options.spawnSyncImpl || spawnSync;
-  const result = spawn('npx', ['--no-install', 'wrangler', 'whoami', '--json'], { cwd: options.cwd || process.cwd(), env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
-  if (result?.status !== 0) return { accounts: [], source: 'wrangler', error: String(result?.stderr || '').trim() || `wrangler exited ${result?.status ?? 'unknown'}` };
+  const npxBin = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+  const result = spawn(npxBin, ['--no-install', 'wrangler', 'whoami', '--json'], {
+    cwd: options.cwd || process.cwd(),
+    env,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    shell: process.platform === 'win32',
+  });
+  if (result?.status !== 0) {
+    return {
+      accounts: [],
+      source: 'wrangler',
+      error: String(result?.stderr || '').trim() || `wrangler exited ${result?.status ?? 'unknown'}`,
+    };
+  }
   try {
     const parsed = JSON.parse(String(result.stdout || '{}'));
-    const accounts = (Array.isArray(parsed?.accounts) ? parsed.accounts : []).map((row) => ({
-      id: String(row?.id || row?.account_id || '').trim(),
-      name: String(row?.name || row?.account_name || '').trim() || null,
-    })).filter((row) => row.id);
+    const accounts = (Array.isArray(parsed?.accounts) ? parsed.accounts : [])
+      .map((row) => ({
+        id: String(row?.id || row?.account_id || '').trim(),
+        name: String(row?.name || row?.account_name || '').trim() || null,
+      }))
+      .filter((row) => row.id);
     return { accounts, source: 'wrangler', error: null };
   } catch (error) {
     return { accounts: [], source: 'wrangler', error: `invalid wrangler JSON: ${error?.message || error}` };
@@ -34,25 +83,90 @@ function cloudflareGuidance(write) {
   writeLine(write, '  D1 / R2 / KV      add direct product permissions only when AgentSam must read/write those resources directly');
 }
 
+function agentsamApiGuidance(write) {
+  writeLine(write, '');
+  writeLine(write, '  AGENTSAM_API_KEY (aak_*)');
+  writeLine(write, '  Preferred:');
+  writeLine(write, '    agentsam api-key create --name "$(hostname)" --store keychain --activate');
+  writeLine(write, '  Then:');
+  writeLine(write, '    source ~/.agentsam/load-agent-env.sh');
+  writeLine(write, '    agentsam whoami');
+}
+
+function cursorGuidance(write) {
+  writeLine(write, '');
+  writeLine(write, '  CURSOR_API_KEY roll');
+  writeLine(write, '  1. Create a new key in Cursor dashboard');
+  writeLine(write, '  2. printf \'%s\' "$NEW" | agentsam providers add cursor --from-stdin');
+  writeLine(write, '  3. source ~/.agentsam/load-agent-env.sh');
+  writeLine(write, '  4. If Local Studio Worker uses the secret: wrangler secret put CURSOR_API_KEY');
+  writeLine(write, '  Optional: agentsam providers remove cursor --yes  (before add, to force replace)');
+}
+
 export async function runEnv(argv = [], options = {}) {
   const write = options.write || ((text) => process.stdout.write(text));
-  const [command = 'status', providerArg] = argv;
+  const [command = 'status', ...args] = argv;
   let accountId = '';
-  for (let i = 2; i < argv.length; i += 1) {
-    if (argv[i] === '--account-id') accountId = String(argv[++i] || '').trim();
-    else throw new Error(`unexpected env argument: ${argv[i]}`);
+  let profile = 'default';
+  const positionals = [];
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === '--account-id') accountId = String(args[++i] || '').trim();
+    else if (args[i] === '--profile') profile = String(args[++i] || 'default').trim() || 'default';
+    else if (String(args[i] || '').startsWith('-')) throw new Error(`unexpected env argument: ${args[i]}`);
+    else positionals.push(args[i]);
   }
+  const providerArg = positionals[0];
+
   if (command === '--help' || command === '-h' || command === 'help') {
-    writeLine(write, 'agentsam env init <openai|anthropic|gemini|grok|cloudflare> [--account-id <id>]');
+    writeLine(write, 'agentsam env shell [--profile default]   print export lines for eval (keychain/vault)');
+    writeLine(write, 'agentsam env init <openai|anthropic|gemini|grok|cursor|cloudflare|inneranimalmedia> [--account-id <id>]');
     writeLine(write, 'agentsam env status [provider]');
+    writeLine(write, 'agentsam env export <provider>     write ~/.agentsam/env.d from vault (compat fallback)');
+    writeLine(write, 'agentsam env boot-line             print: source ~/.agentsam/load-agent-env.sh');
     return;
   }
+
+  if (command === 'shell') {
+    ensureAgentEnvLoader(options);
+    const result = renderEnvShellExports({
+      ...options,
+      profile,
+      providers: positionals.map(normalizeEnvProvider).filter(Boolean),
+    });
+    write(result.script);
+    return result;
+  }
+
+  if (command === 'boot-line') {
+    ensureAgentEnvLoader(options);
+    writeLine(write, 'source ~/.agentsam/load-agent-env.sh');
+    writeLine(write, `# loader: ${agentEnvLoaderPath(options)}`);
+    writeLine(write, '# prefers: eval "$(agentsam env shell --profile default)"');
+    return { command: 'source ~/.agentsam/load-agent-env.sh' };
+  }
+
+  if (command === 'export') {
+    const provider = normalizeEnvProvider(providerArg);
+    if (!providerCredentialSpec(provider)) throw new Error(`unsupported_provider:${provider}`);
+    const result = exportProviderEnvProfile(provider, options);
+    writeLine(write, '');
+    writeLine(write, `  Exported ${provider}: ${result.file}`);
+    writeLine(write, '  source ~/.agentsam/load-agent-env.sh');
+    writeLine(write, '  (compat: plaintext env.d is opt-in; prefer keychain + env shell)');
+    writeLine(write, '');
+    return result;
+  }
+
   if (command === 'init') {
-    const provider = String(providerArg || '').trim().toLowerCase();
-    if (!PROVIDERS.includes(provider)) throw new Error(`env init requires one of: ${PROVIDERS.join(', ')}`);
+    const provider = normalizeEnvProvider(providerArg);
+    if (!PROVIDERS.includes(provider) && provider !== 'xai') {
+      throw new Error(`env init requires one of: ${PROVIDERS.join(', ')}`);
+    }
     let cloudflareAccounts = null;
     if (provider === 'cloudflare') {
-      if (accountId && !/^[a-f0-9]{32}$/i.test(accountId)) throw new Error('Cloudflare --account-id must be a 32-character hexadecimal account ID');
+      if (accountId && !/^[a-f0-9]{32}$/i.test(accountId)) {
+        throw new Error('Cloudflare --account-id must be a 32-character hexadecimal account ID');
+      }
       cloudflareAccounts = detectCloudflareAccounts({ ...options, accountId });
       if (!accountId && cloudflareAccounts.accounts.length === 1) accountId = cloudflareAccounts.accounts[0].id;
     }
@@ -62,29 +176,43 @@ export async function runEnv(argv = [], options = {}) {
     writeLine(write, `  profile  ${result.file}${result.created ? ' · created' : ' · existing'}`);
     writeLine(write, `  loader   ${result.loader}`);
     writeLine(write, '');
-    writeLine(write, '  Add the credential to the profile, then load it into this shell:');
-    writeLine(write, `    ${result.source_command}`);
+    writeLine(write, '  Prefer vault/keychain storage, then:');
+    writeLine(write, '    source ~/.agentsam/load-agent-env.sh');
     if (provider === 'cloudflare') {
       if (accountId) writeLine(write, `  account  detected/configured (${cloudflareAccounts?.source || 'explicit'})`);
-      else if ((cloudflareAccounts?.accounts || []).length > 1) writeLine(write, `  account  ${cloudflareAccounts.accounts.length} Wrangler accounts found · rerun with --account-id <id>`);
-      else writeLine(write, '  account  not detected · set ACCOUNT_ID in the profile or rerun with --account-id <id>');
+      else if ((cloudflareAccounts?.accounts || []).length > 1) {
+        writeLine(write, `  account  ${cloudflareAccounts.accounts.length} Wrangler accounts found · rerun with --account-id <id>`);
+      } else {
+        writeLine(write, '  account  not detected · set CLOUDFLARE_ACCOUNT_ID in the profile or rerun with --account-id <id>');
+      }
       cloudflareGuidance(write);
     }
+    if (provider === 'inneranimalmedia') agentsamApiGuidance(write);
+    if (provider === 'cursor') cursorGuidance(write);
     writeLine(write, '');
     return result;
   }
+
   if (command === 'status') {
-    const providers = providerArg ? [String(providerArg).trim().toLowerCase()] : PROVIDERS;
-    for (const provider of providers) if (!providerCredentialSpec(provider)) throw new Error(`unsupported_provider:${provider}`);
+    const providers = providerArg
+      ? [normalizeEnvProvider(providerArg)]
+      : PROVIDERS.filter((p) => p !== 'grok');
+    for (const provider of providers) {
+      if (!providerCredentialSpec(provider)) throw new Error(`unsupported_provider:${provider}`);
+    }
     writeLine(write, '');
     writeLine(write, '  AgentSam · provider environments');
     for (const provider of providers) {
       const row = describeProviderCredential(provider, options);
       const extra = row.account_id ? ` · account ${row.account_id}` : '';
-      writeLine(write, `  ${provider.padEnd(12)} ${row.configured ? 'configured' : row.error ? `blocked (${row.error})` : 'not configured'}${extra}`);
+      const state = row.configured ? `available · ${row.source || 'runtime'}${extra}` : row.error || 'not configured';
+      writeLine(write, `  ${String(row.label || provider).padEnd(22)} ${state}`);
     }
     writeLine(write, '');
-    return;
+    writeLine(write, '  Load: source ~/.agentsam/load-agent-env.sh');
+    writeLine(write, '');
+    return { providers: listProviderCredentialStatus(options) };
   }
+
   throw new Error(`unknown env command: ${command}`);
 }