svamp-cli 0.1.29 → 0.1.31

package/dist/agent-cli.mjs

@@ -1,453 +0,0 @@
-import { Command } from 'commander';
-import { connectAndGetMachine, resolveSessionId } from './commands-DDB3y1L1.mjs';
-import 'node:fs';
-import 'node:path';
-import 'node:os';
-import './hyphaClient-DLkclazm.mjs';
-
-function formatIsoTime(ts) {
-  if (!ts) return "-";
-  const date = new Date(ts);
-  if (Number.isNaN(date.getTime())) return "-";
-  return date.toISOString();
-}
-function toMarkdownInline(value) {
-  const escaped = value.replace(/`/g, "\\`");
-  return `\`${escaped}\``;
-}
-function normalizeCodeBlockText(value) {
-  const text = value.trim().length > 0 ? value : "(empty)";
-  return text.replace(/```/g, "``\\`");
-}
-function formatSessionTable(sessions) {
-  if (sessions.length === 0) {
-    return "## Sessions\n\n- Total: 0\n- Items: none";
-  }
-  const sections = sessions.map((s, index) => {
-    const name = s.name || "-";
-    const path = s.path || s.directory || "-";
-    const status = s.active ? "active" : "inactive";
-    return [
-      `### Session ${index + 1}`,
-      `- ID: ${toMarkdownInline(s.sessionId)}`,
-      `- Agent: ${s.flavor || "claude"}`,
-      `- Name: ${name}`,
-      `- Path: ${path}`,
-      `- Status: ${status}`
-    ].join("\n");
-  });
-  return `## Sessions
-
-- Total: ${sessions.length}
-
-${sections.join("\n\n")}`;
-}
-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 formatMessageHistory(messages) {
-  if (messages.length === 0) {
-    return "## Message History\n\n- Count: 0\n- Items: none";
-  }
-  const sections = messages.map((msg, index) => {
-    return [
-      `### Message ${index + 1}`,
-      `- ID: ${toMarkdownInline(msg.id)}`,
-      `- Time: ${formatIsoTime(msg.createdAt)}`,
-      `- Role: ${msg.role}`,
-      "- Text:",
-      "```text",
-      normalizeCodeBlockText(msg.text),
-      "```"
-    ].join("\n");
-  });
-  return `## Message History
-
-- Count: ${messages.length}
-
-${sections.join("\n\n")}`;
-}
-function formatJson(data) {
-  return JSON.stringify(data, null, 2);
-}
-
-async function resolveSessionByPath(machine, server, path) {
-  const sessions = await machine.listSessions();
-  const active = sessions.filter((s) => s.active);
-  let matches = active.filter((s) => s.directory === path);
-  if (matches.length === 0) {
-    for (const s of active) {
-      try {
-        const svc = await server.getService(`svamp-session-${s.sessionId}`);
-        const { metadata } = await svc.getMetadata();
-        if (metadata?.path === path) {
-          matches.push(s);
-        }
-      } catch {
-      }
-    }
-  }
-  if (matches.length === 0) {
-    throw new Error(`No active session found for path "${path}"`);
-  }
-  return matches[0];
-}
-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");
-}
-const program = new Command();
-program.name("svamp-agent").description("CLI client for controlling Svamp sessions remotely").version("0.1.0");
-program.command("list").description("List all sessions").option("--active", "Show only active sessions").option("--json", "Output as JSON").action(async (opts) => {
-  const { server, machine } = await connectAndGetMachine();
-  try {
-    const sessions = await machine.listSessions();
-    const filtered = opts.active ? sessions.filter((s) => s.active) : sessions;
-    const enriched = [];
-    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 (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;
-          path = metadata?.path || path;
-          host = metadata?.host || "";
-        } catch {
-        }
-      }
-      enriched.push({ ...s, flavor, name, path, host });
-    }
-    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 {
-      console.log(formatSessionTable(enriched));
-    }
-  } finally {
-    await server.disconnect();
-  }
-});
-program.command("status").description("Get live session state").argument("<session-id>", "Session ID or prefix").option("--json", "Output as JSON").action(async (sessionId, opts) => {
-  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 {
-    }
-    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();
-  }
-});
-program.command("create").description("Create a new session").option("--agent <agent>", "Agent type (claude, gemini, opencode)", "claude").option("--directory <path>", "Working directory path").option("--json", "Output as JSON").action(async (opts) => {
-  const { server, machine } = await connectAndGetMachine();
-  try {
-    const directory = opts.directory ?? process.cwd();
-    const result = await machine.spawnSession({
-      directory,
-      agent: opts.agent
-    });
-    if (result.type === "success") {
-      if (opts.json) {
-        console.log(formatJson({
-          sessionId: result.sessionId,
-          agent: opts.agent,
-          directory
-        }));
-      } else {
-        console.log([
-          "## Session Created",
-          "",
-          `- Session ID: \`${result.sessionId}\``,
-          `- Agent: ${opts.agent}`,
-          `- Directory: ${directory}`,
-          ...result.message ? [`- Note: ${result.message}`] : []
-        ].join("\n"));
-      }
-    } else if (result.type === "requestToApproveDirectoryCreation") {
-      throw new Error(`Directory ${result.directory} does not exist. Create it first or use an existing directory.`);
-    } else {
-      throw new Error(result.errorMessage || "Unknown error creating session");
-    }
-  } finally {
-    await server.disconnect();
-  }
-});
-program.command("send").description("Send a message to a session").argument("<session-id>", "Session ID or prefix (ignored when --by-path is used)").argument("<message>", "Message text").option("--wait", "Wait for agent to become idle").option("--by-path <path>", "Resolve session by working directory path (active sessions only)").option("--json", "Output as JSON").action(async (sessionId, message, opts) => {
-  const { server, machine } = await connectAndGetMachine();
-  try {
-    let match;
-    if (opts.byPath) {
-      match = await resolveSessionByPath(machine, server, opts.byPath);
-    } else {
-      const sessions = await machine.listSessions();
-      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-agent" }
-      })
-    );
-    if (opts.wait) {
-      await waitForBusyThenIdle(server, fullId);
-    }
-    if (opts.json) {
-      console.log(formatJson({
-        sessionId: fullId,
-        message,
-        sent: true,
-        seq: result.seq,
-        waited: !!opts.wait
-      }));
-    } else {
-      console.log([
-        "## Message Sent",
-        "",
-        `- Session ID: \`${fullId}\``,
-        `- Sequence: ${result.seq}`,
-        ...opts.wait ? [`- Waited For Idle: yes`] : []
-      ].join("\n"));
-    }
-  } finally {
-    await server.disconnect();
-  }
-});
-program.command("history").description("Read message history").argument("<session-id>", "Session ID or prefix").option("--limit <n>", "Limit number of messages", (v) => {
-  const n = parseInt(v, 10);
-  if (isNaN(n) || n <= 0) throw new Error("--limit must be a positive integer");
-  return n;
-}).option("--after <seq>", "Only show messages after this sequence number", (v) => {
-  const n = parseInt(v, 10);
-  if (isNaN(n) || n < 0) throw new Error("--after must be a non-negative integer");
-  return n;
-}).option("--json", "Output as JSON").action(async (sessionId, opts) => {
-  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 afterSeq = opts.after ?? 0;
-    const apiLimit = opts.limit ?? 500;
-    const { messages } = await svc.getMessages(afterSeq, apiLimit);
-    let formatted = [];
-    for (const msg of messages) {
-      const extracted = extractMessageText(msg);
-      if (extracted) {
-        formatted.push(extracted);
-      }
-    }
-    formatted.sort((a, b) => a.createdAt - b.createdAt);
-    if (opts.json) {
-      console.log(formatJson(formatted));
-    } else {
-      console.log(formatMessageHistory(formatted));
-    }
-  } finally {
-    await server.disconnect();
-  }
-});
-program.command("stop").description("Stop a session").argument("<session-id>", "Session ID or prefix").action(async (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 Stopped",
-        "",
-        `- Session ID: \`${match.sessionId}\``
-      ].join("\n"));
-    } else {
-      throw new Error("Failed to stop session (not found on daemon)");
-    }
-  } finally {
-    await server.disconnect();
-  }
-});
-program.command("wait").description("Wait for agent to become idle").argument("<session-id>", "Session ID or prefix").option("--timeout <seconds>", "Timeout in seconds", (v) => {
-  const n = parseInt(v, 10);
-  if (isNaN(n) || n <= 0) throw new Error("--timeout must be a positive integer");
-  return n;
-}, 300).action(async (sessionId, opts) => {
-  const { server, machine } = await connectAndGetMachine();
-  try {
-    const sessions = await machine.listSessions();
-    const match = resolveSessionId(sessions, sessionId);
-    const fullId = match.sessionId;
-    await waitForIdle(server, fullId, opts.timeout * 1e3);
-    console.log([
-      "## Session Idle",
-      "",
-      `- Session ID: \`${fullId}\``
-    ].join("\n"));
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(msg);
-    process.exitCode = 1;
-  } finally {
-    await server.disconnect();
-  }
-});
-program.parseAsync(process.argv).catch((err) => {
-  console.error(err instanceof Error ? err.message : String(err));
-  process.exitCode = 1;
-});