@inneranimalmedia/agentsam-sdk 2.6.3 → 2.6.5

package/src/commands/providers.js

@@ -164,8 +164,13 @@ export async function validateAndSaveProviderCredential(provider, secret, option
     };
   }
 
-  // Key is verified! Now persist securely to OS store + AES-256-GCM vault + env profile
-  setProviderCredential(id, cleanSecret, { ...options, accountId });
+  // Key is verified. Persist securely to the OS store + AES-256-GCM vault.
+  // Plaintext shell profiles remain explicit opt-in only.
+  setProviderCredential(id, cleanSecret, {
+    ...options,
+    accountId,
+    writeEnvProfile: options.writeEnvProfile === true,
+  });
 
   return {
     attempted: true,
@@ -213,7 +218,11 @@ export async function promptAndConfigureProvider(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 });
+  const result = await validateAndSaveProviderCredential(id, String(secret), {
+    ...options,
+    accountId,
+    writeEnvProfile: options.writeEnvProfile === true,
+  });
 
   if (!result.ok) {
     spin.stop(`Verification failed: ${result.error || 'invalid key'} · Key was NOT saved`, 1);
@@ -255,10 +264,19 @@ async function runInteractiveProviders(options = {}) {
 }
 
 function parseArgs(argv = []) {
-  const out = { command: 'interactive', provider: '', json: false, verify: false, yes: false, fromEnv: '' };
+  const out = {
+    command: 'interactive',
+    provider: '',
+    json: false,
+    verify: false,
+    yes: false,
+    fromEnv: '',
+    fromStdin: false,
+    exportProfile: true,
+  };
   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('-')) {
+  if (['add', 'set', 'remove', 'verify', 'status', 'export', 'roll'].includes(out.command) && args[0] && !args[0].startsWith('-')) {
     out.provider = normalizeProviderId(args.shift());
   }
   while (args.length) {
@@ -267,6 +285,9 @@ function parseArgs(argv = []) {
     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 === '--from-stdin') out.fromStdin = true;
+    else if (arg === '--no-export') out.exportProfile = false;
+    else if (arg === '--export') out.exportProfile = true;
     else if (arg === '--help' || arg === '-h') out.command = 'help';
     else throw new Error(`unknown providers option: ${arg}`);
   }
@@ -281,13 +302,17 @@ export async function runProviders(argv = [], options = {}) {
     write([
       'agentsam providers',
       'agentsam providers status [provider] [--verify] [--json]',
-      'agentsam providers add <provider> [--from-env NAME]',
+      'agentsam providers add <provider> [--from-env NAME|--from-stdin] [--no-export]',
+      'agentsam providers roll <provider> [--from-env NAME|--from-stdin]   replace + export env.d',
       'agentsam providers export <provider>',
       'agentsam providers verify [provider] [--json]',
       'agentsam providers remove <provider> [--yes]',
       '',
       `Providers: ${PROVIDER_ORDER.join(', ')}`,
       '',
+      'Boot load: source ~/.agentsam/load-agent-env.sh <provider…>',
+      '           agentsam env boot-line',
+      '',
     ].join('\n'));
     return;
   }
@@ -338,24 +363,47 @@ export async function runProviders(argv = [], options = {}) {
     return results;
   }
 
-  if (parsed.command === 'add' || parsed.command === 'set') {
+  if (parsed.command === 'add' || parsed.command === 'set' || parsed.command === 'roll') {
     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 (parsed.command === 'roll') {
+      removeProviderCredential(parsed.provider, options);
+    }
+    let secretValue = '';
+    if (parsed.fromStdin) {
+      const chunks = [];
+      for await (const chunk of options.stdin || process.stdin) chunks.push(chunk);
+      secretValue = Buffer.concat(chunks.map((c) => (Buffer.isBuffer(c) ? c : Buffer.from(c)))).toString('utf8').trim();
+      if (!secretValue) throw new Error('stdin credential missing');
+    } else if (parsed.fromEnv) {
+      secretValue = clean((options.env || process.env)[parsed.fromEnv]);
+      if (!secretValue) throw new Error(`environment credential missing: ${parsed.fromEnv}`);
+    }
+    if (secretValue) {
+      const verified = await validateAndSaveProviderCredential(parsed.provider, secretValue, {
+        ...options,
+        writeEnvProfile: parsed.exportProfile,
+      });
       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`);
+      writeLine(write, `  ${parsed.provider} verified · saved${parsed.exportProfile ? ' · env.d exported' : ''}`);
+      if (parsed.exportProfile) {
+        writeLine(write, `  source ~/.agentsam/load-agent-env.sh ${parsed.provider}`);
+      }
       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');
+      throw new Error('providers add requires an interactive terminal, --from-env NAME, or --from-stdin');
     }
-    const result = await promptAndConfigureProvider(parsed.provider, options);
+    const result = await promptAndConfigureProvider(parsed.provider, {
+      ...options,
+      writeEnvProfile: parsed.exportProfile,
+    });
     if (!result) return null;
     writeLine(write, result.ok ? `  ${parsed.provider} verified` : `  ${parsed.provider} verification failed: ${result.error}`);
+    if (result.ok && parsed.exportProfile) {
+      writeLine(write, `  source ~/.agentsam/load-agent-env.sh ${parsed.provider}`);
+    }
     return result;
   }
 

package/src/commands/runtime-status.js

@@ -7,33 +7,52 @@ import { collectLocalStatus } from '../lib/local-status.js';
 import { tryReadProjectConfig } from '../lib/project-config.js';
 
 function terminalConnection(row = {}) {
+  const lastSeen = row.last_seen_at ?? null;
+  const id = row.id || row.connection_id || null;
+  const compute = row.compute_provider || row.provider || null;
   return {
-    id: row.id || row.connection_id || null,
+    id,
+    connection_id: id,
     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,
+    provider: compute,
+    compute_provider: compute,
     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,
+    endpoint_url: row.endpoint_url || null,
+    route_hostname: row.route_hostname || null,
+    public_url: row.public_url || row.endpoint_url || null,
+    active: row.is_active === true || Number(row.is_active) === 1 || row.active === true,
+    default: row.is_default === true || Number(row.is_default) === 1 || row.default === true,
+    health: row.last_health_status || row.health_status || row.health || 'unknown',
+    last_seen_at: lastSeen,
+    last_seen_at_iso: row.last_seen_at_iso || (Number.isFinite(Number(lastSeen)) && Number(lastSeen) > 0
+      ? new Date((Number(lastSeen) > 1e12 ? Number(lastSeen) : Number(lastSeen) * 1000)).toISOString()
+      : null),
   };
 }
 
 function terminalInstance(row = {}) {
+  const lastSeen = row.last_seen_at ?? null;
+  const id = row.id || row.instance_id || null;
+  const compute = row.compute_provider || row.provider || null;
   return {
-    id: row.id || null,
+    id,
+    instance_id: id,
     name: row.name || null,
     kind: row.kind || null,
-    provider: row.provider || row.compute_provider || null,
+    provider: compute,
+    compute_provider: compute,
     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,
+    last_seen_at: lastSeen,
+    last_seen_at_iso: row.last_seen_at_iso || (Number.isFinite(Number(lastSeen)) && Number(lastSeen) > 0
+      ? new Date((Number(lastSeen) > 1e12 ? Number(lastSeen) : Number(lastSeen) * 1000)).toISOString()
+      : null),
   };
 }
 

package/src/commands/runtime.js

@@ -0,0 +1,313 @@
+/**
+ * agentsam runtime — local machine runtime (agentsamd) install / doctor / status.
+ * Distinct from agentsam go (cloud service agentsam-go-worker).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawn, execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import {
+  discoverRuntimeFacts,
+  ensureRuntimeStateDir,
+  runtimeStateDir,
+  writeRuntimeInstallReceipt,
+  RUNTIME_SETUP_SCHEMA,
+} from '../lib/setup/runtime.js';
+import {
+  DARWIN_LAUNCH_LABEL,
+  writeLaunchAgent,
+  writeWindowsScheduledTask,
+  startWindowsScheduledTask,
+  stopWindowsScheduledTask,
+  bootstrapDarwinLaunchAgent,
+  unloadDarwinLaunchAgent,
+} from '../lib/setup/runtime-persist.js';
+import { RUNTIME_PROTOCOL_SCHEMA } from '../../packages/runtime-protocol/src/index.js';
+
+const execFileAsync = promisify(execFile);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(__dirname, '../..');
+const GO_RUNTIME_ROOT = path.join(REPO_ROOT, 'apps/agentsam-go-worker/runtime');
+const AGENTSAMD_MAIN = path.join(GO_RUNTIME_ROOT, 'cmd/agentsamd');
+
+function writeLine(write, value = '') {
+  write(`${value}\n`);
+}
+
+function printHelp(write) {
+  writeLine(write, '');
+  writeLine(write, '  Agent Sam · runtime (agentsamd)');
+  writeLine(write, '');
+  writeLine(write, '  agentsam runtime status [--json]');
+  writeLine(write, '  agentsam runtime doctor [--json]');
+  writeLine(write, '  agentsam runtime install [--yes]   build agentsamd + install persistence/bin');
+  writeLine(write, '  agentsam runtime start');
+  writeLine(write, '  agentsam runtime stop');
+  writeLine(write, '  agentsam runtime probe');
+  writeLine(write, '');
+  writeLine(write, '  Persistence: LaunchAgent (Mac) · Scheduled Task (Windows) · spawn+pid (Linux).');
+  writeLine(write, '  Machine daemon ≠ agentsam-go-worker (Cloudflare service).');
+  writeLine(write, '  Setup planner: agentsam setup runtime');
+  writeLine(write, '');
+}
+
+function binDir(home = os.homedir()) {
+  return path.join(home, '.agentsam', 'bin');
+}
+
+function agentsamdPath(home = os.homedir()) {
+  return path.join(binDir(home), process.platform === 'win32' ? 'agentsamd.exe' : 'agentsamd');
+}
+
+function pidPath(home = os.homedir()) {
+  return path.join(runtimeStateDir(home), 'agentsamd.pid');
+}
+
+function listenAddr() {
+  return process.env.AGENTSAMD_LISTEN || '127.0.0.1:18765';
+}
+
+function darwinPlistPath(home) {
+  return path.join(home, 'Library', 'LaunchAgents', `${DARWIN_LAUNCH_LABEL}.plist`);
+}
+
+async function buildAgentsamd(write) {
+  if (!fs.existsSync(path.join(AGENTSAMD_MAIN, 'main.go'))) {
+    throw new Error(`agentsamd source missing at ${AGENTSAMD_MAIN}`);
+  }
+  const out = agentsamdPath();
+  fs.mkdirSync(path.dirname(out), { recursive: true });
+  writeLine(write, `  Building agentsamd → ${out}`);
+  await execFileAsync('go', ['build', '-o', out, './cmd/agentsamd'], {
+    cwd: GO_RUNTIME_ROOT,
+    env: { ...process.env, CGO_ENABLED: '0' },
+    timeout: 120000,
+  });
+  try { fs.chmodSync(out, 0o755); } catch { /* ignore */ }
+  return out;
+}
+
+async function probeAgentsamd() {
+  const addr = listenAddr();
+  const url = addr.startsWith('http') ? `${addr}/health` : `http://${addr}/health`;
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(3000) });
+    const body = await res.json().catch(() => ({}));
+    return { ok: res.ok, status: res.status, body, url };
+  } catch (err) {
+    return { ok: false, error: String(err?.message || err), url };
+  }
+}
+
+async function startAgentsamd(home, write) {
+  const bin = agentsamdPath(home);
+  if (!fs.existsSync(bin)) throw new Error('agentsamd_not_installed');
+
+  if (process.platform === 'win32') {
+    try {
+      await startWindowsScheduledTask();
+      writeLine(write, `  Started Scheduled Task · ${listenAddr()}`);
+      await new Promise((r) => setTimeout(r, 600));
+      return probeAgentsamd();
+    } catch (err) {
+      writeLine(write, `  ○ Scheduled Task start failed (${err.message || err}); falling back to spawn`);
+    }
+  }
+
+  if (process.platform === 'darwin') {
+    const plist = darwinPlistPath(home);
+    if (fs.existsSync(plist)) {
+      const boot = await bootstrapDarwinLaunchAgent(plist);
+      if (boot.ok) {
+        writeLine(write, `  Loaded LaunchAgent ${DARWIN_LAUNCH_LABEL}`);
+        await new Promise((r) => setTimeout(r, 400));
+        return probeAgentsamd();
+      }
+    }
+  }
+
+  const child = spawn(bin, ['--listen', listenAddr()], {
+    detached: true,
+    stdio: 'ignore',
+    env: { ...process.env, AGENTSAMD_ROLE: 'machine' },
+    windowsHide: true,
+  });
+  child.unref();
+  ensureRuntimeStateDir(home);
+  fs.writeFileSync(pidPath(home), String(child.pid));
+  writeLine(write, `  Started agentsamd pid ${child.pid} · ${listenAddr()}`);
+  await new Promise((r) => setTimeout(r, 400));
+  return probeAgentsamd();
+}
+
+async function stopAgentsamd(home, write) {
+  if (process.platform === 'win32') {
+    try {
+      await stopWindowsScheduledTask();
+      writeLine(write, '  Ended Windows Scheduled Task');
+    } catch (err) {
+      writeLine(write, `  ○ Scheduled Task end: ${err.message || err}`);
+    }
+  }
+
+  if (process.platform === 'darwin') {
+    const plist = darwinPlistPath(home);
+    if (fs.existsSync(plist)) {
+      await unloadDarwinLaunchAgent(plist);
+      writeLine(write, `  Unloaded LaunchAgent ${DARWIN_LAUNCH_LABEL}`);
+    }
+  }
+
+  const file = pidPath(home);
+  if (!fs.existsSync(file)) {
+    if (process.platform !== 'win32' && process.platform !== 'darwin') {
+      writeLine(write, '  No pid file — nothing to stop');
+    }
+    return { ok: true, stopped: false };
+  }
+  const pid = Number(fs.readFileSync(file, 'utf8').trim());
+  try {
+    if (Number.isFinite(pid) && pid > 0) process.kill(pid, 'SIGTERM');
+  } catch {
+    /* already dead */
+  }
+  try { fs.unlinkSync(file); } catch { /* ignore */ }
+  writeLine(write, `  Stopped agentsamd${pid ? ` pid ${pid}` : ''}`);
+  return { ok: true, stopped: true, pid };
+}
+
+export async function runRuntime(argv = [], options = {}) {
+  const write = options.write || ((s) => process.stdout.write(s));
+  const env = options.env || process.env;
+  const home = options.home || os.homedir();
+  const json = argv.includes('--json');
+  const yes = argv.includes('--yes') || argv.includes('-y');
+  const args = argv.filter((a) => !['--json', '--yes', '-y', 'help', '--help', '-h'].includes(a));
+  const sub = args[0] || 'status';
+
+  if (argv.includes('help') || argv.includes('--help') || argv.includes('-h')) {
+    printHelp(write);
+    return 0;
+  }
+
+  if (sub === 'status' || sub === 'doctor') {
+    const facts = await discoverRuntimeFacts({ env, home });
+    const probe = await probeAgentsamd();
+    const out = {
+      schema: RUNTIME_SETUP_SCHEMA,
+      protocol: RUNTIME_PROTOCOL_SCHEMA,
+      role: 'machine_daemon',
+      product: 'agentsamd',
+      distinct_from: 'agentsam-go-worker',
+      facts,
+      listen: listenAddr(),
+      probe,
+    };
+    if (json) {
+      write(`${JSON.stringify(out, null, 2)}\n`);
+    } else {
+      writeLine(write, '');
+      writeLine(write, '  Agent Sam · runtime');
+      writeLine(write, `  Protocol   ${RUNTIME_PROTOCOL_SCHEMA}`);
+      writeLine(write, `  Binary     ${facts.agentsamd.installed ? facts.agentsamd.binary : '(not installed)'}`);
+      writeLine(write, `  Listen     ${listenAddr()}`);
+      writeLine(write, `  Health     ${probe.ok ? '✓' : '○'} ${probe.ok ? probe.url : (probe.error || 'unreachable')}`);
+      if (probe.ok && probe.body?.implementation) {
+        writeLine(write, `  Impl       ${probe.body.implementation}`);
+      }
+      writeLine(write, '');
+      writeLine(write, '  Next');
+      writeLine(write, '    agentsam setup runtime');
+      writeLine(write, '    agentsam runtime install --yes');
+      writeLine(write, '');
+    }
+    return probe.ok || facts.agentsamd.installed ? 0 : (sub === 'doctor' ? 2 : 0);
+  }
+
+  if (sub === 'probe') {
+    const probe = await probeAgentsamd();
+    if (json) write(`${JSON.stringify(probe, null, 2)}\n`);
+    else writeLine(write, probe.ok ? `  ✓ ${probe.url}` : `  ✕ ${probe.error || probe.url}`);
+    return probe.ok ? 0 : 2;
+  }
+
+  if (sub === 'stop') {
+    const result = await stopAgentsamd(home, write);
+    if (json) write(`${JSON.stringify(result, null, 2)}\n`);
+    return 0;
+  }
+
+  if (sub === 'start') {
+    const probe = await startAgentsamd(home, write);
+    if (json) write(`${JSON.stringify(probe, null, 2)}\n`);
+    else writeLine(write, probe.ok ? '  ✓ agentsamd healthy' : `  ✕ probe failed: ${probe.error || probe.status}`);
+    return probe.ok ? 0 : 2;
+  }
+
+  if (sub === 'install') {
+    if (!yes && process.stdin.isTTY) {
+      writeLine(write, '  Pass --yes to build and install agentsamd into ~/.agentsam/bin');
+    }
+    if (!yes && !process.stdin.isTTY) {
+      writeLine(write, '  Non-interactive: pass --yes');
+      return 1;
+    }
+    if (!yes) {
+      writeLine(write, '  Re-run: agentsam runtime install --yes');
+      return 1;
+    }
+    let binary;
+    try {
+      binary = await buildAgentsamd(write);
+    } catch (err) {
+      writeLine(write, `  ✕ build failed: ${err.message || err}`);
+      return 2;
+    }
+
+    const listen = listenAddr();
+    let persistence = writeLaunchAgent(home, binary, listen);
+    if (persistence) {
+      writeLine(write, `  LaunchAgent  ${persistence.plist}`);
+      const boot = await bootstrapDarwinLaunchAgent(persistence.plist);
+      if (!boot.ok && boot.error) writeLine(write, `  ○ launchctl: ${boot.error}`);
+    } else if (process.platform === 'win32') {
+      persistence = await writeWindowsScheduledTask(home, binary, listen);
+      if (persistence?.xmlPath) writeLine(write, `  Task XML    ${persistence.xmlPath}`);
+      if (persistence?.registered) writeLine(write, `  Scheduled   ${persistence.taskName}`);
+      else if (persistence?.error) writeLine(write, `  ○ schtasks: ${persistence.error}`);
+    } else {
+      writeLine(write, '  Persistence  spawn+pid (Linux — no systemd unit in this cut)');
+    }
+
+    const probe = await startAgentsamd(home, write);
+    const receiptPath = writeRuntimeInstallReceipt({
+      profile_id: 'my_computer',
+      product: 'agentsamd',
+      protocol: RUNTIME_PROTOCOL_SCHEMA,
+      runtime_adapter: 'agentsamd',
+      binary,
+      listen,
+      persistence,
+      launch_agent: persistence?.kind === 'launch_agent' ? persistence : null,
+      scheduled_task: persistence?.kind === 'scheduled_task' ? persistence : null,
+      probe,
+      host: {
+        platform: process.platform,
+        arch: process.arch,
+        hostname: os.hostname(),
+      },
+    }, home);
+    writeLine(write, `  Receipt     ${receiptPath}`);
+    writeLine(write, probe.ok ? '  ✓ agentsamd installed and healthy' : '  ○ installed; start/probe manually');
+    if (json) {
+      write(`${JSON.stringify({ binary, persistence, probe, receiptPath }, null, 2)}\n`);
+    }
+    return probe.ok ? 0 : 2;
+  }
+
+  printHelp(write);
+  writeLine(write, `  Unknown subcommand: ${sub}`);
+  return 1;
+}

package/src/commands/rust.js

@@ -0,0 +1,24 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const entry = path.resolve(here, '../../bin/agentsam-rapid-rust');
+
+export async function runRust(argv = [], options = {}) {
+  const node = options.node || process.execPath;
+  const stdio = options.stdio || 'inherit';
+  return await new Promise((resolve, reject) => {
+    const child = spawn(node, [entry, ...argv], { stdio, env: process.env });
+    child.on('error', reject);
+    child.on('exit', (code, signal) => {
+      if (signal) return reject(new Error(`agentsam rust terminated by ${signal}`));
+      if (code && code !== 0) {
+        const error = new Error(`agentsam rust exited with code ${code}`);
+        error.exitCode = code;
+        return reject(error);
+      }
+      resolve(code ?? 0);
+    });
+  });
+}