svamp-cli 0.1.87 → 0.1.89

package/dist/cli.mjs

@@ -0,0 +1,1535 @@
+import { b as stopDaemon, s as startDaemon, d as daemonStatus } from './run-71Ox10lO.mjs';
+import 'os';
+import 'fs/promises';
+import 'fs';
+import 'path';
+import 'url';
+import 'child_process';
+import 'crypto';
+import 'node:fs';
+import 'node:crypto';
+import 'node:path';
+import 'node:child_process';
+import '@agentclientprotocol/sdk';
+import 'node:os';
+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';
+
+const nodeMajor = parseInt(process.versions.node.split(".")[0], 10);
+if (nodeMajor < 22) {
+  console.error(`Error: svamp requires Node.js >= 22 (you have ${process.version}).`);
+  console.error("  Node 22+ includes native WebSocket support needed by hypha-rpc.");
+  console.error("  Upgrade with:  nvm install 22 && nvm alias default 22");
+  process.exit(1);
+}
+const args = process.argv.slice(2);
+const subcommand = args[0];
+let daemonSubcommand = args[1];
+async function main() {
+  if (subcommand === "login") {
+    await loginToHypha();
+  } else if (subcommand === "logout") {
+    await logoutFromHypha();
+  } else if (subcommand === "daemon") {
+    if (daemonSubcommand === "restart") {
+      await stopDaemon();
+      daemonSubcommand = "start";
+    }
+    if (daemonSubcommand === "start") {
+      const { spawn } = await import('child_process');
+      const extraArgs = [];
+      if (args.includes("--no-auto-continue")) extraArgs.push("--no-auto-continue");
+      const child = spawn(process.execPath, [
+        "--no-warnings",
+        "--no-deprecation",
+        ...process.argv.slice(1, 2),
+        // the script path
+        "daemon",
+        "start-supervised",
+        ...extraArgs
+      ], {
+        detached: true,
+        stdio: "ignore",
+        env: process.env
+      });
+      child.unref();
+      const { existsSync } = await import('fs');
+      const { join } = await import('path');
+      const os = await import('os');
+      const stateFile = join(
+        process.env.SVAMP_HOME || join(os.homedir(), ".svamp"),
+        "daemon.state.json"
+      );
+      let started = false;
+      for (let i = 0; i < 100; i++) {
+        await new Promise((r) => setTimeout(r, 100));
+        if (existsSync(stateFile)) {
+          started = true;
+          break;
+        }
+      }
+      if (started) {
+        console.log("Daemon started successfully");
+      } else {
+        console.error("Failed to start daemon (timeout waiting for state file)");
+        process.exit(1);
+      }
+      process.exit(0);
+    } else if (daemonSubcommand === "start-supervised") {
+      const { spawn: spawnChild } = await import('child_process');
+      const { appendFileSync, mkdirSync, existsSync: fsExists } = await import('fs');
+      const { join: pathJoin } = await import('path');
+      const osModule = await import('os');
+      const svampHome = process.env.SVAMP_HOME || pathJoin(osModule.homedir(), ".svamp");
+      const logsDir = pathJoin(svampHome, "logs");
+      mkdirSync(logsDir, { recursive: true });
+      const logFile = pathJoin(logsDir, "daemon-supervised.log");
+      const log = (msg) => {
+        const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [supervisor] ${msg}
+`;
+        try {
+          appendFileSync(logFile, line);
+        } catch {
+        }
+      };
+      const supervisorPidFile = pathJoin(svampHome, "supervisor.pid");
+      try {
+        appendFileSync(supervisorPidFile, "");
+      } catch {
+      }
+      const { writeFileSync: wfs } = await import('fs');
+      wfs(supervisorPidFile, String(process.pid), "utf-8");
+      const extraSyncArgs = [];
+      if (args.includes("--no-auto-continue")) extraSyncArgs.push("--no-auto-continue");
+      const BASE_DELAY_MS = 2e3;
+      const MAX_DELAY_MS = 3e5;
+      const BACKOFF_RESET_UPTIME_MS = 6e4;
+      let consecutiveRapidCrashes = 0;
+      let currentChild = null;
+      let stopping = false;
+      const onSignal = (sig) => {
+        stopping = true;
+        if (currentChild && !currentChild.killed) {
+          currentChild.kill(sig);
+        }
+      };
+      process.on("SIGTERM", () => onSignal("SIGTERM"));
+      process.on("SIGINT", () => onSignal("SIGINT"));
+      process.on("SIGUSR1", () => onSignal("SIGUSR1"));
+      log("Supervisor started");
+      while (!stopping) {
+        const startTime = Date.now();
+        const exitCode = await new Promise((resolve) => {
+          const child = spawnChild(process.execPath, [
+            "--no-warnings",
+            "--no-deprecation",
+            ...process.argv.slice(1, 2),
+            "daemon",
+            "start-sync",
+            ...extraSyncArgs
+          ], {
+            stdio: ["ignore", "inherit", "inherit"],
+            env: { ...process.env, SVAMP_SUPERVISED: "1" }
+          });
+          currentChild = child;
+          child.on("exit", (code) => resolve(code));
+          child.on("error", (err) => {
+            log(`Failed to spawn daemon: ${err.message}`);
+            resolve(1);
+          });
+        });
+        currentChild = null;
+        const uptime = Date.now() - startTime;
+        if (stopping) {
+          log("Supervisor received stop signal, exiting");
+          break;
+        }
+        if (exitCode === 0) {
+          log("Daemon exited cleanly (exit 0), not restarting");
+          break;
+        }
+        if (uptime > BACKOFF_RESET_UPTIME_MS) {
+          consecutiveRapidCrashes = 0;
+        } else {
+          consecutiveRapidCrashes++;
+        }
+        const backoffExp = Math.min(consecutiveRapidCrashes, 10);
+        let delay = Math.min(BASE_DELAY_MS * Math.pow(2, backoffExp), MAX_DELAY_MS);
+        delay = Math.max(BASE_DELAY_MS, Math.round(delay + (Math.random() * 0.2 - 0.1) * delay));
+        log(`Daemon exited with code ${exitCode} (uptime=${Math.round(uptime / 1e3)}s). Restarting in ${Math.round(delay / 1e3)}s...`);
+        await new Promise((resolve) => {
+          const timer = setTimeout(resolve, delay);
+          const checkStop = setInterval(() => {
+            if (stopping) {
+              clearTimeout(timer);
+              clearInterval(checkStop);
+              resolve();
+            }
+          }, 500);
+          setTimeout(() => clearInterval(checkStop), delay + 100);
+        });
+      }
+      try {
+        const { unlinkSync: us } = await import('fs');
+        us(supervisorPidFile);
+      } catch {
+      }
+      process.exit(0);
+    } else if (daemonSubcommand === "start-sync") {
+      const noAutoContinue = args.includes("--no-auto-continue");
+      await startDaemon({ noAutoContinue });
+      process.exit(0);
+    } else if (daemonSubcommand === "stop") {
+      const cleanup = args.includes("--cleanup");
+      await stopDaemon({ cleanup });
+      process.exit(0);
+    } else if (daemonSubcommand === "status") {
+      daemonStatus();
+      process.exit(0);
+    } else if (daemonSubcommand === "install") {
+      await installDaemonService();
+      process.exit(0);
+    } else if (daemonSubcommand === "uninstall") {
+      await uninstallDaemonService();
+      process.exit(0);
+    } else {
+      printDaemonHelp();
+    }
+  } else if (subcommand === "agent") {
+    await handleAgentCommand();
+  } else if (subcommand === "session") {
+    await handleSessionCommand();
+  } else if (subcommand === "machine") {
+    await handleMachineCommand();
+  } else if (subcommand === "skills") {
+    await handleSkillsCommand();
+  } else if (subcommand === "service" || subcommand === "svc") {
+    const { handleServiceCommand } = await import('./commands-BYbuedOK.mjs');
+    await handleServiceCommand();
+  } else if (subcommand === "process" || subcommand === "proc") {
+    const { processCommand } = await import('./commands-DT4zKcI_.mjs');
+    let machineId;
+    const processArgs = args.slice(1);
+    const mIdx = processArgs.findIndex((a) => a === "--machine" || a === "-m");
+    if (mIdx !== -1 && mIdx + 1 < processArgs.length) {
+      machineId = processArgs[mIdx + 1];
+    }
+    await processCommand(processArgs.filter((_a, i) => {
+      if (processArgs[i] === "--machine" || processArgs[i] === "-m") return false;
+      if (i > 0 && (processArgs[i - 1] === "--machine" || processArgs[i - 1] === "-m")) return false;
+      return true;
+    }), machineId);
+    process.exit(0);
+  } else if (subcommand === "--help" || subcommand === "-h") {
+    printHelp();
+  } else if (!subcommand || subcommand === "start") {
+    await handleInteractiveCommand();
+  } else if (subcommand === "--version" || subcommand === "-v") {
+    const pkg = await import('./package-DP0KvJ1N.mjs').catch(() => ({ default: { version: "unknown" } }));
+    console.log(`svamp version: ${pkg.default.version}`);
+  } else {
+    console.error(`Unknown command: ${subcommand}`);
+    printHelp();
+    process.exit(1);
+  }
+}
+async function handleInteractiveCommand() {
+  const { runInteractive } = await import('./run-BU9OQRQs.mjs');
+  const interactiveArgs = subcommand === "start" ? args.slice(1) : args;
+  let directory = process.cwd();
+  let resumeSessionId;
+  let continueSession = false;
+  let permissionMode;
+  const claudeArgs = [];
+  let pastSeparator = false;
+  for (let i = 0; i < interactiveArgs.length; i++) {
+    if (pastSeparator) {
+      claudeArgs.push(interactiveArgs[i]);
+      continue;
+    }
+    if (interactiveArgs[i] === "--") {
+      pastSeparator = true;
+      continue;
+    }
+    if ((interactiveArgs[i] === "-d" || interactiveArgs[i] === "--directory") && i + 1 < interactiveArgs.length) {
+      directory = interactiveArgs[++i];
+    } else if ((interactiveArgs[i] === "--resume" || interactiveArgs[i] === "-r") && i + 1 < interactiveArgs.length) {
+      resumeSessionId = interactiveArgs[++i];
+    } else if (interactiveArgs[i] === "--continue" || interactiveArgs[i] === "-c") {
+      continueSession = true;
+    } else if ((interactiveArgs[i] === "--permission-mode" || interactiveArgs[i] === "-p") && i + 1 < interactiveArgs.length) {
+      permissionMode = interactiveArgs[++i];
+    } else if (interactiveArgs[i] === "--help" || interactiveArgs[i] === "-h") {
+      printInteractiveHelp();
+      return;
+    }
+  }
+  await runInteractive({
+    directory,
+    resumeSessionId,
+    continueSession,
+    permissionMode,
+    claudeArgs: claudeArgs.length > 0 ? claudeArgs : void 0
+  });
+}
+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, KNOWN_MCP_AGENTS: KNOWN_MCP_AGENTS2 } = await import('./run-71Ox10lO.mjs').then(function (n) { return n.i; });
+    console.log("Known agents:");
+    for (const [name, config2] of Object.entries(KNOWN_ACP_AGENTS)) {
+      console.log(`  ${name.padEnd(12)} ${config2.command} ${config2.args.join(" ")}  (ACP)`);
+    }
+    for (const [name, config2] of Object.entries(KNOWN_MCP_AGENTS2)) {
+      console.log(`  ${name.padEnd(12)} ${config2.command} ${config2.args.join(" ")}  (MCP)`);
+    }
+    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, KNOWN_MCP_AGENTS } = await import('./run-71Ox10lO.mjs').then(function (n) { return n.i; });
+  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);
+  }
+  const logFn = (...logArgs) => {
+    if (process.env.DEBUG) console.error("[debug]", ...logArgs);
+  };
+  console.log(`Starting ${config.agentName} agent in ${cwd}...`);
+  let backend;
+  if (KNOWN_MCP_AGENTS[config.agentName]) {
+    const { CodexMcpBackend } = await import('./run-71Ox10lO.mjs').then(function (n) { return n.j; });
+    backend = new CodexMcpBackend({ cwd, log: logFn });
+  } else {
+    const { AcpBackend } = await import('./run-71Ox10lO.mjs').then(function (n) { return n.h; });
+    const { GeminiTransport } = await import('./run-71Ox10lO.mjs').then(function (n) { return n.G; });
+    const { DefaultTransport } = await import('./run-71Ox10lO.mjs').then(function (n) { return n.D; });
+    const transportHandler = config.agentName === "gemini" ? new GeminiTransport() : new DefaultTransport(config.agentName);
+    backend = new AcpBackend({
+      agentName: config.agentName,
+      cwd,
+      command: config.command,
+      args: config.args,
+      transportHandler,
+      log: logFn
+    });
+  }
+  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 rawSessionArgs = args.slice(1);
+  let targetMachineId;
+  const sessionArgs = [];
+  for (let i = 0; i < rawSessionArgs.length; i++) {
+    if ((rawSessionArgs[i] === "--machine" || rawSessionArgs[i] === "-m") && i + 1 < rawSessionArgs.length) {
+      targetMachineId = rawSessionArgs[i + 1];
+      i++;
+    } else {
+      sessionArgs.push(rawSessionArgs[i]);
+    }
+  }
+  const sessionSubcommand = sessionArgs[0];
+  if (!sessionSubcommand || sessionSubcommand === "--help" || sessionSubcommand === "-h") {
+    printSessionHelp();
+    return;
+  }
+  const { sessionList, sessionSpawn, sessionStop, sessionInfo, sessionMessages, sessionAttach, sessionMachines, sessionSend, sessionWait, sessionShare, sessionRalphStart, sessionRalphCancel, sessionRalphStatus, sessionInboxSend, sessionInboxList, sessionInboxRead, sessionInboxReply, sessionInboxClear } = await import('./commands-pv7rhgVn.mjs');
+  const parseFlagStr = (flag, shortFlag) => {
+    for (let i = 1; i < sessionArgs.length; i++) {
+      if ((sessionArgs[i] === flag || shortFlag) && i + 1 < sessionArgs.length) {
+        return sessionArgs[i + 1];
+      }
+    }
+    return void 0;
+  };
+  const parseFlagInt = (flag, shortFlag) => {
+    const v = parseFlagStr(flag, shortFlag);
+    if (v === void 0) return void 0;
+    const n = parseInt(v, 10);
+    return isNaN(n) ? void 0 : n;
+  };
+  const hasFlag = (flag) => sessionArgs.includes(flag);
+  if (sessionSubcommand === "machines" || sessionSubcommand === "machine") {
+    await sessionMachines();
+  } else if (sessionSubcommand === "list" || sessionSubcommand === "ls") {
+    await sessionList(targetMachineId, {
+      active: hasFlag("--active"),
+      json: hasFlag("--json")
+    });
+  } 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++;
+      }
+    }
+    const message = parseFlagStr("--message");
+    const wait = hasFlag("--wait");
+    const worktree = hasFlag("--worktree");
+    const isolate = hasFlag("--isolate");
+    const permissionMode = parseFlagStr("--permission-mode") || parseFlagStr("-p");
+    const securityContextPath = parseFlagStr("--security-context");
+    const denyNetwork = hasFlag("--deny-network");
+    const parentSessionId = parseFlagStr("--parent");
+    const tagsFlag = parseFlagStr("--tags");
+    const share = [];
+    const denyRead = [];
+    const allowWrite = [];
+    const allowDomain = [];
+    const tags = [];
+    if (tagsFlag) {
+      tags.push(...tagsFlag.split(",").map((t) => t.trim()).filter(Boolean));
+    }
+    for (let i = 1; i < sessionArgs.length; i++) {
+      if (sessionArgs[i] === "--share" && i + 1 < sessionArgs.length) {
+        share.push(sessionArgs[++i]);
+      } else if (sessionArgs[i] === "--deny-read" && i + 1 < sessionArgs.length) {
+        denyRead.push(sessionArgs[++i]);
+      } else if (sessionArgs[i] === "--allow-write" && i + 1 < sessionArgs.length) {
+        allowWrite.push(sessionArgs[++i]);
+      } else if (sessionArgs[i] === "--allow-domain" && i + 1 < sessionArgs.length) {
+        allowDomain.push(sessionArgs[++i]);
+      }
+    }
+    const { parseShareArg } = await import('./commands-pv7rhgVn.mjs');
+    const shareEntries = share.map((s) => parseShareArg(s));
+    await sessionSpawn(agent, dir, targetMachineId, {
+      message,
+      wait,
+      worktree,
+      isolate,
+      permissionMode,
+      securityContextPath,
+      share: shareEntries.length > 0 ? shareEntries : void 0,
+      denyRead: denyRead.length > 0 ? denyRead : void 0,
+      allowWrite: allowWrite.length > 0 ? allowWrite : void 0,
+      denyNetwork,
+      allowDomain: allowDomain.length > 0 ? allowDomain : void 0,
+      tags: tags.length > 0 ? tags : void 0,
+      parentSessionId
+    });
+  } else if (sessionSubcommand === "stop") {
+    if (!sessionArgs[1]) {
+      console.error("Usage: svamp session stop <session-id>");
+      process.exit(1);
+    }
+    await sessionStop(sessionArgs[1], targetMachineId);
+  } else if (sessionSubcommand === "info") {
+    if (!sessionArgs[1]) {
+      console.error("Usage: svamp session info <session-id>");
+      process.exit(1);
+    }
+    await sessionInfo(sessionArgs[1], targetMachineId, {
+      json: hasFlag("--json")
+    });
+  } else if (sessionSubcommand === "messages" || sessionSubcommand === "msgs") {
+    if (!sessionArgs[1]) {
+      console.error("Usage: svamp session messages <session-id> [--last N] [--json] [--raw] [--after N] [--limit N]");
+      process.exit(1);
+    }
+    await sessionMessages(sessionArgs[1], targetMachineId, {
+      last: parseFlagInt("--last"),
+      json: hasFlag("--json"),
+      raw: hasFlag("--raw"),
+      after: parseFlagInt("--after"),
+      limit: parseFlagInt("--limit")
+    });
+  } else if (sessionSubcommand === "attach") {
+    if (!sessionArgs[1]) {
+      console.error("Usage: svamp session attach <session-id>");
+      process.exit(1);
+    }
+    await sessionAttach(sessionArgs[1], targetMachineId);
+  } else if (sessionSubcommand === "send") {
+    if (!sessionArgs[1] || !sessionArgs[2]) {
+      console.error('Usage: svamp session send <session-id> <message> [--subject "..."] [--urgency urgent|normal] [--wait] [--timeout N] [--json]');
+      process.exit(1);
+    }
+    await sessionSend(sessionArgs[1], sessionArgs[2], targetMachineId, {
+      wait: hasFlag("--wait"),
+      timeout: parseFlagInt("--timeout"),
+      json: hasFlag("--json"),
+      subject: parseFlagStr("--subject"),
+      urgency: parseFlagStr("--urgency")
+    });
+  } else if (sessionSubcommand === "wait") {
+    if (!sessionArgs[1]) {
+      console.error("Usage: svamp session wait <session-id> [--timeout N] [--json]");
+      process.exit(1);
+    }
+    await sessionWait(sessionArgs[1], targetMachineId, {
+      timeout: parseFlagInt("--timeout"),
+      json: hasFlag("--json")
+    });
+  } else if (sessionSubcommand === "share") {
+    if (!sessionArgs[1]) {
+      console.error("Usage: svamp session share <session-id> --add <email>[:<role>] | --remove <email> | --list | --public <view|interact|off>");
+      process.exit(1);
+    }
+    await sessionShare(sessionArgs[1], targetMachineId, {
+      add: parseFlagStr("--add"),
+      remove: parseFlagStr("--remove"),
+      list: hasFlag("--list"),
+      public: parseFlagStr("--public")
+    });
+  } else if (sessionSubcommand === "approve") {
+    if (!sessionArgs[1]) {
+      console.error("Usage: svamp session approve <session-id> [request-id] [--json]");
+      process.exit(1);
+    }
+    const { sessionApprove } = await import('./commands-pv7rhgVn.mjs');
+    const approveReqId = sessionArgs[2] && !sessionArgs[2].startsWith("--") ? sessionArgs[2] : void 0;
+    await sessionApprove(sessionArgs[1], approveReqId, targetMachineId, {
+      json: hasFlag("--json")
+    });
+  } else if (sessionSubcommand === "deny") {
+    if (!sessionArgs[1]) {
+      console.error("Usage: svamp session deny <session-id> [request-id] [--json]");
+      process.exit(1);
+    }
+    const { sessionDeny } = await import('./commands-pv7rhgVn.mjs');
+    const denyReqId = sessionArgs[2] && !sessionArgs[2].startsWith("--") ? sessionArgs[2] : void 0;
+    await sessionDeny(sessionArgs[1], denyReqId, targetMachineId, {
+      json: hasFlag("--json")
+    });
+  } else if (sessionSubcommand === "ralph-start" || sessionSubcommand === "ralph") {
+    if (!sessionArgs[1] || !sessionArgs[2]) {
+      console.error('Usage: svamp session ralph-start <session-id> "<task>" [--context-mode fresh|continue] [--completion-promise TEXT] [--max-iterations N] [--cooldown N]');
+      process.exit(1);
+    }
+    const contextModeStr = parseFlagStr("--context-mode") || parseFlagStr("--mode");
+    const contextMode = contextModeStr === "fresh" || contextModeStr === "continue" ? contextModeStr : void 0;
+    await sessionRalphStart(sessionArgs[1], sessionArgs[2], targetMachineId, {
+      completionPromise: parseFlagStr("--completion-promise"),
+      maxIterations: parseFlagInt("--max-iterations"),
+      cooldownSeconds: parseFlagInt("--cooldown"),
+      contextMode
+    });
+  } else if (sessionSubcommand === "ralph-cancel") {
+    if (!sessionArgs[1]) {
+      console.error("Usage: svamp session ralph-cancel <session-id>");
+      process.exit(1);
+    }
+    await sessionRalphCancel(sessionArgs[1], targetMachineId);
+  } else if (sessionSubcommand === "ralph-status") {
+    if (!sessionArgs[1]) {
+      console.error("Usage: svamp session ralph-status <session-id>");
+      process.exit(1);
+    }
+    await sessionRalphStatus(sessionArgs[1], targetMachineId);
+  } else if (sessionSubcommand === "set-title") {
+    const title = sessionArgs[1];
+    if (!title) {
+      console.error("Usage: svamp session set-title <title>");
+      process.exit(1);
+    }
+    const { sessionSetTitle } = await import('./agentCommands-DWSVkBSG.mjs');
+    await sessionSetTitle(title);
+  } else if (sessionSubcommand === "set-link") {
+    const url = sessionArgs[1];
+    if (!url) {
+      console.error("Usage: svamp session set-link <url> [label]");
+      process.exit(1);
+    }
+    const label = sessionArgs[2] && !sessionArgs[2].startsWith("--") ? sessionArgs[2] : void 0;
+    const { sessionSetLink } = await import('./agentCommands-DWSVkBSG.mjs');
+    await sessionSetLink(url, label);
+  } else if (sessionSubcommand === "notify") {
+    const message = sessionArgs[1];
+    if (!message) {
+      console.error("Usage: svamp session notify <message> [--level info|warning|error]");
+      process.exit(1);
+    }
+    const level = parseFlagStr("--level") || "info";
+    const { sessionNotify } = await import('./agentCommands-DWSVkBSG.mjs');
+    await sessionNotify(message, level);
+  } else if (sessionSubcommand === "broadcast") {
+    const action = sessionArgs[1];
+    if (!action) {
+      console.error("Usage: svamp session broadcast <action> [args...]\nActions: open-canvas <url> [label], close-canvas, toast <message>");
+      process.exit(1);
+    }
+    const { sessionBroadcast } = await import('./agentCommands-DWSVkBSG.mjs');
+    await sessionBroadcast(action, sessionArgs.slice(2).filter((a) => !a.startsWith("--")));
+  } else if (sessionSubcommand === "inbox") {
+    const inboxSubcmd = sessionArgs[1];
+    const agentSessionId = process.env.SVAMP_SESSION_ID;
+    if (inboxSubcmd === "send") {
+      if (!sessionArgs[2] || !sessionArgs[3]) {
+        console.error('Usage: svamp session inbox send <target-session-id> "<body>" [--subject "..."] [--urgency urgent|normal] [--json]');
+        process.exit(1);
+      }
+      if (agentSessionId) {
+        const { inboxSend } = await import('./agentCommands-DWSVkBSG.mjs');
+        await inboxSend(sessionArgs[2], {
+          body: sessionArgs[3],
+          subject: parseFlagStr("--subject"),
+          urgency: parseFlagStr("--urgency")
+        });
+      } else {
+        await sessionInboxSend(sessionArgs[2], sessionArgs[3], targetMachineId, {
+          subject: parseFlagStr("--subject"),
+          urgency: parseFlagStr("--urgency"),
+          json: hasFlag("--json")
+        });
+      }
+    } else if (inboxSubcmd === "list" || inboxSubcmd === "ls") {
+      if (agentSessionId && !sessionArgs[2]) {
+        const { inboxList } = await import('./agentCommands-DWSVkBSG.mjs');
+        await inboxList({
+          unread: hasFlag("--unread"),
+          limit: parseFlagInt("--limit"),
+          json: hasFlag("--json")
+        });
+      } else if (sessionArgs[2]) {
+        await sessionInboxList(sessionArgs[2], targetMachineId, {
+          unread: hasFlag("--unread"),
+          limit: parseFlagInt("--limit"),
+          json: hasFlag("--json")
+        });
+      } else {
+        console.error("Usage: svamp session inbox list [session-id] [--unread] [--limit N] [--json]");
+        process.exit(1);
+      }
+    } else if (inboxSubcmd === "read") {
+      if (!sessionArgs[2]) {
+        console.error("Usage: svamp session inbox read <session-id|message-id> [message-id]");
+        process.exit(1);
+      }
+      if (agentSessionId && !sessionArgs[3]) {
+        const { inboxList } = await import('./agentCommands-DWSVkBSG.mjs');
+        await sessionInboxRead(agentSessionId, sessionArgs[2], targetMachineId);
+      } else if (sessionArgs[3]) {
+        await sessionInboxRead(sessionArgs[2], sessionArgs[3], targetMachineId);
+      } else {
+        console.error("Usage: svamp session inbox read <session-id> <message-id>");
+        process.exit(1);
+      }
+    } else if (inboxSubcmd === "reply") {
+      if (agentSessionId && sessionArgs[2] && sessionArgs[3] && !sessionArgs[4]) {
+        const { inboxReply } = await import('./agentCommands-DWSVkBSG.mjs');
+        await inboxReply(sessionArgs[2], sessionArgs[3]);
+      } else if (sessionArgs[2] && sessionArgs[3] && sessionArgs[4]) {
+        await sessionInboxReply(sessionArgs[2], sessionArgs[3], sessionArgs[4], targetMachineId);
+      } else {
+        console.error('Usage: svamp session inbox reply <session-id> <message-id> "<body>"');
+        process.exit(1);
+      }
+    } else if (inboxSubcmd === "clear") {
+      if (agentSessionId && !sessionArgs[2]) {
+        await sessionInboxClear(agentSessionId, targetMachineId, { all: hasFlag("--all") });
+      } else if (sessionArgs[2]) {
+        await sessionInboxClear(sessionArgs[2], targetMachineId, { all: hasFlag("--all") });
+      } else {
+        console.error("Usage: svamp session inbox clear [session-id] [--all]");
+        process.exit(1);
+      }
+    } else {
+      console.error("Usage: svamp session inbox <send|list|read|reply|clear> [session-id] [args]");
+      process.exit(1);
+    }
+  } else {
+    console.error(`Unknown session command: ${sessionSubcommand}`);
+    printSessionHelp();
+    process.exit(1);
+  }
+  process.exit(0);
+}
+async function handleMachineCommand() {
+  const machineArgs = args.slice(1);
+  const machineSubcommand = machineArgs[0];
+  if (!machineSubcommand || machineSubcommand === "--help" || machineSubcommand === "-h") {
+    printMachineHelp();
+    return;
+  }
+  if (machineSubcommand === "share") {
+    const { machineShare } = await import('./commands-pv7rhgVn.mjs');
+    let machineId;
+    const shareArgs = [];
+    for (let i = 1; i < machineArgs.length; i++) {
+      if ((machineArgs[i] === "--machine" || machineArgs[i] === "-m") && i + 1 < machineArgs.length) {
+        machineId = machineArgs[++i];
+      } else {
+        shareArgs.push(machineArgs[i]);
+      }
+    }
+    let add;
+    let remove;
+    let configPath;
+    let list = false;
+    let showConfig = false;
+    for (let i = 0; i < shareArgs.length; i++) {
+      if (shareArgs[i] === "--add" && i + 1 < shareArgs.length) {
+        add = shareArgs[++i];
+      } else if (shareArgs[i] === "--remove" && i + 1 < shareArgs.length) {
+        remove = shareArgs[++i];
+      } else if (shareArgs[i] === "--config" && i + 1 < shareArgs.length) {
+        configPath = shareArgs[++i];
+      } else if (shareArgs[i] === "--list") {
+        list = true;
+      } else if (shareArgs[i] === "--show-config") {
+        showConfig = true;
+      }
+    }
+    await machineShare(machineId, { add, remove, list, configPath, showConfig });
+  } else if (machineSubcommand === "exec") {
+    const { machineExec } = await import('./commands-pv7rhgVn.mjs');
+    let machineId;
+    let cwd;
+    const cmdParts = [];
+    for (let i = 1; i < machineArgs.length; i++) {
+      if ((machineArgs[i] === "--machine" || machineArgs[i] === "-m") && i + 1 < machineArgs.length) {
+        machineId = machineArgs[++i];
+      } else if (machineArgs[i] === "--cwd" && i + 1 < machineArgs.length) {
+        cwd = machineArgs[++i];
+      } else {
+        cmdParts.push(machineArgs[i]);
+      }
+    }
+    const command = cmdParts.join(" ");
+    if (!command) {
+      console.error("Usage: svamp machine exec <command> [--cwd <path>] [-m <id>]");
+      process.exit(1);
+    }
+    await machineExec(machineId, command, cwd);
+  } else if (machineSubcommand === "info") {
+    const { machineInfo } = await import('./commands-pv7rhgVn.mjs');
+    let machineId;
+    for (let i = 1; i < machineArgs.length; i++) {
+      if ((machineArgs[i] === "--machine" || machineArgs[i] === "-m") && i + 1 < machineArgs.length) {
+        machineId = machineArgs[++i];
+      }
+    }
+    await machineInfo(machineId);
+  } else if (machineSubcommand === "notify") {
+    const message = machineArgs[1];
+    if (!message) {
+      console.error("Usage: svamp machine notify <message> [--level info|warning|error]");
+      process.exit(1);
+    }
+    let level = "info";
+    for (let i = 2; i < machineArgs.length; i++) {
+      if (machineArgs[i] === "--level" && i + 1 < machineArgs.length) {
+        level = machineArgs[++i];
+      }
+    }
+    const { machineNotify } = await import('./agentCommands-DWSVkBSG.mjs');
+    await machineNotify(message, level);
+  } else if (machineSubcommand === "ls") {
+    const { machineLs } = await import('./commands-pv7rhgVn.mjs');
+    let machineId;
+    let showHidden = false;
+    let path;
+    for (let i = 1; i < machineArgs.length; i++) {
+      if ((machineArgs[i] === "--machine" || machineArgs[i] === "-m") && i + 1 < machineArgs.length) {
+        machineId = machineArgs[++i];
+      } else if (machineArgs[i] === "--hidden" || machineArgs[i] === "-a") {
+        showHidden = true;
+      } else if (!path) {
+        path = machineArgs[i];
+      }
+    }
+    await machineLs(machineId, path, showHidden);
+  } else {
+    console.error(`Unknown machine command: ${machineSubcommand}`);
+    printMachineHelp();
+    process.exit(1);
+  }
+  process.exit(0);
+}
+async function handleSkillsCommand() {
+  const skillsArgs = args.slice(1);
+  const skillsSubcommand = skillsArgs[0];
+  if (!skillsSubcommand || skillsSubcommand === "--help" || skillsSubcommand === "-h") {
+    printSkillsHelp();
+    return;
+  }
+  const { skillsFind, skillsInstall, skillsList, skillsRemove, skillsPublish } = await import('./commands-DJoYOM_1.mjs');
+  if (skillsSubcommand === "find" || skillsSubcommand === "search") {
+    const query = skillsArgs.slice(1).filter((a) => !a.startsWith("--")).join(" ");
+    if (!query) {
+      console.error("Usage: svamp skills find <query> [--json]");
+      process.exit(1);
+    }
+    await skillsFind(query, { json: skillsArgs.includes("--json") });
+  } else if (skillsSubcommand === "install" || skillsSubcommand === "add") {
+    if (!skillsArgs[1]) {
+      console.error("Usage: svamp skills install <name> [--force]");
+      process.exit(1);
+    }
+    await skillsInstall(skillsArgs[1], { force: skillsArgs.includes("--force") });
+  } else if (skillsSubcommand === "list" || skillsSubcommand === "ls") {
+    await skillsList();
+  } else if (skillsSubcommand === "remove" || skillsSubcommand === "rm") {
+    if (!skillsArgs[1]) {
+      console.error("Usage: svamp skills remove <name>");
+      process.exit(1);
+    }
+    await skillsRemove(skillsArgs[1]);
+  } else if (skillsSubcommand === "publish") {
+    const publishArgs = skillsArgs.slice(1).filter((a) => !a.startsWith("--"));
+    if (!publishArgs[0]) {
+      console.error("Usage: svamp skills publish <path> [--version <tag>]");
+      process.exit(1);
+    }
+    const versionIdx = skillsArgs.indexOf("--version");
+    const versionTag = versionIdx !== -1 ? skillsArgs[versionIdx + 1] : void 0;
+    await skillsPublish(publishArgs[0], { version: versionTag });
+  } else {
+    console.error(`Unknown skills command: ${skillsSubcommand}`);
+    printSkillsHelp();
+    process.exit(1);
+  }
+  process.exit(0);
+}
+async function loginToHypha() {
+  const serverUrl = args[1] || process.env.HYPHA_SERVER_URL;
+  if (!serverUrl) {
+    console.error("Usage: svamp login <server-url>");
+    console.error("  Or set HYPHA_SERVER_URL environment variable");
+    process.exit(1);
+  }
+  console.log(`Logging in to Hypha server: ${serverUrl}`);
+  console.log("A browser window will open for authentication...");
+  try {
+    const mod = await import('hypha-rpc');
+    const hyphaWebsocketClient = mod.hyphaWebsocketClient || mod.default?.hyphaWebsocketClient;
+    if (!hyphaWebsocketClient?.login) {
+      throw new Error("Could not find hyphaWebsocketClient.login in hypha-rpc");
+    }
+    const token = await hyphaWebsocketClient.login({
+      server_url: serverUrl,
+      login_timeout: 120,
+      login_callback: (context) => {
+        console.log(`
+Please open this URL in your browser:
+  ${context.login_url}
+`);
+        console.log("Waiting for you to complete login in the browser...\n");
+      }
+    });
+    if (!token) {
+      console.error("Login failed \u2014 no token received");
+      process.exit(1);
+    }
+    const connectToServer = mod.connectToServer || mod.default && mod.default.connectToServer || hyphaWebsocketClient && hyphaWebsocketClient.connectToServer;
+    const server = await connectToServer({ server_url: serverUrl, token });
+    const workspace = server.config.workspace;
+    const userId = server.config.user?.id || workspace;
+    let longLivedToken = token;
+    try {
+      const sixMonthsInSeconds = 6 * 30 * 24 * 60 * 60;
+      longLivedToken = await server.generateToken({ expires_in: sixMonthsInSeconds, workspace });
+      console.log("Generated long-lived token (expires in ~6 months)");
+    } catch (err) {
+      console.warn("Could not generate long-lived token, using login token:", err.message || err);
+    }
+    await server.disconnect();
+    const os = await import('os');
+    const { join } = await import('path');
+    const fs = await import('fs');
+    const homeDir = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
+    if (!fs.existsSync(homeDir)) {
+      fs.mkdirSync(homeDir, { recursive: true });
+    }
+    const envFile = join(homeDir, ".env");
+    const envLines = [];
+    if (fs.existsSync(envFile)) {
+      const existing = fs.readFileSync(envFile, "utf-8").split("\n");
+      for (const line of existing) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("HYPHA_TOKEN=") || trimmed.startsWith("HYPHA_WORKSPACE=") || trimmed.startsWith("HYPHA_SERVER_URL=")) {
+          continue;
+        }
+        envLines.push(line);
+      }
+    }
+    envLines.push(`HYPHA_SERVER_URL=${serverUrl}`);
+    envLines.push(`HYPHA_TOKEN=${longLivedToken}`);
+    envLines.push(`HYPHA_WORKSPACE=${workspace}`);
+    while (envLines.length > 0 && envLines[envLines.length - 1].trim() === "") {
+      envLines.pop();
+    }
+    fs.writeFileSync(envFile, envLines.join("\n") + "\n", "utf-8");
+    console.log(`
+Login successful!`);
+    console.log(`  User: ${userId}`);
+    console.log(`  Workspace: ${workspace}`);
+    console.log(`  Token saved to: ${envFile}`);
+    console.log(`
+You can now start the daemon: svamp daemon start`);
+  } catch (err) {
+    const msg = err.message || String(err);
+    if (msg.includes("WebSocket is not defined")) {
+      console.error(`Login failed: WebSocket is not available in this Node.js version (${process.version}).`);
+      console.error(`  hypha-rpc requires Node.js >= 22 (which includes native WebSocket support).`);
+      console.error(`  Please upgrade Node.js:  nvm install 22 && nvm use 22`);
+    } else {
+      console.error("Login failed:", msg);
+    }
+    process.exit(1);
+  }
+}
+async function logoutFromHypha() {
+  const os = await import('os');
+  const { join } = await import('path');
+  const fs = await import('fs');
+  const homeDir = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
+  const envFile = join(homeDir, ".env");
+  console.log("Stopping daemon...");
+  try {
+    await stopDaemon();
+  } catch {
+  }
+  if (fs.existsSync(envFile)) {
+    const existing = fs.readFileSync(envFile, "utf-8").split("\n");
+    const kept = [];
+    for (const line of existing) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("HYPHA_TOKEN=") || trimmed.startsWith("HYPHA_WORKSPACE=") || trimmed.startsWith("HYPHA_SERVER_URL=")) {
+        continue;
+      }
+      kept.push(line);
+    }
+    while (kept.length > 0 && kept[kept.length - 1].trim() === "") {
+      kept.pop();
+    }
+    if (kept.length > 0) {
+      fs.writeFileSync(envFile, kept.join("\n") + "\n", "utf-8");
+    } else {
+      fs.unlinkSync(envFile);
+    }
+    console.log("Credentials removed");
+  } else {
+    console.log("No credentials found");
+  }
+  console.log("Logged out successfully");
+}
+const LAUNCHD_LABEL = "io.hypha.svamp.daemon";
+async function installDaemonService() {
+  const os = await import('os');
+  const { join, dirname } = await import('path');
+  const fs = await import('fs');
+  const { execSync } = await import('child_process');
+  const svampHome = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
+  const logsDir = join(svampHome, "logs");
+  let svampBinary = process.argv[1];
+  try {
+    const resolved = execSync(`which svamp`, { encoding: "utf-8" }).trim();
+    if (resolved) svampBinary = resolved;
+  } catch {
+  }
+  if (!fs.existsSync(svampBinary)) {
+    console.error(`Cannot find svamp binary at: ${svampBinary}`);
+    console.error("Please install svamp-cli globally first.");
+    process.exit(1);
+  }
+  const nodeBinDir = dirname(process.execPath);
+  const shellPath = process.env.PATH || "";
+  const supervisedPath = shellPath.includes(nodeBinDir) ? shellPath : [nodeBinDir, shellPath].filter(Boolean).join(":");
+  if (!fs.existsSync(logsDir)) fs.mkdirSync(logsDir, { recursive: true });
+  if (process.platform === "darwin") {
+    const launchAgentsDir = join(os.homedir(), "Library", "LaunchAgents");
+    const plistPath = join(launchAgentsDir, `${LAUNCHD_LABEL}.plist`);
+    if (!fs.existsSync(launchAgentsDir)) fs.mkdirSync(launchAgentsDir, { recursive: true });
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${LAUNCHD_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${svampBinary}</string>
+        <string>daemon</string>
+        <string>start-supervised</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${logsDir}/daemon-supervised.log</string>
+    <key>StandardErrorPath</key>
+    <string>${logsDir}/daemon-supervised.log</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${supervisedPath}</string>
+        <key>SVAMP_HOME</key>
+        <string>${svampHome}</string>
+    </dict>
+</dict>
+</plist>
+`;
+    fs.writeFileSync(plistPath, plist, "utf-8");
+    console.log(`Plist written: ${plistPath}`);
+    try {
+      execSync(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "ignore" });
+    } catch {
+    }
+    execSync(`launchctl load "${plistPath}"`);
+    console.log(`
+Svamp daemon service installed and started!`);
+    console.log(`  Service: ${LAUNCHD_LABEL}`);
+    console.log(`  Auto-restart on crash: enabled`);
+    console.log(`  Log file: ${logsDir}/daemon-supervised.log`);
+    console.log(`
+To stop the service:   svamp daemon stop`);
+    console.log(`To uninstall:          svamp daemon uninstall`);
+  } else if (process.platform === "linux") {
+    const hasSystemd = (() => {
+      try {
+        execSync("systemctl --user status 2>/dev/null", { stdio: "pipe" });
+        return true;
+      } catch {
+        return false;
+      }
+    })();
+    if (hasSystemd) {
+      const systemdUserDir = join(os.homedir(), ".config", "systemd", "user");
+      const unitPath = join(systemdUserDir, "svamp-daemon.service");
+      if (!fs.existsSync(systemdUserDir)) fs.mkdirSync(systemdUserDir, { recursive: true });
+      const unit = `[Unit]
+Description=Svamp Daemon \u2014 AI workspace on Hypha Cloud
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+ExecStart=${svampBinary} daemon start-supervised
+Environment=PATH=${supervisedPath}
+Environment=SVAMP_HOME=${svampHome}
+StandardOutput=append:${logsDir}/daemon-supervised.log
+StandardError=append:${logsDir}/daemon-supervised.log
+
+[Install]
+WantedBy=default.target
+`;
+      fs.writeFileSync(unitPath, unit, "utf-8");
+      execSync("systemctl --user daemon-reload");
+      execSync("systemctl --user enable --now svamp-daemon.service");
+      console.log(`
+Svamp daemon service installed and started!`);
+      console.log(`  Service: svamp-daemon.service (systemd user)`);
+      console.log(`  Unit file: ${unitPath}`);
+      console.log(`  Auto-restart on crash: enabled`);
+      console.log(`  Log file: ${logsDir}/daemon-supervised.log`);
+      console.log(`
+To stop the service:   svamp daemon stop`);
+      console.log(`To uninstall:          svamp daemon uninstall`);
+    } else {
+      console.log(`
+No systemd detected. The built-in supervisor is cross-platform.`);
+      console.log(`
+For Docker, set your container CMD to:`);
+      console.log(`  ${svampBinary} daemon start-supervised`);
+      console.log(`
+Or run in the background:`);
+      console.log(`  svamp daemon start`);
+      console.log(`
+To stop the daemon:    svamp daemon stop`);
+    }
+  } else {
+    console.log(`
+The built-in supervisor is cross-platform.`);
+    console.log(`
+Run: svamp daemon start`);
+    console.log(`
+To stop: svamp daemon stop`);
+  }
+}
+async function uninstallDaemonService() {
+  const os = await import('os');
+  const { join } = await import('path');
+  const fs = await import('fs');
+  const { execSync } = await import('child_process');
+  if (process.platform === "darwin") {
+    const plistPath = join(os.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+    if (!fs.existsSync(plistPath)) {
+      console.log("Svamp daemon service is not installed.");
+      return;
+    }
+    try {
+      execSync(`launchctl unload "${plistPath}"`, { stdio: "pipe" });
+    } catch {
+    }
+    fs.unlinkSync(plistPath);
+    console.log("Svamp daemon service uninstalled (launchd).");
+    console.log("The daemon has been stopped and will no longer auto-start.");
+  } else if (process.platform === "linux") {
+    const unitPath = join(os.homedir(), ".config", "systemd", "user", "svamp-daemon.service");
+    const svampHome = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
+    const wrapperPath = join(svampHome, "daemon-supervisor.sh");
+    let removed = false;
+    if (fs.existsSync(unitPath)) {
+      try {
+        execSync("systemctl --user disable --now svamp-daemon.service", { stdio: "pipe" });
+      } catch {
+      }
+      fs.unlinkSync(unitPath);
+      try {
+        execSync("systemctl --user daemon-reload", { stdio: "pipe" });
+      } catch {
+      }
+      console.log("Svamp daemon service uninstalled (systemd).");
+      removed = true;
+    }
+    if (fs.existsSync(wrapperPath)) {
+      fs.unlinkSync(wrapperPath);
+      if (!removed) console.log("Svamp daemon supervisor script removed.");
+      removed = true;
+    }
+    if (!removed) {
+      console.log("Svamp daemon service is not installed.");
+    }
+  } else {
+    console.error(`Daemon service uninstall is not supported on ${process.platform}.`);
+    process.exit(1);
+  }
+}
+function printHelp() {
+  console.log(`
+svamp \u2014 AI workspace on Hypha Cloud
+
+Quick start \u2014 spawn an agent to do a task (use -p bypassPermissions to run autonomously):
+  svamp session spawn claude -d ./project -p bypassPermissions --message "fix tests" --wait
+
+  Note: without -p bypassPermissions the agent PAUSES waiting for human approval of each
+  tool use. This will cause it to hang in automated/agent contexts. Use bypassPermissions
+  for autonomous work, or "default" only when a human is actively watching.
+
+Commands:
+  svamp                              Start interactive Claude session (synced to cloud)
+  svamp login [url]                  Login to Hypha (opens browser, stores token)
+  svamp logout                       Logout (stop daemon, remove credentials)
+  svamp daemon start                 Start the background daemon (required for sessions)
+  svamp daemon status                Show daemon status
+  svamp daemon --help                Show all daemon commands
+
+  Session management (requires daemon running):
+  svamp session spawn <agent> [opts] Spawn a new agent session (agents: claude, gemini, codex)
+  svamp session send <id> <message>  Send message to a session (--wait to block until done)
+  svamp session wait <id>            Wait for agent to become idle
+  svamp session messages <id>        Show message history (--last N, --json, --raw)
+  svamp session info <id>            Show session status & pending permissions
+  svamp session list                 List sessions
+  svamp session stop <id>            Stop a session
+  svamp session attach <id>          Attach interactive terminal (stdin/stdout)
+  svamp session approve/deny <id>    Approve or deny pending permission requests
+  svamp session --help               Show ALL session commands and detailed options
+
+  Other:
+  svamp machine --help               Machine sharing & security contexts
+  svamp skills --help                Skills marketplace (find, install, publish)
+  svamp service --help               Service exposure (HTTP services from sandboxes)
+  svamp agent <name>                 Start local agent session (no daemon needed)
+  svamp --version                    Show version
+
+Interactive mode:
+  Run 'svamp' with no arguments to start Claude in your terminal with cloud sync.
+  Messages from the web app auto-switch to remote mode. Space-Space returns to local.
+
+Environment variables:
+  HYPHA_SERVER_URL     Hypha server URL (required for cloud sync)
+  HYPHA_TOKEN          Hypha auth token (stored by login command)
+  HYPHA_WORKSPACE      Hypha workspace / user ID (stored by login command)
+  SVAMP_HOME           Config directory (default: ~/.svamp)
+`);
+}
+function printDaemonHelp() {
+  console.log(`
+svamp daemon \u2014 Daemon management
+
+Usage:
+  svamp daemon start                  Start the daemon (detached)
+  svamp daemon start --no-auto-continue  Start without auto-continuing interrupted sessions
+  svamp daemon stop                   Stop the daemon (sessions preserved for restart)
+  svamp daemon stop --cleanup         Stop and mark all sessions as stopped
+  svamp daemon restart                Restart daemon (sessions resume seamlessly)
+  svamp daemon status                 Show daemon status
+  svamp daemon install                Install as login service (macOS/Linux) \u2014 auto-start at login
+  svamp daemon uninstall              Remove login service
+`);
+}
+function printSessionHelp() {
+  console.log(`
+svamp session \u2014 Spawn and manage AI agent sessions
+
+QUICK START \u2014 Spawn a session, give it a task, get results:
+
+  # One-liner: spawn agent, send task, wait for completion
+  svamp session spawn claude -d ./my-project -p bypassPermissions \\
+    --message "fix the failing tests" --wait
+
+  # The command prints the session ID (e.g., "abc12345-..."). Use it to:
+  svamp session messages abc1 --last 10         # read output (prefix match on ID)
+  svamp session send abc1 "now run lint" --wait  # send follow-up, wait for done
+  svamp session stop abc1                        # stop when finished
+
+  # Spawn on a remote/cloud machine:
+  svamp session spawn claude -d /workspace -m cloud-box --message "deploy" --wait
+
+AGENTS:
+  claude    Claude Code \u2014 full coding agent (default)
+  gemini    Google Gemini via ACP protocol
+  codex     OpenAI Codex via MCP protocol
+
+  Usage: svamp session spawn <agent> [options]
+  The <agent> argument is required. Use "claude" if unsure.
+
+COMMANDS:
+
+  Lifecycle:
+    spawn <agent> [-d <path>] [options]   Spawn a new agent session
+    stop <id>                             Stop a running session
+    list [--active] [--json]              List sessions (alias: ls)
+    machines                              List discoverable machines
+    info <id> [--json]                    Show status & pending permissions
+
+  Communicate:
+    send <id> <message> [--wait] [--timeout N] [--json]
+                                          Send a message to a running session
+    messages <id> [--last N] [--json]     Read message history (alias: msgs)
+    wait <id> [--timeout N] [--json]      Wait for agent to become idle
+    attach <id>                           Attach interactive terminal (stdin/stdout)
+
+  Permissions (when agent pauses for approval):
+    approve <id> [request-id] [--json]    Approve pending tool permission(s)
+    deny <id> [request-id] [--json]       Deny pending tool permission(s)
+
+  Sharing:
+    share <id> --list                     List shared users
+    share <id> --add <email>[:<role>]     Share with user (role: view|interact|admin)
+    share <id> --remove <email>           Remove shared user
+    share <id> --public <view|interact|off>  Set public link access
+
+  Ralph Loop (iterative automation):
+    ralph-start <id> "<task>" [options]   Start iterative loop
+    ralph-cancel <id>                     Cancel loop
+    ralph-status <id>                     Show loop status
+
+  Inbox:
+    inbox send <id> "<body>" [opts]       Send a message to session inbox
+    inbox list <id> [--unread] [--json]   List inbox messages
+    inbox read <id> <msg-id>              Read and mark a message
+    inbox reply <id> <msg-id> "<body>"    Reply to sender's session
+    inbox clear <id> [--all]              Clear read (or all) messages
+
+SPAWN OPTIONS:
+  -d, --directory <path>          Working directory (REQUIRED for meaningful work)
+  -p, --permission-mode <mode>    Permission mode (see below). Default: "default"
+  --message <msg>                 Send this message to the agent immediately after spawn
+  --wait                          Block until agent finishes (idle). Combine with --message
+                                  for fire-and-forget: spawn \u2192 task \u2192 wait \u2192 done.
+  --timeout <sec>                 Timeout for --wait (default: no timeout)
+  --worktree                      Create isolated git worktree branch (.dev/worktree/<name>)
+  --tags <tag1,tag2>              Comma-separated tags for session grouping
+  --parent <sessionId>            Set parent session (auto-set from SVAMP_SESSION_ID env)
+
+PERMISSION MODES:
+  default              \u26A0 Agent PAUSES and waits for human approval before each tool use.
+                       The agent will be stuck (exit code 2) until you run approve/deny.
+                       DO NOT use default mode in automated pipelines \u2014 the agent will hang.
+  acceptEdits          Auto-approve file edits. Still pauses for bash & dangerous tools.
+  bypassPermissions    Auto-approve everything. No prompts, no pauses. Fully autonomous.
+                       Use this for automation, CI, or when spawning from another agent.
+
+  \u26A1 For agents/scripts: ALWAYS pass -p bypassPermissions unless you have a human
+     monitoring the session who can approve/deny tool requests in real time.
+
+PERMISSION WORKFLOW (only relevant for "default" and "acceptEdits" modes):
+  1. svamp session wait <id> --json    \u2192 exit code 2 means permission pending
+  2. svamp session info <id> --json    \u2192 shows pendingPermissions array
+  3. svamp session approve <id>        \u2192 approve all pending (or approve <id> <rid>)
+  4. svamp session deny <id>           \u2192 deny all pending (or deny <id> <rid>)
+
+ISOLATION & SHARING OPTIONS (for spawn):
+  --isolate                       Force OS-level sandbox (even without sharing)
+  --security-context <path>       Apply security context config (JSON file)
+  --share <email>[:<role>]        Share session (repeatable). Role: view|interact|admin
+  --deny-network                  Block all network access
+  --deny-read <path>              Deny reading path (repeatable)
+  --allow-write <path>            Allow writing path (repeatable)
+  --allow-domain <domain>         Allow network domain (repeatable)
+
+MESSAGES OPTIONS:
+  --last N       Show last N messages only
+  --after N      Start after sequence number N (for pagination)
+  --limit N      Max messages to fetch (default: 1000)
+  --json         Output as JSON array of {id, seq, role, text, createdAt}
+  --raw          With --json: include full raw objects (tool_use, tool_result, thinking)
+
+RALPH LOOP OPTIONS (for ralph-start):
+  --context-mode <mode>           fresh (new process each iteration) or continue (same process)
+  --completion-promise <text>     Completion signal text (default: DONE)
+  --max-iterations <n>            Max iterations (default: 10)
+  --cooldown <sec>                Delay between iterations (default: 1)
+
+EXIT CODES (for wait, send --wait, spawn --wait):
+  0   Agent is idle (task completed successfully)
+  1   Error (timeout, connection failure, session not found)
+  2   Agent is waiting for permission approval \u2014 use approve/deny to unblock
+
+ATTACH COMMANDS (inside an attached session):
+  /quit, /detach    Detach (session keeps running)
+  /abort, /cancel   Cancel current agent turn
+  /kill             Stop the session entirely
+  /info             Show session status
+
+GLOBAL OPTIONS:
+  --machine <id>, -m <id>   Target a specific machine (prefix match supported)
+
+ID MATCHING:
+  Session and machine IDs support prefix matching.
+  "abc1" matches "abc12345-6789-..." \u2014 you only need enough characters to be unique.
+
+EXAMPLES:
+
+  # === Common: Spawn agent to do a task and wait ===
+  svamp session spawn claude -d ./my-project -p bypassPermissions \\
+    --message "fix all TypeScript errors, run tsc to verify" --wait
+
+  # === Multi-step: Spawn, then send messages interactively ===
+  ID=$(svamp session spawn claude -d ./proj -p bypassPermissions)
+  svamp session send $ID "first, read the README" --wait
+  svamp session send $ID "now implement the feature described there" --wait
+  svamp session messages $ID --last 20
+
+  # === Spawn child session from another agent (e.g., in a bash tool) ===
+  # Use -p bypassPermissions so the child doesn't get stuck on approvals.
+  # Use --wait so your script blocks until the child finishes.
+  svamp session spawn claude -d /tmp/test-project -p bypassPermissions \\
+    --message "run the test suite and report results" --wait
+  # Then read the child's output:
+  svamp session messages <child-id> --last 5
+
+  # === Monitor with permissions (default mode) ===
+  svamp session spawn claude -d ./proj --message "refactor auth module"
+  svamp session wait abc1 --json       # exit code 2 = permission pending
+  svamp session approve abc1           # approve all pending
+  svamp session wait abc1              # wait for completion
+
+  # === Spawn on a remote machine ===
+  svamp session spawn claude -d /workspace -m my-cloud-box \\
+    -p bypassPermissions --message "deploy to staging" --wait
+
+  # === Isolated session with network restrictions ===
+  svamp session spawn claude -d /tmp/sandbox --isolate --deny-network
+
+  # === Ralph Loop: iterative task automation ===
+  svamp session ralph-start abc1 "Fix all linting errors" \\
+    --context-mode fresh --max-iterations 10
+`);
+}
+function printMachineHelp() {
+  console.log(`
+svamp machine \u2014 Machine management
+
+Usage:
+  svamp machine info                                 Show machine info & status
+  svamp machine exec <command> [--cwd <path>]        Run command on machine
+  svamp machine ls [path] [--hidden]                 List directory on machine
+  svamp machine share --list                         List shared users
+  svamp machine share --add <email>[:<role>]         Share machine with user
+  svamp machine share --remove <email>               Remove shared user
+  svamp machine share --config <path>                Apply security context config
+  svamp machine share --show-config                  Show current security context config
+
+Options:
+  --machine <id>, -m <id>  Target a specific machine (prefix match supported)
+  --cwd <path>             Working directory for exec (default: home dir)
+  --hidden, -a             Show hidden files in ls
+
+Examples:
+  svamp machine info
+  svamp machine exec "ls -la /tmp"
+  svamp machine exec "df -h" -m cloud-box --cwd /
+  svamp machine ls /home/user/projects
+  svamp machine ls --hidden -m cloud-box
+  svamp machine share --add alice@example.com:admin
+  svamp machine share --config ./security-context.json
+`);
+}
+function printSkillsHelp() {
+  console.log(`
+svamp skills \u2014 Agent skills marketplace
+
+Usage:
+  svamp skills find <query> [--json]              Search for skills in the marketplace
+  svamp skills install <name> [--force]           Install skill to ~/.claude/skills/<name>/
+  svamp skills list                               List locally installed skills
+  svamp skills remove <name>                      Remove an installed skill
+  svamp skills publish <path> [--version <tag>]   Publish a skill to the marketplace
+
+Skills are stored in ~/.claude/skills/ and automatically detected by Claude Code.
+Each skill contains a SKILL.md file with instructions and metadata.
+Skills use git-backed storage \u2014 you can also clone and push via git.
+
+Browse online: https://hypha.aicell.io/hypha-cloud/artifacts/marketplace
+
+Examples:
+  svamp skills find "code review"
+  svamp skills install code-review
+  svamp skills publish ./my-skill/
+  svamp skills publish ./my-skill/ --version v1.0
+`);
+}
+function printInteractiveHelp() {
+  console.log(`
+svamp \u2014 Interactive Claude session with cloud sync
+
+Usage:
+  svamp [-d <path>] [--resume <id>] [--continue] [--permission-mode <mode>] [-- <claude-args>]
+  svamp start [-d <path>] [...]
+
+Options:
+  -d, --directory <path>     Working directory (default: cwd)
+  -r, --resume <id>          Resume a Claude session by ID
+  -c, --continue             Continue the last Claude session
+  -p, --permission-mode <m>  Permission mode: default, acceptEdits, bypassPermissions, plan
+  --                         Pass remaining args to Claude CLI
+
+Modes:
+  Local mode    Full interactive Claude terminal UI (default)
+  Remote mode   Processes messages from the web app
+
+Switching:
+  When a message arrives from the web app \u2192 automatically switches to remote mode
+  Space Space   Switch from remote mode back to local mode
+  Ctrl-C Ctrl-C Exit from remote mode
+
+The session is synced to Hypha Cloud so it's visible in the web app.
+Works offline if no Hypha credentials are configured.
+`);
+}
+function printAgentHelp() {
+  console.log(`
+svamp agent \u2014 Interactive agent sessions (local, no daemon required)
+
+Usage:
+  svamp agent list                 List known 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 codex                Start Codex agent
+  svamp agent -- mycli --acp       Start custom ACP-compatible agent
+
+Known agents: gemini (ACP), codex (MCP)
+`);
+}
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});