svamp-cli 0.1.23 → 0.1.28

package/bin/svamp-agent.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+// Svamp Agent CLI entry point
+// Loads .env from ~/.svamp/.env if present, then runs the agent CLI
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+// Simple .env loader — load from SVAMP_HOME or ~/.svamp/
+const envDir = process.env.SVAMP_HOME || join(homedir(), '.svamp');
+const envFile = join(envDir, '.env');
+
+if (existsSync(envFile)) {
+    const lines = readFileSync(envFile, '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;
+        }
+    }
+}
+
+// Import and run the agent CLI
+import('../dist/agent-cli.mjs').catch((err) => {
+    console.error('Failed to load compiled agent CLI. Try running: yarn workspace svamp-cli build');
+    console.error(err.message);
+    process.exit(1);
+});

package/dist/agent-cli.mjs

@@ -0,0 +1,453 @@
+import { Command } from 'commander';
+import { connectAndGetMachine, resolveSessionId } from './commands-BOeSil-P.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;
+});