svamp-cli 0.1.32 → 0.1.34

package/dist/cli.mjs

@@ -86,10 +86,12 @@ async function main() {
     await handleAgentCommand();
   } else if (subcommand === "session") {
     await handleSessionCommand();
-  } else if (subcommand === "--help" || subcommand === "-h" || !subcommand) {
+  } 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-CMmjP_vD.mjs').catch(() => ({ default: { version: "unknown" } }));
+    const pkg = await import('./package-D2n0SOTg.mjs').catch(() => ({ default: { version: "unknown" } }));
     console.log(`svamp version: ${pkg.default.version}`);
   } else {
     console.error(`Unknown command: ${subcommand}`);
@@ -97,6 +99,45 @@ async function main() {
     process.exit(1);
   }
 }
+async function handleInteractiveCommand() {
+  const { runInteractive } = await import('./run-COUdcjR7.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") {
@@ -653,32 +694,36 @@ async function uninstallDaemonService() {
 }
 function printHelp() {
   console.log(`
-svamp \u2014 Svamp CLI with Hypha transport
+svamp \u2014 AI workspace on Hypha Cloud
 
 Usage:
+  svamp                      Start interactive Claude session (synced to cloud)
+  svamp start [-d <path>]    Same as above, with explicit directory
   svamp login [url]          Login to Hypha (opens browser, stores token)
   svamp daemon start         Start the daemon (detached)
   svamp daemon stop          Stop the daemon (sessions preserved for restart)
-  svamp daemon stop --cleanup  Stop and mark all sessions as stopped
   svamp daemon status        Show daemon status
   svamp daemon install       Install as system service (launchd/systemd/wrapper)
-  svamp daemon uninstall     Remove system service
-  svamp session list         List active daemon sessions
-  svamp session machines     List discoverable machines
+  svamp session list         List active sessions
   svamp session spawn        Spawn a new session on the daemon
-  svamp session attach <id>  Attach to a session (interactive)
+  svamp session attach <id>  Attach to a session
   svamp session --help       Show all session commands
   svamp agent list           List known agents
   svamp agent <name>         Start local agent session (gemini, codex)
-  svamp agent -- <cmd>       Start custom ACP agent
   svamp --version            Show version
   svamp --help               Show this help
 
+Interactive mode:
+  When you run 'svamp' with no arguments, Claude starts in your terminal
+  with full interactive access. Your session is synced to Hypha Cloud so
+  it's visible in the web app. When a message arrives from the web app,
+  svamp switches to remote mode to process it, then you can press
+  Space-Space to return to local mode.
+
 Environment variables:
-  HYPHA_SERVER_URL     Hypha server URL (required for daemon)
+  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_MACHINE_ID     Machine identifier (optional, auto-generated)
   SVAMP_HOME           Config directory (default: ~/.svamp)
 `);
 }
@@ -736,6 +781,34 @@ Examples:
   svamp session attach abc12345
 `);
 }
+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)

package/dist/{package-CMmjP_vD.mjs → package-D2n0SOTg.mjs}

@@ -1,5 +1,5 @@
 var name = "svamp-cli";
-var version = "0.1.32";
+var version = "0.1.34";
 var description = "Svamp CLI — AI workspace daemon on Hypha Cloud";
 var author = "Amun AI AB";
 var license = "SEE LICENSE IN LICENSE";

package/dist/run-COUdcjR7.mjs

@@ -0,0 +1,897 @@
+import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import { randomUUID } from 'node:crypto';
+import os from 'node:os';
+import { join, resolve } from 'node:path';
+import { mkdirSync, writeFileSync, existsSync, unlinkSync, readFileSync, watch } from 'node:fs';
+import { c as connectToHypha, a as registerSessionService } from './run-fEuWMTdD.mjs';
+import { createServer } from 'node:http';
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import 'os';
+import 'fs/promises';
+import 'fs';
+import 'path';
+import 'url';
+import 'child_process';
+import 'crypto';
+import '@agentclientprotocol/sdk';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/client/stdio.js';
+import '@modelcontextprotocol/sdk/types.js';
+import 'zod';
+import 'node:fs/promises';
+import 'node:util';
+
+async function startHookServer(onSessionHook, log) {
+  return new Promise((resolve, reject) => {
+    const server = createServer(async (req, res) => {
+      if (req.method === "POST" && req.url === "/hook/session-start") {
+        const timeout = setTimeout(() => {
+          if (!res.headersSent) res.writeHead(408).end("timeout");
+        }, 5e3);
+        try {
+          const chunks = [];
+          for await (const chunk of req) chunks.push(chunk);
+          clearTimeout(timeout);
+          const body = Buffer.concat(chunks).toString("utf-8");
+          log("[hook] Received:", body.slice(0, 200));
+          let data = {};
+          try {
+            data = JSON.parse(body);
+          } catch {
+          }
+          const sessionId = data.session_id || data.sessionId;
+          if (sessionId) {
+            log(`[hook] Session ID: ${sessionId}`);
+            onSessionHook(sessionId);
+          }
+          res.writeHead(200).end("ok");
+        } catch {
+          clearTimeout(timeout);
+          if (!res.headersSent) res.writeHead(500).end("error");
+        }
+        return;
+      }
+      res.writeHead(404).end("not found");
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Failed to get server address"));
+        return;
+      }
+      log(`[hook] Listening on port ${addr.port}`);
+      resolve({ port: addr.port, stop: () => server.close() });
+    });
+    server.on("error", reject);
+  });
+}
+
+const SVAMP_HOME$1 = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
+function generateHookSettings(port) {
+  const hooksDir = join(SVAMP_HOME$1, "tmp", "hooks");
+  mkdirSync(hooksDir, { recursive: true });
+  const forwarderPath = join(hooksDir, `forwarder-${process.pid}.cjs`);
+  const forwarderCode = `#!/usr/bin/env node
+const http = require('http');
+const port = parseInt(process.argv[2], 10);
+if (!port || isNaN(port)) process.exit(1);
+const chunks = [];
+process.stdin.on('data', c => chunks.push(c));
+process.stdin.on('end', () => {
+    const body = Buffer.concat(chunks);
+    const req = http.request({
+        host: '127.0.0.1', port, method: 'POST',
+        path: '/hook/session-start',
+        headers: { 'Content-Type': 'application/json', 'Content-Length': body.length }
+    }, res => res.resume());
+    req.on('error', () => {});
+    req.end(body);
+});
+process.stdin.resume();
+`;
+  writeFileSync(forwarderPath, forwarderCode, { mode: 493 });
+  const settingsPath = join(hooksDir, `session-hook-${process.pid}.json`);
+  const hookCommand = `node "${forwarderPath}" ${port}`;
+  const settings = {
+    hooks: {
+      SessionStart: [
+        {
+          matcher: "*",
+          hooks: [{ type: "command", command: hookCommand }]
+        }
+      ]
+    }
+  };
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  const cleanup = () => {
+    try {
+      if (existsSync(settingsPath)) unlinkSync(settingsPath);
+    } catch {
+    }
+    try {
+      if (existsSync(forwarderPath)) unlinkSync(forwarderPath);
+    } catch {
+    }
+  };
+  return { settingsPath, cleanup };
+}
+
+const INTERNAL_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "file-history-snapshot",
+  "change",
+  "queue-operation"
+]);
+function getProjectDir(workingDirectory) {
+  const projectId = resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(os.homedir(), ".claude");
+  return join(claudeConfigDir, "projects", projectId);
+}
+function createSessionScanner(opts) {
+  const { workingDirectory, onMessage, log } = opts;
+  const projectDir = getProjectDir(workingDirectory);
+  const processedKeys = /* @__PURE__ */ new Set();
+  let currentSessionId = null;
+  let watcher = null;
+  let syncInterval = null;
+  let stopped = false;
+  function messageKey(msg) {
+    if (msg.type === "summary") return `summary:${msg.leafUuid}:${msg.summary}`;
+    return msg.uuid || "";
+  }
+  function readAndSync() {
+    if (stopped || !currentSessionId) return;
+    const filePath = join(projectDir, `${currentSessionId}.jsonl`);
+    if (!existsSync(filePath)) return;
+    let content;
+    try {
+      content = readFileSync(filePath, "utf-8");
+    } catch {
+      return;
+    }
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (parsed.type && INTERNAL_EVENT_TYPES.has(parsed.type)) continue;
+      if (!["user", "assistant", "summary", "system"].includes(parsed.type)) continue;
+      const key = messageKey(parsed);
+      if (!key || processedKeys.has(key)) continue;
+      processedKeys.add(key);
+      onMessage(parsed);
+    }
+  }
+  function startWatching(sessionId) {
+    stopWatching();
+    currentSessionId = sessionId;
+    const filePath = join(projectDir, `${sessionId}.jsonl`);
+    log(`[scanner] Watching: ${filePath}`);
+    readAndSync();
+    try {
+      watcher = watch(filePath, { persistent: false }, () => {
+        readAndSync();
+      });
+      watcher.on("error", () => {
+      });
+    } catch {
+    }
+    syncInterval = setInterval(readAndSync, 2e3);
+  }
+  function stopWatching() {
+    if (watcher) {
+      try {
+        watcher.close();
+      } catch {
+      }
+      watcher = null;
+    }
+    if (syncInterval) {
+      clearInterval(syncInterval);
+      syncInterval = null;
+    }
+  }
+  return {
+    onNewSession(sessionId) {
+      if (sessionId === currentSessionId) return;
+      log(`[scanner] New session: ${sessionId}`);
+      startWatching(sessionId);
+    },
+    sync: readAndSync,
+    cleanup() {
+      stopped = true;
+      stopWatching();
+      if (currentSessionId) readAndSync();
+    }
+  };
+}
+
+async function runLocalMode(opts) {
+  const { cwd, onSessionFound, onMessage, onThinkingChange, log } = opts;
+  const scanner = createSessionScanner({
+    workingDirectory: cwd,
+    onMessage,
+    log
+  });
+  if (opts.claudeSessionId) {
+    scanner.onNewSession(opts.claudeSessionId);
+  }
+  const args = [];
+  if (opts.claudeSessionId) {
+    args.push("--resume", opts.claudeSessionId);
+  }
+  if (opts.hookSettingsPath) {
+    args.push("--settings", opts.hookSettingsPath);
+  }
+  if (opts.claudeArgs) {
+    args.push(...opts.claudeArgs);
+  }
+  log(`[local] Spawning: claude ${args.join(" ")}`);
+  const claudeBin = findClaudeBinary();
+  if (!claudeBin) {
+    console.error("Claude Code CLI not found. Install with: npm install -g @anthropic-ai/claude-code");
+    return { type: "exit", code: 1 };
+  }
+  process.stdin.pause();
+  return new Promise((resolve) => {
+    const child = spawn(claudeBin, args, {
+      stdio: ["inherit", "inherit", "inherit"],
+      cwd,
+      signal: opts.abort,
+      env: process.env
+    });
+    child.on("error", (err) => {
+      log(`[local] Spawn error: ${err.message}`);
+      scanner.cleanup();
+      process.stdin.resume();
+      onThinkingChange(false);
+      if (err.code === "ABORT_ERR" || opts.abort.aborted) {
+        resolve({ type: "switch" });
+      } else {
+        resolve({ type: "exit", code: 1 });
+      }
+    });
+    child.on("exit", (code, signal) => {
+      log(`[local] Claude exited: code=${code}, signal=${signal}`);
+      scanner.cleanup();
+      process.stdin.resume();
+      onThinkingChange(false);
+      if (signal === "SIGTERM" && opts.abort.aborted) {
+        resolve({ type: "switch" });
+      } else {
+        resolve({ type: "exit", code: code ?? 0 });
+      }
+    });
+    if (opts.abort.aborted) {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    }
+  });
+}
+function findClaudeBinary() {
+  try {
+    const { execSync } = require("child_process");
+    const path = execSync("which claude 2>/dev/null", { encoding: "utf-8" }).trim();
+    if (path && existsSync(path)) return path;
+  } catch {
+  }
+  return null;
+}
+
+async function runRemoteMode(opts) {
+  const { cwd, log, onThinkingChange, onMessage } = opts;
+  let claudeBin = null;
+  try {
+    const { execSync } = require("child_process");
+    claudeBin = execSync("which claude 2>/dev/null", { encoding: "utf-8" }).trim();
+  } catch {
+  }
+  if (!claudeBin || !existsSync(claudeBin)) {
+    console.error("Claude Code CLI not found.");
+    return "exit";
+  }
+  console.log("\n\x1B[90m" + "\u2550".repeat(50) + "\x1B[0m");
+  console.log("\x1B[36m  Remote mode\x1B[0m \u2014 processing message from web app");
+  console.log("\x1B[90m  Press Space Space to switch to local mode\x1B[0m");
+  console.log("\x1B[90m  Press Ctrl-C Ctrl-C to exit\x1B[0m");
+  console.log("\x1B[90m" + "\u2550".repeat(50) + "\x1B[0m\n");
+  let exitReason = null;
+  let lastSpace = 0;
+  let lastCtrlC = 0;
+  const DOUBLE_TAP_MS = 2e3;
+  let spaceHintShown = false;
+  let ctrlcHintShown = false;
+  const stdinWasRaw = process.stdin.isRaw;
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  process.stdin.setEncoding("utf8");
+  const keyHandler = (data) => {
+    const now = Date.now();
+    if (data === "") {
+      if (now - lastCtrlC < DOUBLE_TAP_MS) {
+        exitReason = "exit";
+        abortController.abort();
+        return;
+      }
+      lastCtrlC = now;
+      if (!ctrlcHintShown) {
+        ctrlcHintShown = true;
+        process.stdout.write("\n\x1B[33m  Press Ctrl-C again to exit\x1B[0m\n");
+        setTimeout(() => {
+          ctrlcHintShown = false;
+        }, DOUBLE_TAP_MS);
+      }
+      return;
+    }
+    if (data === " ") {
+      if (now - lastSpace < DOUBLE_TAP_MS) {
+        exitReason = "switch";
+        abortController.abort();
+        return;
+      }
+      lastSpace = now;
+      if (!spaceHintShown) {
+        spaceHintShown = true;
+        process.stdout.write("\n\x1B[33m  Press Space again to switch to local mode\x1B[0m\n");
+        setTimeout(() => {
+          spaceHintShown = false;
+        }, DOUBLE_TAP_MS);
+      }
+      return;
+    }
+    lastSpace = 0;
+    lastCtrlC = 0;
+  };
+  process.stdin.on("data", keyHandler);
+  const abortController = new AbortController();
+  if (opts.abort.aborted) {
+    abortController.abort();
+  } else {
+    opts.abort.addEventListener("abort", () => abortController.abort(), { once: true });
+  }
+  try {
+    while (!exitReason && !abortController.signal.aborted) {
+      const message = await Promise.race([
+        opts.nextMessage(),
+        new Promise((_, reject) => {
+          if (abortController.signal.aborted) reject(new Error("aborted"));
+          abortController.signal.addEventListener("abort", () => reject(new Error("aborted")), { once: true });
+        })
+      ]).catch(() => null);
+      if (!message || exitReason || abortController.signal.aborted) break;
+      const turnResult = await runClaudeTurn({
+        claudeBin,
+        cwd,
+        message,
+        sessionId: opts.claudeSessionId,
+        permissionMode: opts.permissionMode,
+        hookSettingsPath: opts.hookSettingsPath,
+        claudeArgs: opts.claudeArgs,
+        signal: abortController.signal,
+        onSessionFound: opts.onSessionFound,
+        onThinkingChange,
+        onMessage,
+        log
+      });
+      if (turnResult === "error") {
+        continue;
+      }
+      if (!exitReason && !abortController.signal.aborted) {
+        console.log("\n\x1B[90m  Agent idle. Waiting for next message...\x1B[0m");
+      }
+    }
+  } finally {
+    process.stdin.removeListener("data", keyHandler);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(stdinWasRaw ?? false);
+    }
+  }
+  return exitReason || "exit";
+}
+async function runClaudeTurn(opts) {
+  const args = [
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--input-format",
+    "stream-json",
+    "--permission-prompt-tool",
+    "stdio"
+  ];
+  if (opts.hookSettingsPath) {
+    args.push("--settings", opts.hookSettingsPath);
+  }
+  if (opts.sessionId) {
+    args.push("--resume", opts.sessionId);
+  }
+  const claudeMode = mapPermissionMode(opts.permissionMode);
+  if (claudeMode) {
+    args.push("--permission-mode", claudeMode);
+  }
+  if (opts.claudeArgs) {
+    args.push(...opts.claudeArgs);
+  }
+  opts.log(`[remote] Spawning: claude ${args.join(" ")}`);
+  const child = spawn(opts.claudeBin, args, {
+    stdio: ["pipe", "pipe", "pipe"],
+    cwd: opts.cwd,
+    env: process.env
+  });
+  const userMsg = JSON.stringify({
+    type: "user",
+    message: { role: "user", content: opts.message }
+  });
+  child.stdin.write(userMsg + "\n");
+  child.stdin.end();
+  opts.onThinkingChange(true);
+  let currentText = "";
+  return new Promise((resolve) => {
+    const abortHandler = () => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    };
+    if (opts.signal.aborted) {
+      abortHandler();
+    } else {
+      opts.signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    const rl = createInterface({ input: child.stdout, crlfDelay: Infinity });
+    rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      let msg;
+      try {
+        msg = JSON.parse(trimmed);
+      } catch {
+        return;
+      }
+      if (msg.type === "control_request") {
+        handleControlRequest(msg, child, opts.log);
+        return;
+      }
+      handleSDKMessage(msg, opts, (text) => {
+        process.stdout.write(text);
+        currentText += text;
+      });
+    });
+    if (child.stderr) {
+      child.stderr.on("data", (data) => {
+        opts.log(`[remote:stderr] ${data.toString().trim()}`);
+      });
+    }
+    child.on("error", (err) => {
+      opts.log(`[remote] Error: ${err.message}`);
+      opts.onThinkingChange(false);
+      if (currentText && !currentText.endsWith("\n")) process.stdout.write("\n");
+      resolve("error");
+    });
+    child.on("exit", (code, signal) => {
+      opts.log(`[remote] Exit: code=${code}, signal=${signal}`);
+      opts.onThinkingChange(false);
+      if (currentText && !currentText.endsWith("\n")) process.stdout.write("\n");
+      resolve(code === 0 || signal === "SIGTERM" ? "ok" : "error");
+    });
+  });
+}
+function handleSDKMessage(msg, opts, write) {
+  switch (msg.type) {
+    case "system": {
+      if (msg.subtype === "init" && msg.session_id) {
+        opts.onSessionFound(msg.session_id);
+      }
+      break;
+    }
+    case "assistant": {
+      const content = msg.message?.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === "text" && block.text) {
+            write(block.text);
+          } else if (block.type === "tool_use") {
+            const argsStr = JSON.stringify(block.input || {}).slice(0, 100);
+            write(`
+\x1B[33m[tool]\x1B[0m ${block.name}(${argsStr})
+`);
+          }
+        }
+      }
+      if (msg.message) {
+        opts.onMessage({ type: "assistant", uuid: msg.uuid || msg.message?.id, message: msg.message });
+      }
+      break;
+    }
+    case "user": {
+      const content = msg.message?.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === "tool_result") {
+            const text = typeof block.content === "string" ? block.content : JSON.stringify(block.content || "");
+            if (text.length > 0) {
+              const preview = text.length > 200 ? text.slice(0, 200) + "..." : text;
+              write(`\x1B[90m[result]\x1B[0m ${preview}
+`);
+            }
+          }
+        }
+      }
+      break;
+    }
+    case "result": {
+      if (msg.result) {
+        write(`
+\x1B[32m[done]\x1B[0m ${msg.result}
+`);
+      }
+      break;
+    }
+    default:
+      opts.log(`[remote] Unknown msg type: ${msg.type}`);
+  }
+}
+function handleControlRequest(msg, child, log) {
+  const request = msg.request;
+  const requestId = msg.request_id;
+  if (request?.subtype === "can_use_tool") {
+    log(`[remote] Auto-approving tool: ${request.tool_name}`);
+    const response = JSON.stringify({
+      type: "control_response",
+      response: {
+        subtype: "success",
+        request_id: requestId,
+        response: {
+          behavior: "allow",
+          updatedInput: request.input
+        }
+      }
+    });
+    try {
+      child.stdin.write(response + "\n");
+    } catch {
+    }
+  }
+}
+function mapPermissionMode(mode) {
+  const map = {
+    "default": "default",
+    "acceptEdits": "acceptEdits",
+    "bypassPermissions": "bypassPermissions",
+    "plan": "plan",
+    "auto-approve-all": "bypassPermissions"
+  };
+  return map[mode] || null;
+}
+
+async function loop(opts) {
+  const { log } = opts;
+  let mode = opts.startingMode;
+  let claudeSessionId = null;
+  const onSessionFound = (id) => {
+    if (id !== claudeSessionId) {
+      log(`[loop] Session ID: ${id}`);
+      claudeSessionId = id;
+      opts.onSessionFound(id);
+    }
+  };
+  while (true) {
+    log(`[loop] Mode: ${mode}`);
+    switch (mode) {
+      case "local": {
+        if (opts.hasRemoteMessage()) {
+          log("[loop] Pending remote message, switching to remote");
+          mode = "remote";
+          opts.onModeChange(mode);
+          break;
+        }
+        const abortController = new AbortController();
+        let messageWatcher = null;
+        messageWatcher = setInterval(() => {
+          if (opts.hasRemoteMessage() && !abortController.signal.aborted) {
+            log("[loop] Remote message received, switching to remote mode");
+            abortController.abort();
+          }
+        }, 500);
+        const result = await runLocalMode({
+          cwd: opts.cwd,
+          claudeSessionId,
+          onSessionFound,
+          onMessage: opts.onMessage,
+          onThinkingChange: opts.onThinkingChange,
+          abort: abortController.signal,
+          hookSettingsPath: opts.hookSettingsPath,
+          claudeArgs: opts.claudeArgs,
+          log
+        });
+        if (messageWatcher) clearInterval(messageWatcher);
+        if (result.type === "switch") {
+          mode = "remote";
+          opts.onModeChange(mode);
+        } else {
+          return result.code;
+        }
+        break;
+      }
+      case "remote": {
+        const abortController = new AbortController();
+        const result = await runRemoteMode({
+          cwd: opts.cwd,
+          claudeSessionId,
+          onSessionFound,
+          onMessage: opts.onMessage,
+          onThinkingChange: opts.onThinkingChange,
+          nextMessage: opts.waitForRemoteMessage,
+          permissionMode: opts.permissionMode,
+          abort: abortController.signal,
+          hookSettingsPath: opts.hookSettingsPath,
+          claudeArgs: opts.claudeArgs,
+          log
+        });
+        if (result === "switch") {
+          mode = "local";
+          opts.onModeChange(mode);
+        } else {
+          return 0;
+        }
+        break;
+      }
+    }
+  }
+}
+
+const SVAMP_HOME = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
+const ENV_FILE = join(SVAMP_HOME, ".env");
+const DAEMON_STATE_FILE = join(SVAMP_HOME, "daemon.state.json");
+const DEBUG = !!process.env.DEBUG;
+const log = (...args) => {
+  if (DEBUG) console.error("[svamp]", ...args);
+};
+async function runInteractive(options) {
+  const cwd = options.directory;
+  const sessionId = randomUUID();
+  const permissionMode = options.permissionMode || "default";
+  log(`Starting interactive session: ${sessionId}`);
+  log(`Directory: ${cwd}`);
+  loadDotEnv();
+  let server = null;
+  let sessionService = null;
+  const serverUrl = process.env.HYPHA_SERVER_URL;
+  const token = process.env.HYPHA_TOKEN;
+  if (serverUrl && token) {
+    try {
+      const origLog = console.log;
+      const origWarn = console.warn;
+      console.log = () => {
+      };
+      console.warn = () => {
+      };
+      server = await connectToHypha({ serverUrl, token, name: "svamp-interactive" });
+      console.log = origLog;
+      console.warn = origWarn;
+      log("Connected to Hypha");
+    } catch (err) {
+      console.error(`\x1B[33mNote:\x1B[0m Could not connect to Hypha (${err.message}). Running in offline mode.`);
+    }
+  } else {
+    console.error("\x1B[33mNote:\x1B[0m No Hypha credentials found. Running in offline mode.");
+    console.error('  Run "svamp login <url>" to enable cloud sync.\n');
+  }
+  const messageQueue = [];
+  let messageWaiter = null;
+  function enqueueMessage(text) {
+    if (messageWaiter) {
+      const w = messageWaiter;
+      messageWaiter = null;
+      w.resolve(text);
+    } else {
+      messageQueue.push(text);
+    }
+  }
+  function waitForRemoteMessage() {
+    if (messageQueue.length > 0) {
+      return Promise.resolve(messageQueue.shift());
+    }
+    return new Promise((resolve) => {
+      messageWaiter = { resolve };
+    });
+  }
+  function hasRemoteMessage() {
+    return messageQueue.length > 0;
+  }
+  const machineId = readMachineId();
+  const metadata = {
+    path: cwd,
+    host: os.hostname(),
+    os: os.platform(),
+    machineId: machineId || void 0,
+    homeDir: os.homedir(),
+    svampHomeDir: SVAMP_HOME,
+    svampLibDir: "",
+    svampToolsDir: "",
+    startedBy: "terminal",
+    lifecycleState: "running",
+    flavor: "claude"
+  };
+  if (server) {
+    const callbacks = {
+      onUserMessage: (content, _meta) => {
+        const text = typeof content === "string" ? content : content?.text || content?.content?.text || JSON.stringify(content);
+        log(`[hypha] User message received: ${text.slice(0, 80)}`);
+        enqueueMessage(text);
+      },
+      onAbort: () => {
+        log("[hypha] Abort requested");
+      },
+      onPermissionResponse: (_params) => {
+        log("[hypha] Permission response");
+      },
+      onSwitchMode: (mode) => {
+        log(`[hypha] Switch mode: ${mode}`);
+      },
+      onRestartClaude: async () => {
+        log("[hypha] Restart requested");
+        return { success: false, message: "Restart not supported in interactive mode" };
+      },
+      onKillSession: () => {
+        log("[hypha] Kill requested");
+        cleanup();
+        process.exit(0);
+      }
+    };
+    try {
+      sessionService = await registerSessionService(
+        server,
+        sessionId,
+        metadata,
+        { controlledByUser: true },
+        callbacks
+      );
+      log(`Session service registered: svamp-session-${sessionId}`);
+    } catch (err) {
+      console.error(`\x1B[33mNote:\x1B[0m Could not register session on Hypha (${err.message}).`);
+    }
+  }
+  let hookServer = null;
+  let hookSettings = null;
+  let claudeSessionId = options.resumeSessionId || null;
+  try {
+    hookServer = await startHookServer((id) => {
+      claudeSessionId = id;
+      log(`Claude session ID from hook: ${id}`);
+      if (sessionService) {
+        sessionService.updateMetadata({ ...metadata, claudeSessionId: id });
+      }
+    }, log);
+    hookSettings = generateHookSettings(hookServer.port);
+    log(`Hook settings: ${hookSettings.settingsPath}`);
+  } catch (err) {
+    log(`Failed to start hook server: ${err.message}`);
+  }
+  let keepAliveInterval = null;
+  if (sessionService) {
+    keepAliveInterval = setInterval(() => {
+      sessionService.sendKeepAlive(false);
+    }, 3e4);
+  }
+  const cleanup = async () => {
+    log("Cleaning up...");
+    if (keepAliveInterval) clearInterval(keepAliveInterval);
+    if (sessionService) {
+      sessionService.sendSessionEnd();
+      await sessionService.disconnect().catch(() => {
+      });
+    }
+    hookSettings?.cleanup();
+    hookServer?.stop();
+    if (server) {
+      await server.disconnect().catch(() => {
+      });
+    }
+    if (messageWaiter) {
+      messageWaiter.resolve(null);
+      messageWaiter = null;
+    }
+  };
+  let exiting = false;
+  const handleExit = async () => {
+    if (exiting) return;
+    exiting = true;
+    await cleanup();
+    process.exit(0);
+  };
+  process.on("SIGTERM", handleExit);
+  process.on("SIGINT", handleExit);
+  const claudeArgs = [...options.claudeArgs || []];
+  if (options.resumeSessionId) ; else if (options.continueSession) {
+    claudeArgs.push("--continue");
+  }
+  console.log(`\x1B[36mSvamp interactive mode\x1B[0m`);
+  if (server && sessionService) {
+    console.log(`\x1B[90mSession synced to Hypha \u2014 visible in the web app\x1B[0m`);
+    console.log(`\x1B[90mSession ID: ${sessionId.slice(0, 8)}\x1B[0m`);
+  }
+  console.log("");
+  try {
+    const exitCode = await loop({
+      cwd,
+      startingMode: "local",
+      hookSettingsPath: hookSettings?.settingsPath || "",
+      permissionMode,
+      claudeArgs: claudeArgs.length > 0 ? claudeArgs : void 0,
+      log,
+      onModeChange: (mode) => {
+        log(`Mode changed: ${mode}`);
+        if (sessionService) {
+          sessionService.updateMetadata({ ...metadata, lifecycleState: "running" });
+          sessionService.sendKeepAlive(false, mode);
+        }
+      },
+      onSessionFound: (id) => {
+        claudeSessionId = id;
+        if (sessionService) {
+          sessionService.updateMetadata({ ...metadata, claudeSessionId: id });
+        }
+      },
+      onMessage: (msg) => {
+        if (!sessionService) return;
+        if (msg.type === "assistant" && msg.message) {
+          sessionService.pushMessage(msg.message, "agent");
+        } else if (msg.type === "user" && msg.message) {
+          const text = typeof msg.message.content === "string" ? msg.message.content : msg.message.content?.text || JSON.stringify(msg.message.content);
+          sessionService.pushMessage({ type: "text", text }, "user");
+        } else if (msg.type === "summary") {
+          sessionService.updateMetadata({
+            ...metadata,
+            claudeSessionId: claudeSessionId || void 0,
+            summary: { text: msg.summary || "", updatedAt: Date.now() }
+          });
+        }
+      },
+      onThinkingChange: (thinking) => {
+        if (sessionService) {
+          sessionService.sendKeepAlive(thinking);
+        }
+      },
+      waitForRemoteMessage,
+      hasRemoteMessage
+    });
+    await cleanup();
+    process.exit(exitCode);
+  } catch (err) {
+    log(`Loop error: ${err.message}`);
+    await cleanup();
+    process.exit(1);
+  }
+}
+function loadDotEnv() {
+  if (!existsSync(ENV_FILE)) return;
+  const lines = readFileSync(ENV_FILE, "utf-8").split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    const value = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, "");
+    if (!process.env[key]) process.env[key] = value;
+  }
+}
+function readMachineId() {
+  try {
+    if (!existsSync(DAEMON_STATE_FILE)) return null;
+    const state = JSON.parse(readFileSync(DAEMON_STATE_FILE, "utf-8"));
+    return state.machineId || null;
+  } catch {
+    return null;
+  }
+}
+
+export { runInteractive };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svamp-cli",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "description": "Svamp CLI — AI workspace daemon on Hypha Cloud",
   "author": "Amun AI AB",
   "license": "SEE LICENSE IN LICENSE",