svamp-cli 0.1.29 → 0.1.30

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { s as startDaemon, b as stopDaemon, d as daemonStatus } from './run-BCSNMhiz.mjs';
+import { s as startDaemon, b as stopDaemon, d as daemonStatus } from './run-dBWhjQRf.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -104,7 +104,7 @@ async function handleAgentCommand() {
     return;
   }
   if (agentArgs[0] === "list") {
-    const { KNOWN_ACP_AGENTS } = await import('./run-BCSNMhiz.mjs').then(function (n) { return n.f; });
+    const { KNOWN_ACP_AGENTS } = await import('./run-dBWhjQRf.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(" ")}`);
@@ -113,10 +113,10 @@ async function handleAgentCommand() {
     console.log('Use "svamp agent -- <command> [args]" for a custom ACP agent.');
     return;
   }
-  const { resolveAcpAgentConfig } = await import('./run-BCSNMhiz.mjs').then(function (n) { return n.f; });
-  const { AcpBackend } = await import('./run-BCSNMhiz.mjs').then(function (n) { return n.e; });
-  const { GeminiTransport } = await import('./run-BCSNMhiz.mjs').then(function (n) { return n.G; });
-  const { DefaultTransport } = await import('./run-BCSNMhiz.mjs').then(function (n) { return n.D; });
+  const { resolveAcpAgentConfig } = await import('./run-dBWhjQRf.mjs').then(function (n) { return n.f; });
+  const { AcpBackend } = await import('./run-dBWhjQRf.mjs').then(function (n) { return n.e; });
+  const { GeminiTransport } = await import('./run-dBWhjQRf.mjs').then(function (n) { return n.G; });
+  const { DefaultTransport } = await import('./run-dBWhjQRf.mjs').then(function (n) { return n.D; });
   let cwd = process.cwd();
   const filteredArgs = [];
   for (let i = 0; i < agentArgs.length; i++) {
@@ -255,7 +255,7 @@ async function handleSessionCommand() {
     printSessionHelp();
     return;
   }
-  const { sessionList, sessionSpawn, sessionStop, sessionInfo, sessionMessages, sessionAttach, sessionMachines, sessionSend, sessionWait } = await import('./commands-CtO1WRt4.mjs');
+  const { sessionList, sessionSpawn, sessionStop, sessionInfo, sessionMessages, sessionAttach, sessionMachines, sessionSend, sessionWait } = await import('./commands-C5pW2VmI.mjs');
   const parseFlagStr = (flag, shortFlag) => {
     for (let i = 1; i < sessionArgs.length; i++) {
       if ((sessionArgs[i] === flag || shortFlag) && i + 1 < sessionArgs.length) {

package/dist/{commands-CgT3AgJ0.mjs → commands-B2xQb9u7.mjs}

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import os from 'node:os';
-import { c as connectToHypha } from './run-DZmxHj-e.mjs';
+import { c as connectToHypha } from './run-CtCTd6if.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';

package/dist/{commands-CKTIJoV0.mjs → commands-C5pW2VmI.mjs}

@@ -1,7 +1,51 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import os from 'node:os';
-import { c as connectToHypha } from './hyphaClient-DLkclazm.mjs';
+import { c as connectToHypha } from './run-dBWhjQRf.mjs';
+import 'os';
+import 'fs/promises';
+import 'fs';
+import 'path';
+import 'url';
+import 'child_process';
+import 'crypto';
+import 'node:crypto';
+import 'node:child_process';
+import '@agentclientprotocol/sdk';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/client/stdio.js';
+import '@modelcontextprotocol/sdk/types.js';
+import 'zod';
+import 'node:fs/promises';
+import 'node:util';
+
+function toMarkdownInline(value) {
+  const escaped = value.replace(/`/g, "\\`");
+  return `\`${escaped}\``;
+}
+function formatSessionStatus(data) {
+  const lines = [
+    "## Session Status",
+    "",
+    `- Session ID: ${toMarkdownInline(data.sessionId)}`,
+    `- Agent: ${data.flavor}`
+  ];
+  if (data.name) lines.push(`- Name: ${data.name}`);
+  if (data.summary) lines.push(`- Summary: ${data.summary}`);
+  if (data.path) lines.push(`- Path: ${data.path}`);
+  if (data.host) lines.push(`- Host: ${data.host}`);
+  if (data.lifecycleState) lines.push(`- Lifecycle: ${data.lifecycleState}`);
+  lines.push(`- Active: ${data.active ? "yes" : "no"}`);
+  lines.push(`- Thinking: ${data.thinking ? "yes" : "no"}`);
+  lines.push(`- Agent Status: ${data.active ? "busy" : "idle"}`);
+  if (data.startedBy) lines.push(`- Started By: ${data.startedBy}`);
+  if (data.claudeSessionId) lines.push(`- Claude Session: ${data.claudeSessionId}`);
+  if (data.sessionLink) lines.push(`- Link: ${data.sessionLink}`);
+  return lines.join("\n");
+}
+function formatJson(data) {
+  return JSON.stringify(data, null, 2);
+}
 
 const SVAMP_HOME = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
 const DAEMON_STATE_FILE = join(SVAMP_HOME, "daemon.state.json");
@@ -354,49 +398,168 @@ function renderMessage(msg) {
     }
   }
 }
-async function sessionList(machineId) {
+function extractMessageText(msg) {
+  const content = msg.content;
+  if (!content) return null;
+  const role = content.role || "unknown";
+  let text = "";
+  if (role === "user") {
+    const data = content.content;
+    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 || "");
+    }
+  } else if (role === "agent" || role === "assistant") {
+    const data = content.content?.data || content.content;
+    if (!data) return null;
+    if (data.type === "assistant" && Array.isArray(data.content)) {
+      const parts = [];
+      for (const block of data.content) {
+        if (block.type === "text" && block.text) {
+          parts.push(block.text);
+        } else if (block.type === "tool_use") {
+          parts.push(`[tool: ${block.name}]`);
+        }
+      }
+      text = parts.join("\n");
+    } else if (data.type === "result") {
+      text = data.result || "";
+    } else if (data.type === "output") {
+      const inner = data.data;
+      if (inner?.type === "assistant" && Array.isArray(inner.content)) {
+        const parts = [];
+        for (const block of inner.content) {
+          if (block.type === "text" && block.text) {
+            parts.push(block.text);
+          } else if (block.type === "tool_use") {
+            parts.push(`[tool: ${block.name}]`);
+          }
+        }
+        text = parts.join("\n");
+      } else if (inner?.type === "result") {
+        text = inner.result || "";
+      }
+    }
+  } else if (role === "session") {
+    text = "[session event]";
+  }
+  return {
+    id: msg.id || "",
+    seq: msg.seq || 0,
+    role,
+    text,
+    createdAt: msg.createdAt || 0
+  };
+}
+async function waitForIdle(server, sessionId, timeoutMs) {
+  const svc = await server.getService(`svamp-session-${sessionId}`);
+  const pollInterval = 2e3;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const activity = await svc.getActivityState();
+    if (activity && !activity.active) {
+      return;
+    }
+    await new Promise((r) => setTimeout(r, pollInterval));
+  }
+  throw new Error("Timeout waiting for agent to become idle");
+}
+async function waitForBusyThenIdle(server, sessionId, timeoutMs = 3e5, busyTimeoutMs = 1e4) {
+  const svc = await server.getService(`svamp-session-${sessionId}`);
+  const pollInterval = 2e3;
+  const deadline = Date.now() + timeoutMs;
+  const busyDeadline = Date.now() + busyTimeoutMs;
+  let sawBusy = false;
+  while (Date.now() < deadline) {
+    const activity = await svc.getActivityState();
+    const isActive = activity?.active === true;
+    if (isActive) {
+      sawBusy = true;
+    }
+    if (sawBusy && !isActive) {
+      return;
+    }
+    if (!sawBusy && Date.now() > busyDeadline) {
+      return;
+    }
+    await new Promise((r) => setTimeout(r, pollInterval));
+  }
+  throw new Error("Timeout waiting for agent to become idle");
+}
+async function sessionList(machineId, opts) {
   const { server, machine } = await connectAndGetMachine(machineId);
   try {
     const sessions = await machine.listSessions();
-    if (sessions.length === 0) {
-      console.log("No active sessions.");
+    const filtered = opts?.active ? sessions.filter((s) => s.active) : sessions;
+    if (filtered.length === 0) {
+      if (opts?.json) {
+        console.log(formatJson([]));
+      } else {
+        console.log("No active sessions.");
+      }
       return;
     }
     const enriched = [];
-    for (const s of sessions) {
+    for (const s of filtered) {
       let flavor = "claude";
       let name = "";
+      let path = s.directory || "";
+      let host = "";
       if (s.metadata) {
         flavor = s.metadata.flavor || "claude";
         name = s.metadata.name || "";
       }
-      if (!name && s.active) {
+      if (s.active) {
         try {
           const svc = await server.getService(`svamp-session-${s.sessionId}`);
           const { metadata } = await svc.getMetadata();
           flavor = metadata?.flavor || flavor;
-          name = metadata?.name || "";
+          name = metadata?.name || name;
+          path = metadata?.path || path;
+          host = metadata?.host || "";
         } catch {
         }
       }
-      enriched.push({ ...s, flavor, name });
+      enriched.push({ ...s, flavor, name, path, host });
     }
-    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}`);
+    if (opts?.json) {
+      console.log(formatJson(enriched.map((s) => ({
+        sessionId: s.sessionId,
+        agent: s.flavor,
+        name: s.name,
+        path: s.path,
+        host: s.host,
+        active: s.active,
+        directory: s.directory
+      }))));
+    } else {
+      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, machineId) {
+async function sessionSpawn(agent, directory, machineId, opts) {
   const { server, machine } = await connectAndGetMachine(machineId);
   try {
     console.log(`Spawning ${agent} session in ${directory}...`);
@@ -407,6 +570,22 @@ async function sessionSpawn(agent, directory, machineId) {
     if (result.type === "success") {
       console.log(`Session started: ${result.sessionId}`);
       if (result.message) console.log(`  ${result.message}`);
+      if (opts?.message && result.sessionId) {
+        const svc = await server.getService(`svamp-session-${result.sessionId}`);
+        const sendResult = await svc.sendMessage(
+          JSON.stringify({
+            role: "user",
+            content: { type: "text", text: opts.message },
+            meta: { sentFrom: "svamp-cli" }
+          })
+        );
+        console.log(`Message sent (seq: ${sendResult.seq})`);
+        if (opts.wait) {
+          console.log("Waiting for agent to become idle...");
+          await waitForBusyThenIdle(server, result.sessionId);
+          console.log("Agent is idle.");
+        }
+      }
     } else if (result.type === "requestToApproveDirectoryCreation") {
       console.error(`Directory ${result.directory} does not exist. Create it first or use an existing directory.`);
       process.exit(1);
@@ -434,7 +613,7 @@ async function sessionStop(sessionId, machineId) {
     await server.disconnect();
   }
 }
-async function sessionInfo(sessionId, machineId) {
+async function sessionInfo(sessionId, machineId, opts) {
   const { server, machine } = await connectAndGetMachine(machineId);
   try {
     const sessions = await machine.listSessions();
@@ -449,43 +628,62 @@ async function sessionInfo(sessionId, machineId) {
       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}`);
+    const statusData = {
+      sessionId: fullId,
+      flavor: metadata.flavor || "claude",
+      name: metadata.name || "",
+      path: metadata.path || match.directory || "",
+      host: metadata.host || "",
+      lifecycleState: metadata.lifecycleState || "unknown",
+      active: activity.active ?? false,
+      thinking: activity.thinking ?? false,
+      startedBy: metadata.startedBy || match.startedBy || "",
+      summary: metadata.summary?.text || void 0,
+      claudeSessionId: metadata.claudeSessionId || void 0,
+      sessionLink: metadata.sessionLink?.url || void 0
+    };
+    if (opts?.json) {
+      console.log(formatJson(statusData));
+    } else {
+      console.log(formatSessionStatus(statusData));
     }
   } finally {
     await server.disconnect();
   }
 }
-async function sessionMessages(sessionId, last, machineId) {
+async function sessionMessages(sessionId, machineId, opts) {
   const { server, machine } = await connectAndGetMachine(machineId);
   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;
+    const afterSeq = opts?.after ?? 0;
+    const apiLimit = opts?.limit ?? 1e3;
+    const { messages } = await svc.getMessages(afterSeq, apiLimit);
+    const toShow = opts?.last ? messages.slice(-opts.last) : messages;
     if (toShow.length === 0) {
-      console.log("No messages yet.");
+      if (opts?.json) {
+        console.log(formatJson([]));
+      } else {
+        console.log("No messages yet.");
+      }
       return;
     }
-    for (const msg of toShow) {
-      renderMessage(msg);
+    if (opts?.json) {
+      const formatted = [];
+      for (const msg of toShow) {
+        const extracted = extractMessageText(msg);
+        if (extracted) {
+          formatted.push(extracted);
+        }
+      }
+      formatted.sort((a, b) => a.createdAt - b.createdAt);
+      console.log(formatJson(formatted));
+    } else {
+      for (const msg of toShow) {
+        renderMessage(msg);
+      }
     }
   } finally {
     await server.disconnect();
@@ -607,30 +805,58 @@ async function sessionAttach(sessionId, machineId) {
     process.exit(0);
   });
 }
-async function sessionRecover(machineId) {
+async function sessionSend(sessionId, message, machineId, opts) {
   const { server, machine } = await connectAndGetMachine(machineId);
   try {
-    console.log("Scanning for crashed sessions to recover...");
-    const result = await machine.recoverSessions();
-    if (result.recovered === 0 && result.failed === 0) {
-      console.log("No crashed sessions found to recover.");
-      if (result.alreadyActive > 0) {
-        console.log(`${result.alreadyActive} session(s) already active.`);
-      }
-      return;
+    const sessions = await machine.listSessions();
+    const match = resolveSessionId(sessions, sessionId);
+    const fullId = match.sessionId;
+    const svc = await server.getService(`svamp-session-${fullId}`);
+    const result = await svc.sendMessage(
+      JSON.stringify({
+        role: "user",
+        content: { type: "text", text: message },
+        meta: { sentFrom: "svamp-cli" }
+      })
+    );
+    if (opts?.wait) {
+      const timeoutMs = (opts.timeout || 300) * 1e3;
+      await waitForBusyThenIdle(server, fullId, timeoutMs);
     }
-    for (const detail of result.details) {
-      if (detail.status === "recovered") {
-        console.log(`  \x1B[32m\u2713\x1B[0m ${detail.sessionId.slice(0, 8)} (${detail.directory})`);
-      } else if (detail.status === "failed") {
-        console.log(`  \x1B[31m\u2717\x1B[0m ${detail.sessionId.slice(0, 8)} (${detail.directory}): ${detail.error}`);
+    if (opts?.json) {
+      console.log(formatJson({
+        sessionId: fullId,
+        message,
+        sent: true,
+        seq: result.seq,
+        waited: !!opts.wait
+      }));
+    } else {
+      console.log(`Message sent to session ${fullId.slice(0, 8)} (seq: ${result.seq})`);
+      if (opts?.wait) {
+        console.log("Agent is idle.");
       }
     }
-    console.log(`
-Recovered: ${result.recovered}, Failed: ${result.failed}, Already active: ${result.alreadyActive}`);
+  } finally {
+    await server.disconnect();
+  }
+}
+async function sessionWait(sessionId, machineId, opts) {
+  const { server, machine } = await connectAndGetMachine(machineId);
+  try {
+    const sessions = await machine.listSessions();
+    const match = resolveSessionId(sessions, sessionId);
+    const fullId = match.sessionId;
+    const timeoutMs = (opts?.timeout || 300) * 1e3;
+    await waitForIdle(server, fullId, timeoutMs);
+    console.log(`Session ${fullId.slice(0, 8)} is idle.`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(msg);
+    process.exitCode = 1;
   } finally {
     await server.disconnect();
   }
 }
 
-export { connectAndGetMachine, renderMessage, resolveSessionId, sessionAttach, sessionInfo, sessionList, sessionMachines, sessionMessages, sessionRecover, sessionSpawn, sessionStop };
+export { connectAndGetMachine, renderMessage, resolveSessionId, sessionAttach, sessionInfo, sessionList, sessionMachines, sessionMessages, sessionSend, sessionSpawn, sessionStop, sessionWait };