@inneranimalmedia/agentsam-sdk 2.6.2 → 2.6.3

package/src/commands/status.js

@@ -1,13 +1,88 @@
-import { collectLocalStatus } from '../lib/local-status.js';
-import { renderLocalStatus } from '../ui/ansi.js';
+import { collectRuntimeStatus } from './runtime-status.js';
+import { renderRuntimeStatus } from '../ui/ansi.js';
+import { buildStatusActionPlan } from '../status/actions.js';
+import { openExternalUrl } from '../lib/open-url.js';
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+
+function parseStatusArgs(argv = []) {
+  const opts = {
+    json: false,
+    offline: false,
+    discoverModels: true,
+    interactive: false,
+  };
+  for (const arg of argv) {
+    if (arg === '--json') opts.json = true;
+    else if (arg === '--offline') opts.offline = true;
+    else if (arg === '--no-discover') opts.discoverModels = false;
+    else if (arg === '--interactive' || arg === '-i') opts.interactive = true;
+    else throw new Error(`unknown status option: ${arg}`);
+  }
+  return opts;
+}
+
+async function runInteractiveMenu(status, write) {
+  const plan = buildStatusActionPlan(status);
+  write(`\n  ${plan.headline}\n`);
+  if (plan.tips.length) {
+    for (const tip of plan.tips) write(`  • ${tip}\n`);
+    write('\n');
+  }
+  plan.actions.forEach((action, index) => {
+    write(`  ${String(index + 1).padStart(2)}. ${action.label}\n`);
+    write(`      ${action.why}\n`);
+  });
+  write(`   0. Done\n\n`);
+
+  if (!input.isTTY || !output.isTTY) {
+    write('  (non-TTY — pick a command from the list above)\n\n');
+    return;
+  }
+
+  const rl = readline.createInterface({ input, output });
+  try {
+    while (true) {
+      const answer = (await rl.question('  Select [0-n]: ')).trim();
+      if (!answer || answer === '0' || /^q(uit)?$/i.test(answer)) break;
+      const index = Number(answer) - 1;
+      const action = plan.actions[index];
+      if (!action) {
+        write('  Invalid choice.\n');
+        continue;
+      }
+      if (action.id === 'open_health' && /^https?:\/\//i.test(action.command)) {
+        write(`  Opening ${action.command}\n`);
+        openExternalUrl(action.command);
+        continue;
+      }
+      write(`\n  → ${action.command}\n`);
+      write(`    ${action.why}\n\n`);
+      write('  Copy/run that in this project root (awareness stays in-repo).\n');
+      write('  Or press Enter for another action, 0 to exit.\n\n');
+    }
+  } finally {
+    rl.close();
+  }
+}
 
 export async function runStatus(argv = [], opts = {}) {
-  const json = argv.includes('--json');
-  const status = await collectLocalStatus(opts.cwd || process.cwd());
-  if (json) {
-    process.stdout.write(`${JSON.stringify(status, null, 2)}\n`);
+  const parsed = parseStatusArgs(argv);
+  const status = await (opts.collectRuntime || collectRuntimeStatus)({
+    ...opts,
+    cwd: opts.cwd || process.cwd(),
+    offline: parsed.offline,
+    discoverModels: parsed.discoverModels,
+  });
+  const write = opts.write || ((value) => process.stdout.write(value));
+  if (parsed.json) {
+    const plan = buildStatusActionPlan(status);
+    write(`${JSON.stringify({ ...status, next: plan }, null, 2)}\n`);
   } else {
-    process.stdout.write(`\n${renderLocalStatus(status)}\n\n`);
+    write(`\n${renderRuntimeStatus(status)}\n\n`);
+    if (parsed.interactive || opts.interactive) {
+      await runInteractiveMenu(status, write);
+    }
   }
   return status;
 }

package/src/commands/tunnel.js

@@ -1,233 +1,266 @@
 /**
- * agentsam tunnel — expose local PTY (:3099) to the IAM platform.
+ * agentsam tunnel — guided access to Cloudflare's real Wrangler tunnel lifecycle.
  *
- * Default (--quick): cloudflared quick tunnel → register ws_url via SDK API.
- * Named (--named): platform provisions CF named tunnel + DNS; run with --token.
+ * AgentSam does not provision a parallel tunnel system. Wrangler owns tunnel
+ * discovery, creation, inspection, and connector execution.
  */
-import { spawn, spawnSync } from 'node:child_process';
-import { authenticateViaBrowser } from '../lib/auth.js';
-import { postJson } from '../lib/core-client.js';
-import { resolveAccountAuth } from '../lib/account-session.js';
-
-const DEFAULT_PORT = 3099;
-
-function parseArgs(argv) {
-  const opts = {
-    mode: 'quick',
-    port: DEFAULT_PORT,
-    tunnelName: '',
-    hostname: '',
-    zoneId: '',
-    platform: process.platform === 'win32' ? 'windows' : process.platform === 'darwin' ? 'macos' : 'linux',
-    shell: process.platform === 'win32' ? 'powershell' : process.env.SHELL || '/bin/zsh',
-    skipAuth: false,
-  };
-  for (let i = 0; i < argv.length; i += 1) {
-    const a = argv[i];
-    if (a === '--quick') opts.mode = 'quick';
-    else if (a === '--named') opts.mode = 'named';
-    else if (a === '--port') opts.port = Number(argv[++i]) || DEFAULT_PORT;
-    else if (a === '--tunnel-name') opts.tunnelName = argv[++i] || '';
-    else if (a === '--hostname') opts.hostname = argv[++i] || '';
-    else if (a === '--zone-id') opts.zoneId = argv[++i] || '';
-    else if (a === '--platform') opts.platform = argv[++i] || opts.platform;
-    else if (a === '--shell') opts.shell = argv[++i] || opts.shell;
-    else if (a === '--token' && argv[i + 1]) {
-      process.env.AGENTSAM_API_KEY = argv[++i];
-    }
-  }
-  return opts;
-}
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { confirm, isCancel, select, text } from '@clack/prompts';
+import { runWranglerNative } from '../cloudflare/index.js';
 
-function ensureCloudflared() {
-  const which = spawnSync(process.platform === 'win32' ? 'where' : 'which', ['cloudflared'], {
-    encoding: 'utf8',
-  });
-  if (which.status !== 0) {
-    throw new Error(
-      'cloudflared not found. Install: https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/',
-    );
-  }
-}
+const DEFAULT_QUICK_URL = 'http://127.0.0.1:3099';
+const UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
 
-async function resolveToken() {
-  const existing = resolveAccountAuth({ env: process.env });
-  if (existing.value) return existing.value;
-  if (existing.error) throw new Error(existing.error);
-  const session = await authenticateViaBrowser();
-  const token = String(session?.access_token || '').trim();
-  if (!token) throw new Error('IAM auth did not return a browser session credential');
-  return token;
+function stripAnsi(value = '') {
+  return String(value).replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '');
 }
 
-async function assertLocalPty(port) {
-  const url = `http://127.0.0.1:${port}/health`;
-  try {
-    const res = await fetch(url, { signal: AbortSignal.timeout(2500) });
-    if (!res.ok) throw new Error(`health ${res.status}`);
-    return true;
-  } catch {
-    throw new Error(
-      `Local PTY not reachable at ${url}. In another terminal run: npx agentsam start-local`,
-    );
+export function parseWranglerTunnelList(value = '') {
+  const rows = [];
+  for (const rawLine of stripAnsi(value).split(/\r?\n/)) {
+    const match = rawLine.match(UUID_RE);
+    if (!match) continue;
+    const id = match[0];
+    const suffix = rawLine
+      .slice((match.index || 0) + id.length)
+      .replace(/[│|]/g, ' ')
+      .trim();
+    const columns = suffix.split(/\s{2,}/).map((item) => item.trim()).filter(Boolean);
+    rows.push({
+      id,
+      name: columns[0] || id,
+      status: columns[1] || 'unknown',
+      created_at: columns[2] || null,
+      tunnel_type: columns[3] || null,
+    });
   }
+  return rows;
 }
 
-function httpsToWss(url) {
-  const u = String(url || '').trim();
-  if (!u) return '';
-  if (u.startsWith('wss://') || u.startsWith('ws://')) return u.replace(/\/$/, '');
-  if (u.startsWith('https://')) return `wss://${u.slice(8)}`.replace(/\/$/, '');
-  if (u.startsWith('http://')) return `ws://${u.slice(7)}`.replace(/\/$/, '');
-  return `wss://${u.replace(/^\/+/, '')}`.replace(/\/$/, '');
+function npxCommand() {
+  return process.platform === 'win32' ? 'npx.cmd' : 'npx';
 }
 
-/**
- * Parse trycloudflare.com URL from cloudflared stderr/stdout.
- * @param {import('node:child_process').ChildProcessWithoutNullStreams} child
- * @returns {Promise<string>}
- */
-function waitForQuickTunnelUrl(child) {
+function runInteractiveWrangler(args, options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
   return new Promise((resolve, reject) => {
-    let buf = '';
-    const timer = setTimeout(() => {
-      reject(new Error('Timed out waiting for cloudflared quick tunnel URL (60s)'));
-    }, 60_000);
-
-    const onData = (chunk) => {
-      const text = chunk.toString();
-      buf += text;
-      process.stderr.write(text);
-      const m =
-        buf.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/i) ||
-        buf.match(/https:\/\/[a-z0-9.-]+\.cfargotunnel\.com/i);
-      if (m) {
-        clearTimeout(timer);
-        child.stdout?.off('data', onData);
-        child.stderr?.off('data', onData);
-        resolve(m[0]);
-      }
-    };
-
-    child.stdout?.on('data', onData);
-    child.stderr?.on('data', onData);
-    child.on('error', (e) => {
-      clearTimeout(timer);
-      reject(e);
+    const child = spawn(npxCommand(), ['--yes', 'wrangler', 'tunnel', ...args], {
+      cwd,
+      stdio: 'inherit',
+      env: options.env || process.env,
+      shell: process.platform === 'win32',
     });
-    child.on('exit', (code) => {
-      clearTimeout(timer);
-      reject(new Error(`cloudflared exited early (code ${code})`));
+    child.once('error', reject);
+    child.once('exit', (code, signal) => {
+      if (signal) reject(new Error(`wrangler tunnel stopped by ${signal}`));
+      else if (code === 0) resolve(0);
+      else reject(new Error(`wrangler tunnel ${args[0] || ''} exited ${code ?? 1}`));
     });
   });
 }
 
-async function runQuick(opts, token) {
-  await assertLocalPty(opts.port);
-  ensureCloudflared();
-
-  console.log(`
-  Agent Sam — tunnel (quick)
-  Local PTY  http://127.0.0.1:${opts.port}
-  Mode       cloudflared quick tunnel → IAM register-local
-  `);
-
-  const child = spawn(
-    'cloudflared',
-    ['tunnel', '--url', `http://127.0.0.1:${opts.port}`, '--no-autoupdate'],
-    { stdio: ['ignore', 'pipe', 'pipe'] },
+async function readTunnelList(options = {}) {
+  const result = await (options.runWrangler || runWranglerNative)(
+    'tunnel.list',
+    { cwd: options.cwd || process.cwd() },
+    options,
   );
+  const raw = String(result?.stdout || '');
+  return { raw, rows: parseWranglerTunnelList(raw) };
+}
 
-  const publicUrl = await waitForQuickTunnelUrl(child);
-  const wsUrl = httpsToWss(publicUrl);
-  console.log(`\n  ✓ Public URL  ${publicUrl}`);
-  console.log(`  ✓ Registering  ${wsUrl}\n`);
-
-  const registered = await postJson(
-    '/api/sdk/terminal/register-local',
-    {
-      ws_url: wsUrl,
-      platform: opts.platform,
-      shell: opts.shell,
-    },
-    token,
+async function printTunnelInfo(tunnel, options = {}) {
+  const write = options.write || ((value) => process.stdout.write(value));
+  const result = await (options.runWrangler || runWranglerNative)(
+    'tunnel.info',
+    { cwd: options.cwd || process.cwd(), tunnel },
+    options,
   );
+  write(String(result?.stdout || '').trimEnd() + '\n');
+  return result;
+}
 
-  console.log(`  ✓ IAM local lane active`);
-  if (registered?.connection?.id) {
-    console.log(`  ✓ connection   ${registered.connection.id}`);
-  }
-  console.log(`
-  Keep this process running. In the dashboard: Terminal → Local.
+async function chooseExistingTunnel(options = {}) {
+  const { raw, rows } = await readTunnelList(options);
+  const write = options.write || ((value) => process.stdout.write(value));
 
-  Ctrl+C stops the tunnel.
-  `);
+  if (!rows.length) {
+    if (raw.trim()) write(raw.endsWith('\n') ? raw : raw + '\n');
+    return null;
+  }
 
-  await new Promise((resolve) => {
-    child.on('exit', resolve);
-    process.on('SIGINT', () => {
-      child.kill('SIGINT');
-    });
-    process.on('SIGTERM', () => {
-      child.kill('SIGTERM');
-    });
+  const choice = await select({
+    message: 'Cloudflare Tunnel',
+    options: [
+      ...rows.map((row) => ({
+        value: row.id,
+        label: row.name,
+        hint: `${row.status} · ${row.id.slice(0, 8)}`,
+      })),
+      { value: '__raw__', label: 'Show Wrangler tunnel list', hint: 'print Cloudflare CLI output' },
+      { value: '__create__', label: 'Create a new tunnel', hint: 'Wrangler-managed remote tunnel' },
+      { value: '__quick__', label: 'Quick tunnel', hint: 'temporary trycloudflare.com URL' },
+      { value: '__back__', label: 'Back' },
+    ],
   });
+
+  if (isCancel(choice) || choice === '__back__') return null;
+  if (choice === '__raw__') {
+    write(raw.endsWith('\n') ? raw : raw + '\n');
+    return null;
+  }
+  if (choice === '__create__' || choice === '__quick__') return { action: choice.slice(2, -2) };
+  return rows.find((row) => row.id === choice) || null;
 }
 
-async function runNamed(opts, token) {
-  if (!opts.tunnelName || !opts.hostname || !opts.zoneId) {
-    throw new Error(
-      'Named mode requires --tunnel-name, --hostname, and --zone-id (from your CF zone).',
-    );
-  }
-  await assertLocalPty(opts.port);
-  ensureCloudflared();
-
-  console.log(`
-  Agent Sam — tunnel (named)
-  Provisioning Cloudflare tunnel ${opts.tunnelName} → ${opts.hostname}
-  `);
-
-  const provisioned = await postJson(
-    '/api/sdk/terminal/tunnel/provision',
-    {
-      tunnel_name: opts.tunnelName,
-      hostname: opts.hostname,
-      zone_id: opts.zoneId,
-      port: opts.port,
-      platform: opts.platform,
-      shell: opts.shell,
-    },
-    token,
-  );
+async function guidedTunnel(options = {}) {
+  const interactive = options.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const write = options.write || ((value) => process.stdout.write(value));
 
-  const runToken = String(provisioned?.run_token || '').trim();
-  if (!runToken) throw new Error('Platform did not return a cloudflared run_token');
+  if (!interactive) {
+    const { raw } = await readTunnelList(options);
+    write(raw.endsWith('\n') ? raw : raw + '\n');
+    return;
+  }
 
-  console.log(`  ✓ ws_url       ${provisioned.ws_url || `wss://${opts.hostname}`}`);
-  console.log(`  ✓ Starting     cloudflared tunnel run --token …\n`);
+  const selected = await chooseExistingTunnel(options);
+  if (!selected) return;
 
-  const child = spawn('cloudflared', ['tunnel', 'run', '--token', runToken, '--no-autoupdate'], {
-    stdio: 'inherit',
+  if (selected.action === 'create') {
+    const name = await text({
+      message: 'New Cloudflare Tunnel name',
+      placeholder: 'my-machine',
+      validate(value) {
+        if (!String(value || '').trim()) return 'Tunnel name is required';
+      },
+    });
+    if (isCancel(name)) return;
+    const approved = await confirm({
+      message: `Create Cloudflare Tunnel "${String(name).trim()}" in your account?`,
+      initialValue: false,
+    });
+    if (isCancel(approved) || approved !== true) return;
+    await runInteractiveWrangler(['create', String(name).trim()], options);
+    return;
+  }
+
+  if (selected.action === 'quick') {
+    const url = await text({
+      message: 'Local URL to expose temporarily',
+      defaultValue: DEFAULT_QUICK_URL,
+      placeholder: DEFAULT_QUICK_URL,
+    });
+    if (isCancel(url)) return;
+    await runInteractiveWrangler(['quick-start', String(url || DEFAULT_QUICK_URL).trim()], options);
+    return;
+  }
+
+  const action = await select({
+    message: `${selected.name} · ${selected.status}`,
+    options: [
+      { value: 'info', label: 'Inspect tunnel', hint: 'wrangler tunnel info' },
+      {
+        value: 'run',
+        label: 'Run connector on this machine',
+        hint: 'wrangler tunnel run · persistent until Ctrl+C',
+      },
+      { value: 'back', label: 'Back' },
+    ],
   });
+  if (isCancel(action) || action === 'back') return;
+  if (action === 'info') {
+    await printTunnelInfo(selected.id, options);
+    return;
+  }
 
-  await new Promise((resolve, reject) => {
-    child.on('error', reject);
-    child.on('exit', resolve);
-    process.on('SIGINT', () => child.kill('SIGINT'));
+  const approved = await confirm({
+    message: `Run ${selected.name} on this machine? This starts/adds a live connector until Ctrl+C.`,
+    initialValue: false,
   });
+  if (isCancel(approved) || approved !== true) return;
+  await runInteractiveWrangler(['run', selected.id], options);
 }
 
-/**
- * @param {string[]} [argv]
- */
-export async function runTunnel(argv = []) {
-  const opts = parseArgs(argv);
-  const token = await resolveToken();
+const HELP = `Agent Sam · Cloudflare Tunnel
+
+  agentsam tunnel
+      Guided picker over your real Cloudflare tunnels.
+
+  agentsam tunnel list
+      Run Wrangler's tunnel list.
+
+  agentsam tunnel info <name-or-id>
+      Inspect one tunnel through Wrangler.
+
+  agentsam tunnel run <name-or-id>
+      Start that tunnel's connector on this machine. Ctrl+C stops it.
+
+  agentsam tunnel create <name>
+      Create a remotely managed Cloudflare Tunnel through Wrangler.
+
+  agentsam tunnel quick-start [url]
+      Start a temporary Quick Tunnel. Default: ${DEFAULT_QUICK_URL}
+
+AgentSam delegates tunnel lifecycle to Wrangler; it does not mint a parallel
+named-tunnel system or copy tunnel credentials into project configuration.
+`;
+
+export async function runTunnel(argv = [], options = {}) {
+  const args = [...argv];
+  const write = options.write || ((value) => process.stdout.write(value));
+  const subcommand = args[0] || '';
+
+  if (subcommand === '--help' || subcommand === '-h' || subcommand === 'help') {
+    write(HELP);
+    return;
+  }
+
+  // Compatibility: old quick mode now delegates to Wrangler Quick Tunnel.
+  if (subcommand === '--quick') {
+    await runInteractiveWrangler(['quick-start', DEFAULT_QUICK_URL], options);
+    return;
+  }
+  if (subcommand === '--named') {
+    throw new Error('legacy --named provisioning was removed; run `agentsam tunnel` and select an existing Cloudflare Tunnel, or use `agentsam tunnel run <name-or-id>`');
+  }
+
+  if (!subcommand) {
+    await guidedTunnel(options);
+    return;
+  }
 
-  if (opts.mode === 'named') {
-    await runNamed(opts, token);
-  } else {
-    await runQuick(opts, token);
+  if (subcommand === 'list') {
+    const { raw } = await readTunnelList(options);
+    write(raw.endsWith('\n') ? raw : raw + '\n');
+    return;
   }
+
+  if (subcommand === 'info') {
+    const tunnel = String(args[1] || '').trim();
+    if (!tunnel) throw new Error('Usage: agentsam tunnel info <name-or-id>');
+    await printTunnelInfo(tunnel, options);
+    return;
+  }
+
+  if (subcommand === 'run') {
+    const tunnel = String(args[1] || '').trim();
+    if (!tunnel) throw new Error('Usage: agentsam tunnel run <name-or-id>');
+    await runInteractiveWrangler(['run', tunnel], options);
+    return;
+  }
+
+  if (subcommand === 'create') {
+    const name = String(args[1] || '').trim();
+    if (!name) throw new Error('Usage: agentsam tunnel create <name>');
+    await runInteractiveWrangler(['create', name], options);
+    return;
+  }
+
+  if (subcommand === 'quick-start') {
+    await runInteractiveWrangler(['quick-start', String(args[1] || DEFAULT_QUICK_URL)], options);
+    return;
+  }
+
+  throw new Error(`unknown tunnel option: ${subcommand}\n\n${HELP}`);
 }