@inneranimalmedia/agentsam-sdk 2.6.2 → 2.6.3

package/src/commands/providers.js

@@ -6,6 +6,7 @@ import {
   multiselect,
   outro,
   password,
+  select,
   spinner,
   text,
 } from '@clack/prompts';
@@ -13,6 +14,7 @@ import { getJson } from '../lib/core-client.js';
 import {
   PROVIDER_CREDENTIALS,
   describeProviderCredential,
+  exportProviderEnvProfile,
   listProviderCredentialStatus,
   normalizeProviderId,
   providerCredentialSpec,
@@ -117,15 +119,69 @@ export function renderProviderStatus(rows = []) {
     lines.push(`  ${String(row.label || row.provider).padEnd(18)} ${state}${verification}`);
   }
   lines.push('');
-  lines.push('  Profiles: ~/.agentsam/env.d/<provider>.env · mode 0600');
-  lines.push('  Load one or many: source ~/.agentsam/load-agent-env.sh openai gemini cursor');
+  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');
 }
 
-async function promptProviderCredential(provider, options = {}) {
-  const spec = providerCredentialSpec(provider);
-  if (!spec) throw new Error(`unsupported_provider:${provider}`);
+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({
@@ -140,50 +196,60 @@ async function promptProviderCredential(provider, options = {}) {
   if (isCancel(secret)) return null;
 
   let accountId = '';
-  if (provider === 'cloudflare') {
+  if (id === 'cloudflare') {
     const answer = await promptText({
       message: 'Cloudflare account ID',
       placeholder: '32-character account ID',
       validate(value) {
-        const id = clean(value);
-        if (!id) return 'Cloudflare account ID is required';
-        if (!/^[a-f0-9]{32}$/i.test(id)) return 'Expected a 32-character hexadecimal account ID';
+        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);
   }
 
-  setProviderCredential(provider, String(secret), { ...options, accountId });
-  return verifyProviderCredential(provider, options);
+  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 promptMultiselect = options.multiselectImpl || multiselect;
-  const selected = await promptMultiselect({
-    message: 'Providers to configure',
-    required: false,
-    options: providerChoices(options),
-  });
-  if (isCancel(selected)) {
-    cancel('Provider setup cancelled.');
-    return collectProviderStatus(options);
-  }
-  if (!selected.length) return collectProviderStatus(options);
+  const promptSelect = options.selectImpl || select;
 
   intro('Agent Sam provider setup');
-  const spin = options.spinnerImpl ? options.spinnerImpl() : spinner();
-  for (const provider of selected) {
-    const result = await promptProviderCredential(provider, options);
-    if (!result) continue;
-    spin.start(`Verifying ${providerCredentialSpec(provider)?.label || provider}`);
-    if (result.ok) {
-      const suffix = result.models?.length ? ` · ${result.models.length} models` : '';
-      spin.stop(`Verified${suffix}`);
-    } else {
-      spin.stop(`Saved · verification failed: ${result.error || 'unknown'}`, 1);
+
+  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);
 }
@@ -192,7 +258,7 @@ 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'].includes(out.command) && args[0] && !args[0].startsWith('-')) {
+  if (['add', 'set', 'remove', 'verify', 'status', 'export'].includes(out.command) && args[0] && !args[0].startsWith('-')) {
     out.provider = normalizeProviderId(args.shift());
   }
   while (args.length) {
@@ -216,6 +282,7 @@ export async function runProviders(argv = [], options = {}) {
       '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]',
       '',
@@ -276,15 +343,29 @@ export async function runProviders(argv = [], options = {}) {
     if (parsed.fromEnv) {
       const value = clean((options.env || process.env)[parsed.fromEnv]);
       if (!value) throw new Error(`environment credential missing: ${parsed.fromEnv}`);
-      setProviderCredential(parsed.provider, value, options);
-      return verifyProviderCredential(parsed.provider, options);
+      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 promptProviderCredential(parsed.provider, options);
+    const result = await promptAndConfigureProvider(parsed.provider, options);
     if (!result) return null;
-    writeLine(write, result.ok ? `  ${parsed.provider} verified` : `  ${parsed.provider} saved · verification failed: ${result.error}`);
+    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;
   }
 

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,
+  };
+}