@inneranimalmedia/agentsam-sdk 2.6.1 → 2.6.3

package/src/commands/providers.js

@@ -0,0 +1,389 @@
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  multiselect,
+  outro,
+  password,
+  select,
+  spinner,
+  text,
+} from '@clack/prompts';
+import { getJson } from '../lib/core-client.js';
+import {
+  PROVIDER_CREDENTIALS,
+  describeProviderCredential,
+  exportProviderEnvProfile,
+  listProviderCredentialStatus,
+  normalizeProviderId,
+  providerCredentialSpec,
+  removeProviderCredential,
+  resolveProviderCredential,
+  setProviderCredential,
+} from '../lib/provider-credentials.js';
+import { discoverProviderModels } from '../models/discovery.js';
+
+const PROVIDER_ORDER = Object.freeze([
+  'openai',
+  'anthropic',
+  'gemini',
+  'cursor',
+  'xai',
+  'cloudflare',
+  'inneranimalmedia',
+]);
+
+function clean(value) { return value == null ? '' : String(value).trim(); }
+function writeLine(write, value = '') { write(`${value}\n`); }
+
+export function providerChoices(options = {}) {
+  const statuses = new Map(listProviderCredentialStatus(options).map((row) => [row.provider, row]));
+  return PROVIDER_ORDER.map((provider) => {
+    const spec = providerCredentialSpec(provider);
+    const status = statuses.get(provider);
+    return {
+      value: provider,
+      label: spec?.label || provider,
+      hint: status?.configured
+        ? `configured · ${status.source || 'runtime'}`
+        : status?.error ? `blocked · ${status.error}` : spec?.env || '',
+    };
+  });
+}
+
+async function verifyInnerAnimalMedia(credential, options = {}) {
+  if (!credential?.configured || !credential?.value) {
+    return { attempted: false, ok: false, error: credential?.error || 'credential unavailable', models: [] };
+  }
+  try {
+    const loader = options.iamContextLoader || ((token) => getJson('/api/sdk/context', token));
+    const context = await loader(credential.value);
+    return {
+      attempted: true,
+      ok: true,
+      error: null,
+      models: [],
+      identity: {
+        user_id: context?.user_id || null,
+        account_id: context?.account_id || null,
+        email: context?.email || context?.user?.email || null,
+      },
+    };
+  } catch (error) {
+    return { attempted: true, ok: false, error: error?.message || String(error), models: [] };
+  }
+}
+
+export async function verifyProviderCredential(provider, options = {}) {
+  const id = normalizeProviderId(provider);
+  const credential = resolveProviderCredential(id, options);
+  if (id === 'inneranimalmedia') return verifyInnerAnimalMedia(credential, options);
+  if (!credential.configured) {
+    return { attempted: false, ok: false, error: credential.error || 'credential unavailable', models: [] };
+  }
+  return discoverProviderModels(id, credential, { fetchImpl: options.fetchImpl || fetch });
+}
+
+export async function collectProviderStatus(options = {}) {
+  const rows = listProviderCredentialStatus(options);
+  if (options.verify !== true) {
+    return rows.map((row) => ({ ...row, verification: null }));
+  }
+  const verified = await Promise.all(rows.map(async (row) => {
+    if (!row.configured) return { ...row, verification: null };
+    const verification = await verifyProviderCredential(row.provider, options);
+    return {
+      ...row,
+      verification: {
+        attempted: verification.attempted === true,
+        ok: verification.ok === true,
+        error: verification.error || null,
+        model_count: Array.isArray(verification.models) ? verification.models.length : 0,
+      },
+    };
+  }));
+  return verified;
+}
+
+export function renderProviderStatus(rows = []) {
+  const lines = ['', '  Agent Sam · providers', ''];
+  for (const row of rows) {
+    const state = row.configured ? 'configured' : row.error ? `blocked (${row.error})` : 'not configured';
+    let verification = '';
+    if (row.verification) {
+      verification = row.verification.ok
+        ? ` · verified${row.verification.model_count ? ` · ${row.verification.model_count} models` : ''}`
+        : ` · verify failed: ${row.verification.error || 'unknown'}`;
+    }
+    lines.push(`  ${String(row.label || row.provider).padEnd(18)} ${state}${verification}`);
+  }
+  lines.push('');
+  lines.push('  Storage: Encrypted local vault (AES-256-GCM / OS keychain) — no plaintext on disk.');
+  lines.push('  Optional export for non-AgentSam shells: agentsam providers export <provider>');
+  lines.push('');
+  return lines.join('\n');
+}
+
+export async function validateAndSaveProviderCredential(provider, secret, options = {}) {
+  const id = normalizeProviderId(provider);
+  const spec = providerCredentialSpec(id);
+  if (!spec) throw new Error(`unsupported_provider:${id}`);
+  const cleanSecret = clean(secret);
+  if (!cleanSecret) return { attempted: false, ok: false, error: 'Credential is required', models: [] };
+  if (spec.tokenPrefix && !cleanSecret.startsWith(spec.tokenPrefix)) {
+    return { attempted: false, ok: false, error: `Expected ${spec.tokenPrefix}…`, models: [] };
+  }
+
+  const accountId = clean(options.accountId);
+  if (id === 'cloudflare' && !accountId) {
+    return { attempted: false, ok: false, error: 'Cloudflare account ID is required', models: [] };
+  }
+
+  const tempCredential = {
+    provider: id,
+    configured: true,
+    value: cleanSecret,
+    account_id: accountId || null,
+  };
+
+  let verification;
+  if (id === 'inneranimalmedia') {
+    verification = await verifyInnerAnimalMedia(tempCredential, options);
+  } else {
+    verification = await discoverProviderModels(id, tempCredential, { fetchImpl: options.fetchImpl || fetch });
+  }
+
+  if (!verification.ok) {
+    return {
+      attempted: true,
+      ok: false,
+      error: verification.error || 'Provider verification failed',
+      models: [],
+      saved: false,
+    };
+  }
+
+  // Key is verified! Now persist securely to OS store + AES-256-GCM vault + env profile
+  setProviderCredential(id, cleanSecret, { ...options, accountId });
+
+  return {
+    attempted: true,
+    ok: true,
+    error: null,
+    models: verification.models || [],
+    model_count: verification.models?.length || 0,
+    identity: verification.identity || null,
+    saved: true,
+  };
+}
+
+export async function promptAndConfigureProvider(provider, options = {}) {
+  const id = normalizeProviderId(provider);
+  const spec = providerCredentialSpec(id);
+  if (!spec) throw new Error(`unsupported_provider:${id}`);
+  const promptPassword = options.passwordImpl || password;
+  const promptText = options.textImpl || text;
+  const secret = await promptPassword({
+    message: `${spec.label} · ${spec.env}`,
+    mask: '•',
+    validate(value) {
+      const trimmed = clean(value);
+      if (!trimmed) return 'Credential is required';
+      if (spec.tokenPrefix && !trimmed.startsWith(spec.tokenPrefix)) return `Expected ${spec.tokenPrefix}…`;
+    },
+  });
+  if (isCancel(secret)) return null;
+
+  let accountId = '';
+  if (id === 'cloudflare') {
+    const answer = await promptText({
+      message: 'Cloudflare account ID',
+      placeholder: '32-character account ID',
+      validate(value) {
+        const val = clean(value);
+        if (!val) return 'Cloudflare account ID is required';
+        if (!/^[a-f0-9]{32}$/i.test(val)) return 'Expected a 32-character hexadecimal account ID';
+      },
+    });
+    if (isCancel(answer)) return null;
+    accountId = clean(answer);
+  }
+
+  const spin = options.spinnerImpl ? options.spinnerImpl() : spinner();
+  spin.start(`Verifying ${spec.label} API credential`);
+
+  const result = await validateAndSaveProviderCredential(id, String(secret), { ...options, accountId });
+
+  if (!result.ok) {
+    spin.stop(`Verification failed: ${result.error || 'invalid key'} · Key was NOT saved`, 1);
+    return { ...result, saved: false };
+  }
+
+  const count = result.models?.length || 0;
+  const suffix = count ? ` · ${count} models visible` : '';
+  spin.stop(`Verified${suffix} · saved securely to local vault`);
+
+  return { ...result, saved: true };
+}
+
+async function runInteractiveProviders(options = {}) {
+  const promptSelect = options.selectImpl || select;
+
+  intro('Agent Sam provider setup');
+
+  while (true) {
+    const choices = [
+      ...providerChoices(options),
+      { value: '__done__', label: 'Done / Return to shell', hint: 'finish provider setup' },
+    ];
+
+    const choice = await promptSelect({
+      message: 'Select your preferred provider to continue',
+      options: choices,
+    });
+
+    if (isCancel(choice) || choice === '__done__') {
+      break;
+    }
+
+    await promptAndConfigureProvider(choice, options);
+  }
+
+  outro('Provider setup complete');
+  return collectProviderStatus(options);
+}
+
+function parseArgs(argv = []) {
+  const out = { command: 'interactive', provider: '', json: false, verify: false, yes: false, fromEnv: '' };
+  const args = [...argv];
+  if (args[0] && !args[0].startsWith('-')) out.command = args.shift();
+  if (['add', 'set', 'remove', 'verify', 'status', 'export'].includes(out.command) && args[0] && !args[0].startsWith('-')) {
+    out.provider = normalizeProviderId(args.shift());
+  }
+  while (args.length) {
+    const arg = args.shift();
+    if (arg === '--json') out.json = true;
+    else if (arg === '--verify') out.verify = true;
+    else if (arg === '--yes' || arg === '-y') out.yes = true;
+    else if (arg === '--from-env') out.fromEnv = clean(args.shift());
+    else if (arg === '--help' || arg === '-h') out.command = 'help';
+    else throw new Error(`unknown providers option: ${arg}`);
+  }
+  return out;
+}
+
+export async function runProviders(argv = [], options = {}) {
+  const write = options.write || ((value) => process.stdout.write(value));
+  const parsed = parseArgs(argv);
+
+  if (parsed.command === 'help') {
+    write([
+      'agentsam providers',
+      'agentsam providers status [provider] [--verify] [--json]',
+      'agentsam providers add <provider> [--from-env NAME]',
+      'agentsam providers export <provider>',
+      'agentsam providers verify [provider] [--json]',
+      'agentsam providers remove <provider> [--yes]',
+      '',
+      `Providers: ${PROVIDER_ORDER.join(', ')}`,
+      '',
+    ].join('\n'));
+    return;
+  }
+
+  if (parsed.command === 'interactive') {
+    if (options.interactive === false || !(options.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY))) {
+      const rows = await collectProviderStatus({ ...options, verify: false });
+      write(renderProviderStatus(rows));
+      return rows;
+    }
+    const rows = await runInteractiveProviders(options);
+    write(renderProviderStatus(rows));
+    return rows;
+  }
+
+  if (parsed.provider && !providerCredentialSpec(parsed.provider)) throw new Error(`unsupported_provider:${parsed.provider}`);
+
+  if (parsed.command === 'status') {
+    let rows = await collectProviderStatus({ ...options, verify: parsed.verify });
+    if (parsed.provider) rows = rows.filter((row) => row.provider === parsed.provider);
+    if (parsed.json) writeLine(write, JSON.stringify(rows, null, 2));
+    else write(renderProviderStatus(rows));
+    return rows;
+  }
+
+  if (parsed.command === 'verify') {
+    const providers = parsed.provider
+      ? [parsed.provider]
+      : Object.keys(PROVIDER_CREDENTIALS).filter((provider) => describeProviderCredential(provider, options).configured);
+    const results = [];
+    for (const provider of providers) {
+      const result = await verifyProviderCredential(provider, options);
+      results.push({
+        provider,
+        ok: result.ok === true,
+        error: result.error || null,
+        model_count: Array.isArray(result.models) ? result.models.length : 0,
+      });
+    }
+    if (parsed.json) writeLine(write, JSON.stringify(results, null, 2));
+    else {
+      writeLine(write, '');
+      for (const row of results) {
+        writeLine(write, `  ${row.provider.padEnd(18)} ${row.ok ? `verified${row.model_count ? ` · ${row.model_count} models` : ''}` : `failed · ${row.error}`}`);
+      }
+      writeLine(write, '');
+    }
+    return results;
+  }
+
+  if (parsed.command === 'add' || parsed.command === 'set') {
+    if (!parsed.provider) throw new Error('providers add requires a provider');
+    if (parsed.fromEnv) {
+      const value = clean((options.env || process.env)[parsed.fromEnv]);
+      if (!value) throw new Error(`environment credential missing: ${parsed.fromEnv}`);
+      const verified = await validateAndSaveProviderCredential(parsed.provider, value, options);
+      if (!verified.ok) {
+        throw new Error(`Provider verification failed: ${verified.error}. Credential was not saved.`);
+      }
+      writeLine(write, `  ${parsed.provider} verified · ${verified.model_count || 0} models`);
+      return verified;
+    }
+    if (options.interactive === false || !(options.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY))) {
+      throw new Error('providers add requires an interactive terminal or --from-env NAME');
+    }
+    const result = await promptAndConfigureProvider(parsed.provider, options);
+    if (!result) return null;
+    writeLine(write, result.ok ? `  ${parsed.provider} verified` : `  ${parsed.provider} verification failed: ${result.error}`);
+    return result;
+  }
+
+  if (parsed.command === 'export') {
+    if (!parsed.provider) throw new Error('providers export requires a provider');
+    const result = exportProviderEnvProfile(parsed.provider, options);
+    writeLine(write, '');
+    writeLine(write, `  Exported ${parsed.provider} profile: ${result.file} (mode 0600)`);
+    writeLine(write, `  Load into external shell: ${result.source_command}`);
+    writeLine(write, '');
+    return result;
+  }
+
+  if (parsed.command === 'remove') {
+    if (!parsed.provider) throw new Error('providers remove requires a provider');
+    let approved = parsed.yes;
+    if (!approved) {
+      if (options.interactive === false || !(options.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY))) {
+        throw new Error('providers remove requires --yes in non-interactive mode');
+      }
+      const answer = await (options.confirmImpl || confirm)({ message: `Remove ${providerCredentialSpec(parsed.provider)?.label} credential profile from this machine?` });
+      approved = !isCancel(answer) && answer === true;
+    }
+    if (!approved) return { provider: parsed.provider, removed: false };
+    const result = removeProviderCredential(parsed.provider, options);
+    writeLine(write, result.removed ? `  removed ${parsed.provider}` : `  ${parsed.provider} was not configured`);
+    return result;
+  }
+
+  throw new Error(`unknown providers command: ${parsed.command}`);
+}

package/src/commands/resume.js

@@ -24,13 +24,17 @@ export async function runResume(argv = [], options = {}) {
   const write = options.write || ((text) => process.stdout.write(text));
   const json = argv.includes('--json');
   const listOnly = argv.includes('--list');
-  const positional = argv.filter((arg) => !arg.startsWith('-'));
-  const unknown = argv.filter((arg) => arg.startsWith('-') && !['--json', '--list'].includes(arg));
+  const cwdIndex = argv.indexOf('--cwd');
+  if (cwdIndex >= 0 && !argv[cwdIndex + 1]) throw new Error('--cwd requires a project path');
+  const cwd = cwdIndex >= 0 ? path.resolve(argv[cwdIndex + 1]) : path.resolve(options.cwd || process.cwd());
+  const args = argv.filter((_, index) => cwdIndex < 0 || (index !== cwdIndex && index !== cwdIndex + 1));
+  const positional = args.filter((arg) => !arg.startsWith('-'));
+  const unknown = args.filter((arg) => arg.startsWith('-') && !['--json', '--list'].includes(arg));
   if (unknown.length) throw new Error(`unknown resume option: ${unknown[0]}`);
   if (positional.length > 1) throw new Error('agentsam resume accepts at most one session id');
 
   if (listOnly || (json && !positional[0])) {
-    const sessions = listLocalSessions({ home: options.home, limit: 30 });
+    const sessions = listLocalSessions({ home: options.home, cwd, limit: 30 });
     if (json) writeLine(write, JSON.stringify(sessions, null, 2));
     else write(renderSessionList(sessions));
     return sessions;
@@ -38,7 +42,7 @@ export async function runResume(argv = [], options = {}) {
 
   let sessionId = positional[0] || '';
   if (!sessionId) {
-    const sessions = listLocalSessions({ home: options.home, limit: 30 });
+    const sessions = listLocalSessions({ home: options.home, cwd, limit: 30 });
     if (!sessions.length) { write(renderSessionList([])); return null; }
     const interactive = options.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
     if (!interactive) { write(renderSessionList(sessions)); return null; }
@@ -54,7 +58,7 @@ export async function runResume(argv = [], options = {}) {
     sessionId = choice;
   }
 
-  const session = loadLocalSession(sessionId, { home: options.home });
+  const session = loadLocalSession(sessionId, { home: options.home, cwd });
   if (!session) throw new Error(`session_not_found:${sessionId}`);
   if (json) { writeLine(write, JSON.stringify(session, null, 2)); return session; }
 

package/src/commands/runtime-status.js

@@ -0,0 +1,154 @@
+import path from 'node:path';
+import { collectWhoami } from './whoami.js';
+import { collectModelsStatus } from './models.js';
+import { collectCloudflareDeploymentStatus } from '../cloudflare/index.js';
+import { getJson } from '../lib/core-client.js';
+import { collectLocalStatus } from '../lib/local-status.js';
+import { tryReadProjectConfig } from '../lib/project-config.js';
+
+function terminalConnection(row = {}) {
+  return {
+    id: row.id || row.connection_id || null,
+    instance_id: row.instance_id || null,
+    name: row.name || row.connection_name || null,
+    kind: row.kind || row.target_type || null,
+    provider: row.provider || row.compute_provider || null,
+    transport: row.transport || null,
+    transport_provider: row.transport_provider || null,
+    active: row.is_active === true || Number(row.is_active) === 1,
+    default: row.is_default === true || Number(row.is_default) === 1,
+    health: row.last_health_status || row.health_status || 'unknown',
+    last_seen_at: row.last_seen_at || null,
+  };
+}
+
+function terminalInstance(row = {}) {
+  return {
+    id: row.id || null,
+    name: row.name || null,
+    kind: row.kind || null,
+    provider: row.provider || row.compute_provider || null,
+    status: row.status || null,
+    platform: row.platform || null,
+    arch: row.arch || null,
+    active_connection_count: Number(row.active_connection_count || 0),
+    default_connection_id: row.default_connection_id || null,
+    last_seen_at: row.last_seen_at || null,
+  };
+}
+
+export async function collectTerminalAuthorityStatus(options = {}) {
+  if (options.offline === true) return { connected: false, offline: true, instances: [], connections: [], error: null };
+  const loader = options.getJsonImpl || getJson;
+  const requestOptions = {
+    env: options.env || process.env,
+    home: options.home,
+    explicit: options.token || '',
+    fetchImpl: options.fetchImpl,
+  };
+  try {
+    const [instances, connections] = await Promise.all([
+      loader('/api/terminal/instances', requestOptions),
+      loader('/api/terminal/connections', requestOptions),
+    ]);
+    return {
+      connected: true,
+      offline: false,
+      instances: (instances?.instances || []).map(terminalInstance),
+      connections: (connections?.connections || []).map(terminalConnection),
+      error: null,
+    };
+  } catch (error) {
+    return { connected: false, offline: false, instances: [], connections: [], error: error?.message || String(error) };
+  }
+}
+
+export async function collectRuntimeStatus(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const localCollector = options.collectLocal || collectLocalStatus;
+  const identityCollector = options.collectIdentity || collectWhoami;
+  const modelCollector = options.collectModels || collectModelsStatus;
+  const cloudflareCollector = options.collectCloudflare || collectCloudflareDeploymentStatus;
+  const terminalCollector = options.collectTerminal || collectTerminalAuthorityStatus;
+  const offline = options.offline === true;
+
+  const local = await localCollector(cwd);
+  const projectConfig = options.projectConfig || tryReadProjectConfig(local.root);
+  const [identity, models, cloudflare] = await Promise.all([
+    offline
+      ? identityCollector({ ...options, env: options.env || process.env, contextLoader: async () => { throw new Error('offline'); } })
+      : identityCollector(options),
+    modelCollector({ ...options, discoverRemote: !offline && options.discoverModels !== false }),
+    cloudflareCollector({ ...options, root: local.root, projectConfig, offline }),
+  ]);
+  const terminal = identity.authenticated
+    ? identity.terminal?.available === true
+      ? {
+          connected: true,
+          offline: false,
+          instances: identity.terminal.instances.map(terminalInstance),
+          connections: identity.terminal.connections.map(terminalConnection),
+          error: null,
+        }
+      : await terminalCollector({ ...options, offline })
+    : { connected: false, offline, instances: [], connections: [], error: identity.active_auth?.error || 'account_auth_required' };
+
+  const providerModelCount = Object.values(models.providerModels || {}).reduce((total, rows) => total + (Array.isArray(rows) ? rows.length : 0), 0);
+  const activeConnections = terminal.connections.filter((row) => row.active);
+  const modelStatus = {
+    schemaVersion: models.schemaVersion,
+    generatedAt: models.generatedAt,
+    authority: models.authority,
+    providers: models.providers || [],
+    discovery: models.discovery || {},
+    local: {
+      online: models.local?.online === true,
+      endpoint: models.local?.endpoint || null,
+      chatModel: models.local?.chatModel || null,
+      embedModel: models.local?.embedModel || null,
+      models: (models.local?.models || []).map((row) => ({ name: row?.name || null })),
+      error: models.local?.error || null,
+    },
+  };
+  const checks = {
+    account: identity.authenticated === true,
+    models: providerModelCount > 0 || models.local?.online === true,
+    terminal: local.pty?.online === true || activeConnections.length > 0,
+    cloudflare: cloudflare.configured !== true || (
+      cloudflare.connected === true
+      && cloudflare.bindings?.match === true
+      && cloudflare.health?.ok === true
+    ),
+  };
+
+  return {
+    schema_version: 'agentsam-runtime-status-v1',
+    generated_at: new Date().toISOString(),
+    offline,
+    ready: Object.values(checks).every(Boolean),
+    local_ready: local.db?.ready === true || local.db?.exists === false,
+    checks,
+    local,
+    state_storage: {
+      runtime: 'sqlite',
+      project_root: local.root,
+      path: local.db?.path || path.join(local.root, '.agentsam/data/agentsam.sqlite'),
+      migrated: local.db?.ready === true,
+      actor_runtime: 'none',
+      connected_bindings: (cloudflare.bindings?.live || []).map((row) => ({ name: row.name, type: row.type })),
+    },
+    identity,
+    models: modelStatus,
+    model_summary: {
+      verified_provider_models: providerModelCount,
+      local_models: models.local?.models?.length || 0,
+      configured_providers: (models.providers || []).filter((row) => row.configured).map((row) => row.id),
+    },
+    terminal: {
+      ...terminal,
+      local_pty: local.pty,
+      active_connection_count: activeConnections.length,
+    },
+    cloudflare,
+  };
+}