svamp-cli 0.1.5 → 0.1.7

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { s as startDaemon, b as stopDaemon, d as daemonStatus } from './run-xiJdI9RG.mjs';
+import { s as startDaemon, b as stopDaemon, d as daemonStatus } from './run-aevHxpEl.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -13,6 +13,8 @@ import '@modelcontextprotocol/sdk/server/mcp.js';
 import 'node:http';
 import '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import 'zod';
+import 'node:child_process';
+import '@agentclientprotocol/sdk';
 
 const args = process.argv.slice(2);
 const subcommand = args[0];
@@ -70,16 +72,218 @@ async function main() {
     } else {
       printDaemonHelp();
     }
+  } else if (subcommand === "agent") {
+    await handleAgentCommand();
+  } else if (subcommand === "session") {
+    await handleSessionCommand();
   } else if (subcommand === "--help" || subcommand === "-h" || !subcommand) {
     printHelp();
   } else if (subcommand === "--version" || subcommand === "-v") {
-    console.log("svamp version: 0.1.0");
+    const pkg = await import('./package-DD4JHOe_.mjs').catch(() => ({ default: { version: "unknown" } }));
+    console.log(`svamp version: ${pkg.default.version}`);
   } else {
     console.error(`Unknown command: ${subcommand}`);
     printHelp();
     process.exit(1);
   }
 }
+async function handleAgentCommand() {
+  const agentArgs = args.slice(1);
+  if (agentArgs.length === 0 || agentArgs[0] === "--help" || agentArgs[0] === "-h") {
+    printAgentHelp();
+    return;
+  }
+  if (agentArgs[0] === "list") {
+    const { KNOWN_ACP_AGENTS } = await import('./run-aevHxpEl.mjs').then(function (n) { return n.f; });
+    console.log("Known ACP agents:");
+    for (const [name, config2] of Object.entries(KNOWN_ACP_AGENTS)) {
+      console.log(`  ${name.padEnd(12)} ${config2.command} ${config2.args.join(" ")}`);
+    }
+    console.log('\nUse "svamp agent <name>" to start an interactive session.');
+    console.log('Use "svamp agent -- <command> [args]" for a custom ACP agent.');
+    return;
+  }
+  const { resolveAcpAgentConfig } = await import('./run-aevHxpEl.mjs').then(function (n) { return n.f; });
+  const { AcpBackend } = await import('./run-aevHxpEl.mjs').then(function (n) { return n.e; });
+  const { GeminiTransport } = await import('./run-aevHxpEl.mjs').then(function (n) { return n.G; });
+  const { DefaultTransport } = await import('./run-aevHxpEl.mjs').then(function (n) { return n.D; });
+  let cwd = process.cwd();
+  const filteredArgs = [];
+  for (let i = 0; i < agentArgs.length; i++) {
+    if ((agentArgs[i] === "-d" || agentArgs[i] === "--directory") && i + 1 < agentArgs.length) {
+      cwd = agentArgs[i + 1];
+      i++;
+    } else {
+      filteredArgs.push(agentArgs[i]);
+    }
+  }
+  let config;
+  try {
+    config = resolveAcpAgentConfig(filteredArgs);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+  console.log(`Starting ${config.agentName} agent in ${cwd}...`);
+  const transportHandler = config.agentName === "gemini" ? new GeminiTransport() : new DefaultTransport(config.agentName);
+  const backend = new AcpBackend({
+    agentName: config.agentName,
+    cwd,
+    command: config.command,
+    args: config.args,
+    transportHandler,
+    log: (...logArgs) => {
+      if (process.env.DEBUG) {
+        console.error("[debug]", ...logArgs);
+      }
+    }
+  });
+  let currentText = "";
+  backend.onMessage((msg) => {
+    switch (msg.type) {
+      case "model-output":
+        if (msg.textDelta) {
+          process.stdout.write(msg.textDelta);
+          currentText += msg.textDelta;
+        } else if (msg.fullText) {
+          process.stdout.write(msg.fullText);
+        }
+        break;
+      case "status":
+        if (msg.status === "idle") {
+          if (currentText && !currentText.endsWith("\n")) {
+            process.stdout.write("\n");
+          }
+          currentText = "";
+          process.stdout.write("\n> ");
+        } else if (msg.status === "error") {
+          console.error(`
+Error: ${msg.detail}`);
+        } else if (msg.status === "stopped") {
+          console.log(`
+Agent stopped: ${msg.detail || ""}`);
+        }
+        break;
+      case "tool-call":
+        console.log(`
+[tool] ${msg.toolName}(${JSON.stringify(msg.args).substring(0, 100)})`);
+        break;
+      case "tool-result": {
+        const resultStr = typeof msg.result === "string" ? msg.result : JSON.stringify(msg.result);
+        if (resultStr.length > 200) {
+          console.log(`[tool result] ${resultStr.substring(0, 200)}...`);
+        }
+        break;
+      }
+      case "event":
+        if (msg.name === "thinking") {
+          const payload = msg.payload;
+          if (payload?.text) {
+            process.stdout.write(`\x1B[90m${payload.text}\x1B[0m`);
+          }
+        }
+        break;
+    }
+  });
+  try {
+    const result = await backend.startSession();
+    console.log(`Session started: ${result.sessionId}`);
+    process.stdout.write("> ");
+  } catch (err) {
+    const errMsg = err?.message || (typeof err === "object" ? JSON.stringify(err) : String(err));
+    console.error(`Failed to start ${config.agentName}: ${errMsg}`);
+    process.exit(1);
+  }
+  const readline = await import('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false
+  });
+  rl.on("line", async (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    if (trimmed === "/quit" || trimmed === "/exit") {
+      console.log("Shutting down...");
+      await backend.dispose();
+      process.exit(0);
+    }
+    if (trimmed === "/cancel") {
+      await backend.cancel("");
+      return;
+    }
+    try {
+      await backend.sendPrompt("", trimmed);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+    }
+  });
+  rl.on("close", async () => {
+    await backend.dispose();
+    process.exit(0);
+  });
+  process.on("SIGINT", async () => {
+    console.log("\nShutting down...");
+    await backend.dispose();
+    process.exit(0);
+  });
+}
+async function handleSessionCommand() {
+  const sessionArgs = args.slice(1);
+  const sessionSubcommand = sessionArgs[0];
+  if (!sessionSubcommand || sessionSubcommand === "--help" || sessionSubcommand === "-h") {
+    printSessionHelp();
+    return;
+  }
+  const { sessionList, sessionSpawn, sessionStop, sessionInfo, sessionMessages, sessionAttach } = await import('./commands-p36abIvL.mjs');
+  if (sessionSubcommand === "list" || sessionSubcommand === "ls") {
+    await sessionList();
+  } else if (sessionSubcommand === "spawn") {
+    const agent = sessionArgs[1] || "claude";
+    let dir = process.cwd();
+    for (let i = 1; i < sessionArgs.length; i++) {
+      if ((sessionArgs[i] === "-d" || sessionArgs[i] === "--directory") && i + 1 < sessionArgs.length) {
+        dir = sessionArgs[i + 1];
+        i++;
+      }
+    }
+    await sessionSpawn(agent, dir);
+  } else if (sessionSubcommand === "stop") {
+    if (!sessionArgs[1]) {
+      console.error("Usage: svamp session stop <session-id>");
+      process.exit(1);
+    }
+    await sessionStop(sessionArgs[1]);
+  } else if (sessionSubcommand === "info") {
+    if (!sessionArgs[1]) {
+      console.error("Usage: svamp session info <session-id>");
+      process.exit(1);
+    }
+    await sessionInfo(sessionArgs[1]);
+  } else if (sessionSubcommand === "messages" || sessionSubcommand === "msgs") {
+    if (!sessionArgs[1]) {
+      console.error("Usage: svamp session messages <session-id> [--last N]");
+      process.exit(1);
+    }
+    let last;
+    const lastIdx = sessionArgs.indexOf("--last");
+    if (lastIdx >= 0 && sessionArgs[lastIdx + 1]) {
+      last = parseInt(sessionArgs[lastIdx + 1], 10);
+    }
+    await sessionMessages(sessionArgs[1], last);
+  } else if (sessionSubcommand === "attach") {
+    if (!sessionArgs[1]) {
+      console.error("Usage: svamp session attach <session-id>");
+      process.exit(1);
+    }
+    await sessionAttach(sessionArgs[1]);
+  } else {
+    console.error(`Unknown session command: ${sessionSubcommand}`);
+    printSessionHelp();
+    process.exit(1);
+  }
+  process.exit(0);
+}
 async function loginToHypha() {
   const serverUrl = args[1] || process.env.HYPHA_SERVER_URL;
   if (!serverUrl) {
@@ -169,19 +373,26 @@ function printHelp() {
 svamp \u2014 Svamp CLI with Hypha transport
 
 Usage:
-  svamp login [url]      Login to Hypha (opens browser, stores token)
-  svamp daemon start     Start the daemon (detached)
-  svamp daemon stop      Stop the daemon
-  svamp daemon status    Show daemon status
-  svamp --version        Show version
-  svamp --help           Show this help
+  svamp login [url]          Login to Hypha (opens browser, stores token)
+  svamp daemon start         Start the daemon (detached)
+  svamp daemon stop          Stop the daemon
+  svamp daemon status        Show daemon status
+  svamp session list         List active daemon sessions
+  svamp session spawn        Spawn a new session on the daemon
+  svamp session attach <id>  Attach to a session (interactive)
+  svamp session --help       Show all session commands
+  svamp agent list           List known ACP agents
+  svamp agent <name>         Start local ACP agent session
+  svamp agent -- <cmd>       Start custom ACP agent
+  svamp --version            Show version
+  svamp --help               Show this help
 
 Environment variables:
   HYPHA_SERVER_URL     Hypha server URL (required for daemon)
   HYPHA_TOKEN          Hypha auth token (stored by login command)
   HYPHA_WORKSPACE      Hypha workspace / user ID (stored by login command)
   SVAMP_MACHINE_ID     Machine identifier (optional, auto-generated)
-  SVAMP_HOME     Config directory (default: ~/.svamp)
+  SVAMP_HOME           Config directory (default: ~/.svamp)
 `);
 }
 function printDaemonHelp() {
@@ -194,6 +405,55 @@ Usage:
   svamp daemon status    Show daemon status
 `);
 }
+function printSessionHelp() {
+  console.log(`
+svamp session \u2014 Manage daemon sessions (Claude, Gemini, OpenCode)
+
+Usage:
+  svamp session list                       List active sessions
+  svamp session spawn <agent> [-d <path>]  Spawn a new session
+  svamp session stop <id>                  Stop a session
+  svamp session info <id>                  Show session metadata
+  svamp session messages <id> [--last N]   Dump recent messages
+  svamp session attach <id>                Attach to session (interactive)
+
+Agents: claude (default), gemini, opencode
+
+Session IDs can be abbreviated (prefix match, like Docker).
+
+Attach commands:
+  /quit, /detach    Detach (session keeps running)
+  /abort, /cancel   Cancel current agent turn
+  /kill             Stop the session
+  /info             Show session status
+
+Examples:
+  svamp session list
+  svamp session spawn claude -d ~/projects/myapp
+  svamp session spawn gemini
+  svamp session info abc12345
+  svamp session messages abc12345 --last 10
+  svamp session attach abc12345
+`);
+}
+function printAgentHelp() {
+  console.log(`
+svamp agent \u2014 Interactive ACP agent sessions
+
+Usage:
+  svamp agent list                 List known ACP agents
+  svamp agent <name> [-d <path>]   Start interactive agent session
+  svamp agent -- <cmd> [args]      Start custom ACP agent
+
+Examples:
+  svamp agent gemini               Start Gemini agent in current directory
+  svamp agent gemini -d /tmp/proj  Start Gemini agent in /tmp/proj
+  svamp agent opencode             Start OpenCode agent
+  svamp agent -- mycli --acp       Start custom ACP-compatible agent
+
+Known agents: gemini, opencode
+`);
+}
 main().catch((err) => {
   console.error("Fatal error:", err);
   process.exit(1);