@inneranimalmedia/agentsam-sdk 2.5.0 → 2.6.0

package/src/commands/preferences.js

@@ -1,8 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { cancel, intro, isCancel, outro, select, text } from '@clack/prompts';
+import { cancel, confirm, intro, isCancel, outro, select, text } from '@clack/prompts';
 import { collectModelsStatus } from './models.js';
+import { getModelRecord } from '../models/index.js';
 import { detectCliProject, readCliPreferences, writeCliPreferences } from '../lib/cli-preferences.js';
 
 function stopIfCancelled(value) {
@@ -22,81 +23,122 @@ export function availableShells(env = process.env) {
   const values = [];
   const detected = path.basename(env.SHELL || env.ComSpec || '').trim();
   if (detected) values.push(detected);
-  for (const shell of ['zsh', 'bash', 'fish', 'pwsh']) {
-    if (!values.includes(shell) && commandExists(shell)) values.push(shell);
-  }
+  for (const shell of ['zsh', 'bash', 'fish', 'pwsh']) if (!values.includes(shell) && commandExists(shell)) values.push(shell);
   return values.length ? values : ['shell'];
 }
 
-function modelOptions(status) {
-  const options = [{ value: 'auto', label: 'Automatic', hint: 'connected host/runtime decides' }];
+export function modelOptions(status) {
+  const options = [{ value: 'auto', label: 'Automatic', hint: 'runtime chooses; exact economics unavailable until resolved' }];
+  for (const model of status.availableModels || []) {
+    options.push({ value: model.model_key, label: model.label, hint: `${model.provider_model_id} · provider verified` });
+  }
   if (status.local?.online) {
-    for (const row of status.local.models || []) {
-      if (row?.name) options.push({ value: `ollama:${row.name}`, label: `Ollama · ${row.name}`, hint: 'local' });
-    }
+    for (const row of status.local.models || []) if (row?.name) options.push({ value: `ollama:${row.name}`, label: `Ollama · ${row.name}`, hint: 'local' });
   }
   for (const provider of status.providers || []) {
-    if (provider.configured) options.push({ value: `${provider.id}:auto`, label: provider.label, hint: 'provider configured' });
+    if (provider.configured && !options.some((row) => row.value.startsWith(`${provider.id}:`) && row.value !== `${provider.id}:auto`)) {
+      options.push({ value: `${provider.id}:auto`, label: `${provider.label} · automatic`, hint: 'credential proven; exact model not verified' });
+    }
   }
   return options;
 }
 
-export async function configureCliPreferences({ cwd = process.cwd(), firstRun = false } = {}) {
+function reasoningOptions(modelPreference) {
+  const record = getModelRecord(modelPreference);
+  if (!record) return [{ value: 'auto', label: 'Automatic', hint: 'runtime/provider default' }];
+  return record.reasoning_efforts.map((value) => ({
+    value,
+    label: value === 'xhigh' ? 'Extra high' : value === 'max' ? 'Max' : value[0].toUpperCase() + value.slice(1),
+    hint: value === 'low' ? 'lighter reasoning' : value === 'max' ? 'highest supported reasoning depth' : undefined,
+  }));
+}
+
+function serviceTierOptions(modelPreference) {
+  const record = getModelRecord(modelPreference);
+  if (!record) return [{ value: 'default', label: 'Standard', hint: 'default provider processing' }];
+  return record.service_tiers.map((value) => {
+    if (value === 'fast') return { value, label: 'Fast', hint: 'lower latency · 2× applicable token rates for Astra' };
+    if (value === 'flex') return { value, label: 'Flex', hint: 'slower / capacity-sensitive · 50% of Standard for Astra' };
+    return { value, label: 'Standard', hint: 'standard pricing and latency' };
+  });
+}
+
+async function promptModelPreferences(identity, existing, options = {}) {
+  let status = { providers: [], availableModels: [], local: { online: false, models: [] } };
+  try { status = await collectModelsStatus(options.modelStatusOptions || {}); } catch { /* inventory remains best-effort */ }
+  const models = modelOptions(status);
+  const initialModel = models.some((row) => row.value === existing.modelPreference) ? existing.modelPreference : 'auto';
+  const modelPreference = stopIfCancelled(await select({ message: 'Model', initialValue: initialModel, options: models }));
+
+  const reasoning = reasoningOptions(modelPreference);
+  const initialReasoning = reasoning.some((row) => row.value === existing.reasoningEffort) ? existing.reasoningEffort : reasoning[0].value;
+  const reasoningEffort = stopIfCancelled(await select({ message: 'Reasoning level', initialValue: initialReasoning, options: reasoning }));
+
+  const tiers = serviceTierOptions(modelPreference);
+  const initialTier = tiers.some((row) => row.value === existing.serviceTier) ? existing.serviceTier : tiers[0].value;
+  const serviceTier = stopIfCancelled(await select({ message: 'Processing', initialValue: initialTier, options: tiers }));
+
+  return { modelPreference, reasoningEffort, serviceTier };
+}
+
+export async function configureCliPreferences({ cwd = process.cwd(), firstRun = false, section = 'all', modelStatusOptions } = {}) {
   let identity = detectCliProject(cwd);
   const existing = readCliPreferences(identity.root) || {};
-  intro(firstRun ? 'Welcome to Agent Sam' : 'Agent Sam settings');
+  intro(firstRun ? `You are in ${identity.root}` : section === 'model' ? 'Agent Sam model' : 'Agent Sam settings');
 
-  const projectChoice = stopIfCancelled(await select({
-    message: 'Where should Agent Sam work?',
-    initialValue: 'current',
-    options: [
-      { value: 'current', label: `This project · ${identity.project}`, hint: identity.root },
-      { value: 'other', label: 'Choose another folder' },
-    ],
-  }));
-
-  if (projectChoice === 'other') {
-    const folder = stopIfCancelled(await text({
-      message: 'Project folder',
-      placeholder: identity.root,
-      defaultValue: identity.root,
-      validate(value) {
-        const resolved = path.resolve(String(value || ''));
-        if (!fs.existsSync(resolved)) return 'Folder does not exist';
-        if (!fs.statSync(resolved).isDirectory()) return 'Path is not a directory';
-      },
+  let trustedDirectory = existing.trustedDirectory === true;
+  if (firstRun && !trustedDirectory) {
+    trustedDirectory = stopIfCancelled(await confirm({
+      message: 'Do you trust the contents of this directory? Project-local instructions, hooks, and execution policy may load.',
+      initialValue: false,
     }));
-    identity = detectCliProject(path.resolve(String(folder)));
+    if (!trustedDirectory) {
+      cancel('Directory not trusted. Agent Sam did not load project-local configuration.');
+      const error = new Error('directory_not_trusted');
+      error.code = 'AGENTSAM_SETUP_CANCELLED';
+      throw error;
+    }
   }
 
-  const runtime = stopIfCancelled(await select({
-    message: 'Runtime',
-    initialValue: existing.runtime || 'local',
-    options: [
-      { value: 'local', label: 'Local machine', hint: 'real shell + filesystem' },
-      { value: 'remote', label: 'Remote', hint: 'connected remote runtime' },
-      { value: 'sandbox', label: 'Sandbox', hint: 'isolated disposable runtime' },
-    ],
-  }));
-
-  const shells = availableShells();
-  const terminal = stopIfCancelled(await select({
-    message: 'Terminal',
-    initialValue: existing.terminal && shells.includes(existing.terminal) ? existing.terminal : shells[0],
-    options: shells.map((shell) => ({ value: shell, label: shell, hint: shell === shells[0] ? 'detected/default' : undefined })),
-  }));
-
-  let status = { providers: [], local: { online: false, models: [] } };
-  try { status = await collectModelsStatus(); } catch { /* inventory is best-effort */ }
-  const models = modelOptions(status);
-  const initialModel = models.some((row) => row.value === existing.modelPreference) ? existing.modelPreference : 'auto';
-  const modelPreference = stopIfCancelled(await select({
-    message: 'Model preference',
-    initialValue: initialModel,
-    options: models,
-  }));
+  let runtime = existing.runtime || 'local';
+  let terminal = existing.terminal || availableShells()[0];
+  if (!firstRun && section === 'all') {
+    const projectChoice = stopIfCancelled(await select({
+      message: 'Where should Agent Sam work?',
+      initialValue: 'current',
+      options: [
+        { value: 'current', label: `This project · ${identity.project}`, hint: identity.root },
+        { value: 'other', label: 'Choose another folder' },
+      ],
+    }));
+    if (projectChoice === 'other') {
+      const folder = stopIfCancelled(await text({
+        message: 'Project folder', placeholder: identity.root, defaultValue: identity.root,
+        validate(value) {
+          const resolved = path.resolve(String(value || ''));
+          if (!fs.existsSync(resolved)) return 'Folder does not exist';
+          if (!fs.statSync(resolved).isDirectory()) return 'Path is not a directory';
+        },
+      }));
+      identity = detectCliProject(path.resolve(String(folder)));
+    }
+    runtime = stopIfCancelled(await select({
+      message: 'Runtime', initialValue: runtime,
+      options: [
+        { value: 'local', label: 'Local machine', hint: 'real shell + filesystem' },
+        { value: 'remote', label: 'Remote', hint: 'connected remote runtime' },
+        { value: 'sandbox', label: 'Sandbox', hint: 'isolated disposable runtime' },
+      ],
+    }));
+    const shells = availableShells();
+    terminal = stopIfCancelled(await select({
+      message: 'Terminal', initialValue: terminal && shells.includes(terminal) ? terminal : shells[0],
+      options: shells.map((shell) => ({ value: shell, label: shell, hint: shell === shells[0] ? 'detected/default' : undefined })),
+    }));
+  }
 
-  const preferences = writeCliPreferences(identity.root, { runtime, terminal, modelPreference });
+  const model = await promptModelPreferences(identity, existing, { modelStatusOptions });
+  const preferences = writeCliPreferences(identity.root, { trustedDirectory, runtime, terminal, ...model });
   outro(`Ready · ${identity.project}`);
   return { identity, preferences };
 }

package/src/commands/resume.js

@@ -0,0 +1,67 @@
+import path from 'node:path';
+import { isCancel, select } from '@clack/prompts';
+import { listLocalSessions, loadLocalSession } from '../lib/local-sessions.js';
+import { runShell } from './shell.js';
+
+function writeLine(write, value = '') { write(`${value}\n`); }
+function formatWhen(value) {
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? String(value || '') : date.toLocaleString();
+}
+
+export function renderSessionList(sessions = []) {
+  if (!sessions.length) return '\n  No resumable Agent Sam sessions found.\n';
+  const lines = ['', '  Agent Sam · sessions', ''];
+  for (const row of sessions) {
+    lines.push(`  ${row.id}  ${row.title}`);
+    lines.push(`    ${formatWhen(row.updated_at)} · ${row.model_key || 'no model'} · ${row.cwd}`);
+  }
+  lines.push('');
+  return lines.join('\n');
+}
+
+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));
+  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 });
+    if (json) writeLine(write, JSON.stringify(sessions, null, 2));
+    else write(renderSessionList(sessions));
+    return sessions;
+  }
+
+  let sessionId = positional[0] || '';
+  if (!sessionId) {
+    const sessions = listLocalSessions({ home: options.home, 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; }
+    const choice = await select({
+      message: 'Resume Agent Sam session',
+      options: sessions.map((row) => ({
+        value: row.id,
+        label: row.title,
+        hint: `${path.basename(row.cwd)} · ${formatWhen(row.updated_at)}`,
+      })),
+    });
+    if (isCancel(choice)) return null;
+    sessionId = choice;
+  }
+
+  const session = loadLocalSession(sessionId, { home: options.home });
+  if (!session) throw new Error(`session_not_found:${sessionId}`);
+  if (json) { writeLine(write, JSON.stringify(session, null, 2)); return session; }
+
+  writeLine(write, `\n  Resuming ${session.id}`);
+  writeLine(write, `  ${session.title}`);
+  writeLine(write, `  ${session.cwd}\n`);
+  const runner = options.runShellImpl || runShell;
+  await runner([], { cwd: session.cwd, intro: 'quiet', session, home: options.home });
+  return session;
+}

package/src/commands/security.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { scanProjectSecurity, reportExitCode, repairProject, formatSecurityReport } from '../security/index.js';
 import { runProcess } from '../security/process.js';
+import { diagnosticFromError, renderDiagnosticError } from '../errors/index.js';
 
 const help = [
   'Agent Sam · security',
@@ -63,9 +64,10 @@ export async function runSecurity(argv) {
     }
     process.stdout.write(options.json ? JSON.stringify(report, null, 2) + '\n' : formatSecurityReport(report, { color: Boolean(process.stdout.isTTY && !process.env.NO_COLOR) }));
     process.exitCode = reportExitCode(report);
-  } catch {
-    const report = { schema_version: 1, ok: false, complete: false, status: 'error', error: 'Security operation failed. Check command options, manifest/log validity, network access, and Git prerequisites. Use --help.' };
-    process.stdout.write(options.json ? JSON.stringify(report) + '\n' : report.error + '\n');
+  } catch (error) {
+    const diagnostic = diagnosticFromError(error, { source: 'security', kind: 'security_operation_error' });
+    const report = { schema_version: 1, ok: false, complete: false, status: 'error', error: diagnostic };
+    process.stdout.write(options.json ? JSON.stringify(report) + '\n' : `${renderDiagnosticError(error)}\n`);
     process.exitCode = 2;
   }
 }