svamp-cli 0.1.6 → 0.1.7

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { s as startDaemon, b as stopDaemon, d as daemonStatus } from './run-C2z4Zl9E.mjs';
+import { s as startDaemon, b as stopDaemon, d as daemonStatus } from './run-aevHxpEl.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -74,10 +74,13 @@ async function main() {
     }
   } 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();
@@ -91,7 +94,7 @@ async function handleAgentCommand() {
     return;
   }
   if (agentArgs[0] === "list") {
-    const { KNOWN_ACP_AGENTS } = await import('./run-C2z4Zl9E.mjs').then(function (n) { return n.f; });
+    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(" ")}`);
@@ -100,10 +103,10 @@ async function handleAgentCommand() {
     console.log('Use "svamp agent -- <command> [args]" for a custom ACP agent.');
     return;
   }
-  const { resolveAcpAgentConfig } = await import('./run-C2z4Zl9E.mjs').then(function (n) { return n.f; });
-  const { AcpBackend } = await import('./run-C2z4Zl9E.mjs').then(function (n) { return n.e; });
-  const { GeminiTransport } = await import('./run-C2z4Zl9E.mjs').then(function (n) { return n.G; });
-  const { DefaultTransport } = await import('./run-C2z4Zl9E.mjs').then(function (n) { return n.D; });
+  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++) {
@@ -187,7 +190,8 @@ Agent stopped: ${msg.detail || ""}`);
     console.log(`Session started: ${result.sessionId}`);
     process.stdout.write("> ");
   } catch (err) {
-    console.error(`Failed to start ${config.agentName}: ${err.message}`);
+    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');
@@ -224,6 +228,62 @@ Agent stopped: ${msg.detail || ""}`);
     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) {
@@ -313,15 +373,19 @@ 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 agent list         List known ACP agents
-  svamp agent <name>       Start interactive ACP agent session
-  svamp agent -- <cmd>     Start custom ACP agent
-  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)
@@ -341,6 +405,37 @@ 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

package/dist/commands-C8QbpD3d.mjs

@@ -0,0 +1,476 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import os from 'node:os';
+import { c as connectToHypha } from './run-aevHxpEl.mjs';
+import 'os';
+import 'fs/promises';
+import 'fs';
+import 'path';
+import 'url';
+import 'child_process';
+import 'crypto';
+import 'node:crypto';
+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 SVAMP_HOME = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
+const DAEMON_STATE_FILE = join(SVAMP_HOME, "daemon.state.json");
+const ENV_FILE = join(SVAMP_HOME, ".env");
+function loadDotEnv() {
+  if (!existsSync(ENV_FILE)) return;
+  const lines = readFileSync(ENV_FILE, "utf-8").split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    const value = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, "");
+    if (!process.env[key]) {
+      process.env[key] = value;
+    }
+  }
+}
+function readDaemonState() {
+  if (!existsSync(DAEMON_STATE_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync(DAEMON_STATE_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function isDaemonAlive(state) {
+  try {
+    process.kill(state.pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function connectAndGetMachine() {
+  loadDotEnv();
+  const state = readDaemonState();
+  if (!state || !isDaemonAlive(state)) {
+    console.error('Daemon is not running. Start it with "svamp daemon start".');
+    process.exit(1);
+  }
+  const serverUrl = process.env.HYPHA_SERVER_URL || state.hyphaServerUrl;
+  const token = process.env.HYPHA_TOKEN;
+  if (!serverUrl) {
+    console.error('No Hypha server URL. Run "svamp login <url>" first.');
+    process.exit(1);
+  }
+  const origLog = console.log;
+  const origWarn = console.warn;
+  const origInfo = console.info;
+  const stdoutWrite = process.stdout.write.bind(process.stdout);
+  console.log = () => {
+  };
+  console.warn = () => {
+  };
+  console.info = () => {
+  };
+  process.stdout.write = (chunk, ...args) => {
+    if (typeof chunk === "string" && (chunk.includes("WebSocket") || chunk.includes("Connection established") || chunk.includes("registering service") || chunk.includes("Subscribing") || chunk.includes("subscribed") || chunk.includes("Cleaning up") || chunk.includes("disconnected"))) {
+      return true;
+    }
+    return stdoutWrite(chunk, ...args);
+  };
+  const restoreConsole = () => {
+    console.log = origLog;
+    console.warn = origWarn;
+    console.info = origInfo;
+    process.stdout.write = stdoutWrite;
+  };
+  let server;
+  try {
+    server = await connectToHypha({
+      serverUrl,
+      token,
+      name: "svamp-session-cli"
+    });
+  } catch (err) {
+    restoreConsole();
+    console.error(`Failed to connect to Hypha: ${err.message}`);
+    process.exit(1);
+  }
+  let machine;
+  if (state.machineId) {
+    try {
+      machine = await server.getService(`svamp-machine-${state.machineId}`);
+    } catch {
+    }
+  }
+  if (!machine) {
+    try {
+      const services = await server.listServices();
+      const machineServices = services.filter((svc) => {
+        const sid = svc.id || svc.name || "";
+        return sid.includes("svamp-machine-");
+      });
+      if (machineServices.length === 0) {
+        restoreConsole();
+        console.error("No machine service found. Is the daemon registered on Hypha?");
+        await server.disconnect();
+        process.exit(1);
+      }
+      const svcId = machineServices[0].id || machineServices[0].name;
+      machine = await server.getService(svcId);
+    } catch (err) {
+      restoreConsole();
+      console.error(`Failed to discover machine service: ${err.message}`);
+      await server.disconnect();
+      process.exit(1);
+    }
+  }
+  restoreConsole();
+  return { server, machine };
+}
+function resolveSessionId(sessions, partial) {
+  const exact = sessions.find((s) => s.sessionId === partial);
+  if (exact) return exact;
+  const matches = sessions.filter((s) => s.sessionId.startsWith(partial));
+  if (matches.length === 1) return matches[0];
+  if (matches.length === 0) {
+    console.error(`No session found matching: ${partial}`);
+    console.error('Run "svamp session list" to see active sessions.');
+    process.exit(1);
+  }
+  console.error(`Ambiguous session ID "${partial}". Matches:`);
+  for (const s of matches) {
+    console.error(`  ${s.sessionId}`);
+  }
+  process.exit(1);
+}
+function truncate(str, max) {
+  if (str.length <= max) return str;
+  return "..." + str.slice(str.length - max + 3);
+}
+function renderMessage(msg) {
+  const content = msg.content;
+  if (!content) return;
+  const role = content.role;
+  if (role === "user") {
+    const data = content.content;
+    let text;
+    if (typeof data === "string") {
+      try {
+        const parsed = JSON.parse(data);
+        text = parsed?.text || parsed?.content?.text || data;
+      } catch {
+        text = data;
+      }
+    } else if (data?.text) {
+      text = data.text;
+    } else if (data?.type === "text") {
+      text = data.text || "";
+    } else {
+      text = typeof data === "object" ? JSON.stringify(data) : String(data || "");
+    }
+    console.log(`\x1B[36m[user]\x1B[0m ${text}`);
+  } else if (role === "agent" || role === "assistant") {
+    const data = content.content?.data || content.content;
+    if (!data) return;
+    if (data.type === "assistant" && Array.isArray(data.content)) {
+      for (const block of data.content) {
+        if (block.type === "text" && block.text) {
+          process.stdout.write(block.text);
+          if (!block.text.endsWith("\n")) process.stdout.write("\n");
+        } else if (block.type === "tool_use") {
+          const argsStr = JSON.stringify(block.input || {}).slice(0, 120);
+          console.log(`\x1B[33m[tool]\x1B[0m ${block.name}(${argsStr})`);
+        } else if (block.type === "tool_result") {
+          const resultStr = typeof block.content === "string" ? block.content : JSON.stringify(block.content || "");
+          console.log(`\x1B[90m[result]\x1B[0m ${resultStr.slice(0, 200)}${resultStr.length > 200 ? "..." : ""}`);
+        } else if (block.type === "thinking") {
+          const text = block.thinking || block.text || "";
+          if (text) console.log(`\x1B[90m[thinking] ${text.slice(0, 200)}\x1B[0m`);
+        }
+      }
+    } else if (data.type === "result") {
+      if (data.result) console.log(`\x1B[32m[done]\x1B[0m ${data.result}`);
+    } else if (data.type === "output") {
+      const inner = data.data;
+      if (inner?.type === "assistant" && Array.isArray(inner.content)) {
+        for (const block of inner.content) {
+          if (block.type === "text" && block.text) {
+            process.stdout.write(block.text);
+            if (!block.text.endsWith("\n")) process.stdout.write("\n");
+          } else if (block.type === "tool_use") {
+            const argsStr = JSON.stringify(block.input || {}).slice(0, 120);
+            console.log(`\x1B[33m[tool]\x1B[0m ${block.name}(${argsStr})`);
+          } else if (block.type === "tool_result") {
+            const resultStr = typeof block.content === "string" ? block.content : JSON.stringify(block.content || "");
+            console.log(`\x1B[90m[result]\x1B[0m ${resultStr.slice(0, 200)}${resultStr.length > 200 ? "..." : ""}`);
+          }
+        }
+      } else if (inner?.type === "result") {
+        if (inner.result) console.log(`\x1B[32m[done]\x1B[0m ${inner.result}`);
+      }
+    }
+  } else if (role === "session") {
+    const data = content.content?.data;
+    if (data?.type === "system" && data?.subtype === "init") {
+      console.log(`\x1B[90m[session init]\x1B[0m`);
+    }
+  }
+}
+async function sessionList() {
+  const { server, machine } = await connectAndGetMachine();
+  try {
+    const sessions = await machine.listSessions();
+    if (sessions.length === 0) {
+      console.log("No active sessions.");
+      return;
+    }
+    const enriched = [];
+    for (const s of sessions) {
+      let flavor = "claude";
+      let name = "";
+      if (s.metadata) {
+        flavor = s.metadata.flavor || "claude";
+        name = s.metadata.name || "";
+      }
+      if (!name && s.active) {
+        try {
+          const svc = await server.getService(`svamp-session-${s.sessionId}`);
+          const { metadata } = await svc.getMetadata();
+          flavor = metadata?.flavor || flavor;
+          name = metadata?.name || "";
+        } catch {
+        }
+      }
+      enriched.push({ ...s, flavor, name });
+    }
+    const header = `${"ID".padEnd(10)} ${"AGENT".padEnd(10)} ${"STATUS".padEnd(9)} ${"NAME".padEnd(25)} ${"DIRECTORY".padEnd(35)}`;
+    console.log(header);
+    console.log("-".repeat(header.length));
+    for (const s of enriched) {
+      const id = s.sessionId.slice(0, 8);
+      const agent = (s.flavor || "claude").padEnd(10);
+      const status = s.active ? "\x1B[32mactive\x1B[0m  " : "\x1B[90minactive\x1B[0m";
+      const name = truncate(s.name || "-", 25).padEnd(25);
+      const dir = truncate(s.directory || "-", 33).padEnd(35);
+      console.log(`${id.padEnd(10)} ${agent} ${status} ${name} ${dir}`);
+    }
+  } finally {
+    await server.disconnect();
+  }
+}
+async function sessionSpawn(agent, directory) {
+  const { server, machine } = await connectAndGetMachine();
+  try {
+    console.log(`Spawning ${agent} session in ${directory}...`);
+    const result = await machine.spawnSession({
+      directory,
+      agent
+    });
+    if (result.type === "success") {
+      console.log(`Session started: ${result.sessionId}`);
+      if (result.message) console.log(`  ${result.message}`);
+    } else if (result.type === "requestToApproveDirectoryCreation") {
+      console.error(`Directory ${result.directory} does not exist. Create it first or use an existing directory.`);
+      process.exit(1);
+    } else {
+      console.error(`Failed: ${result.errorMessage || "Unknown error"}`);
+      process.exit(1);
+    }
+  } finally {
+    await server.disconnect();
+  }
+}
+async function sessionStop(sessionId) {
+  const { server, machine } = await connectAndGetMachine();
+  try {
+    const sessions = await machine.listSessions();
+    const match = resolveSessionId(sessions, sessionId);
+    const success = await machine.stopSession(match.sessionId);
+    if (success) {
+      console.log(`Session ${match.sessionId.slice(0, 8)} stopped.`);
+    } else {
+      console.error("Failed to stop session (not found on daemon).");
+      process.exit(1);
+    }
+  } finally {
+    await server.disconnect();
+  }
+}
+async function sessionInfo(sessionId) {
+  const { server, machine } = await connectAndGetMachine();
+  try {
+    const sessions = await machine.listSessions();
+    const match = resolveSessionId(sessions, sessionId);
+    const fullId = match.sessionId;
+    let metadata = {};
+    let activity = {};
+    try {
+      const svc = await server.getService(`svamp-session-${fullId}`);
+      const metaResult = await svc.getMetadata();
+      metadata = metaResult.metadata || {};
+      activity = await svc.getActivityState();
+    } catch {
+    }
+    console.log(`Session:    ${fullId}`);
+    console.log(`Agent:      ${metadata.flavor || "claude"}`);
+    console.log(`Name:       ${metadata.name || "(unnamed)"}`);
+    console.log(`Directory:  ${metadata.path || match.directory || "-"}`);
+    console.log(`Host:       ${metadata.host || "-"}`);
+    console.log(`State:      ${metadata.lifecycleState || "unknown"}`);
+    console.log(`Active:     ${activity.active ?? "-"}`);
+    console.log(`Thinking:   ${activity.thinking ?? "-"}`);
+    console.log(`Started by: ${metadata.startedBy || match.startedBy || "-"}`);
+    if (metadata.summary?.text) {
+      console.log(`Summary:    ${metadata.summary.text}`);
+    }
+    if (metadata.claudeSessionId) {
+      console.log(`Claude ID:  ${metadata.claudeSessionId}`);
+    }
+    if (metadata.sessionLink?.url) {
+      console.log(`Link:       ${metadata.sessionLink.url}`);
+    }
+  } finally {
+    await server.disconnect();
+  }
+}
+async function sessionMessages(sessionId, last) {
+  const { server, machine } = await connectAndGetMachine();
+  try {
+    const sessions = await machine.listSessions();
+    const match = resolveSessionId(sessions, sessionId);
+    const fullId = match.sessionId;
+    const svc = await server.getService(`svamp-session-${fullId}`);
+    const { messages } = await svc.getMessages(0, 1e3);
+    const toShow = last ? messages.slice(-last) : messages;
+    if (toShow.length === 0) {
+      console.log("No messages yet.");
+      return;
+    }
+    for (const msg of toShow) {
+      renderMessage(msg);
+    }
+  } finally {
+    await server.disconnect();
+  }
+}
+async function sessionAttach(sessionId) {
+  const { server, machine } = await connectAndGetMachine();
+  const sessions = await machine.listSessions();
+  const match = resolveSessionId(sessions, sessionId);
+  const fullId = match.sessionId;
+  let svc;
+  try {
+    svc = await server.getService(`svamp-session-${fullId}`);
+  } catch (err) {
+    console.error(`Could not find session service: ${err.message}`);
+    await server.disconnect();
+    process.exit(1);
+  }
+  const { metadata } = await svc.getMetadata();
+  const flavor = metadata?.flavor || "claude";
+  const name = metadata?.name || fullId.slice(0, 8);
+  console.log(`Attached to ${flavor} session "${name}". Commands: /quit /abort /kill
+`);
+  const seenMessageIds = /* @__PURE__ */ new Set();
+  let replayDone = false;
+  await svc.registerListener({
+    onUpdate: (update) => {
+      if (update.type === "new-message") {
+        const msg = update.message;
+        if (!msg?.id) return;
+        if (seenMessageIds.has(msg.id)) return;
+        seenMessageIds.add(msg.id);
+        if (!replayDone) return;
+        renderMessage(msg);
+      } else if (update.type === "activity") {
+        if (!replayDone) return;
+        if (update.thinking) {
+          process.stdout.write("\x1B[90m[thinking...]\x1B[0m\r");
+        } else if (!update.active) {
+          process.stdout.write("\n> ");
+        }
+      } else if (update.type === "update-session") ;
+    }
+  });
+  await new Promise((r) => setTimeout(r, 500));
+  replayDone = true;
+  console.log(`\x1B[90m(${seenMessageIds.size} messages in history)\x1B[0m`);
+  process.stdout.write("> ");
+  const readline = await import('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  rl.on("line", async (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      process.stdout.write("> ");
+      return;
+    }
+    if (trimmed === "/quit" || trimmed === "/detach") {
+      console.log("Detaching (session continues running)...");
+      rl.close();
+      await server.disconnect();
+      process.exit(0);
+    }
+    if (trimmed === "/abort" || trimmed === "/cancel") {
+      try {
+        await svc.abort();
+        console.log("Abort sent.");
+      } catch (err) {
+        console.error(`Abort failed: ${err.message}`);
+      }
+      process.stdout.write("> ");
+      return;
+    }
+    if (trimmed === "/kill") {
+      try {
+        await svc.killSession();
+        console.log("Session killed.");
+      } catch (err) {
+        console.error(`Kill failed: ${err.message}`);
+      }
+      rl.close();
+      await server.disconnect();
+      process.exit(0);
+    }
+    if (trimmed === "/info") {
+      try {
+        const { metadata: m } = await svc.getMetadata();
+        const act = await svc.getActivityState();
+        console.log(`  Agent: ${m?.flavor || "claude"}, State: ${m?.lifecycleState || "?"}, Active: ${act?.active}, Thinking: ${act?.thinking}`);
+      } catch (err) {
+        console.error(`Info failed: ${err.message}`);
+      }
+      process.stdout.write("> ");
+      return;
+    }
+    try {
+      await svc.sendMessage(
+        JSON.stringify({
+          role: "user",
+          content: { type: "text", text: trimmed }
+        })
+      );
+    } catch (err) {
+      console.error(`Send failed: ${err.message}`);
+      process.stdout.write("> ");
+    }
+  });
+  rl.on("close", async () => {
+    await server.disconnect();
+    process.exit(0);
+  });
+  process.on("SIGINT", async () => {
+    console.log("\nDetaching (session continues running)...");
+    rl.close();
+    await server.disconnect();
+    process.exit(0);
+  });
+}
+
+export { sessionAttach, sessionInfo, sessionList, sessionMessages, sessionSpawn, sessionStop };