svamp-cli 0.1.33 → 0.1.35

package/dist/cli.mjs

@@ -91,7 +91,7 @@ async function main() {
   } 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-DhEMNA72.mjs').catch(() => ({ default: { version: "unknown" } }));
     console.log(`svamp version: ${pkg.default.version}`);
   } else {
     console.error(`Unknown command: ${subcommand}`);
@@ -100,7 +100,7 @@ async function main() {
   }
 }
 async function handleInteractiveCommand() {
-  const { runInteractive } = await import('./run-COUdcjR7.mjs');
+  const { runInteractive } = await import('./run-CbrQx9o5.mjs');
   const interactiveArgs = subcommand === "start" ? args.slice(1) : args;
   let directory = process.cwd();
   let resumeSessionId;

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/package-DhEMNA72.mjs

@@ -0,0 +1,57 @@
+var name = "svamp-cli";
+var version = "0.1.35";
+var description = "Svamp CLI — AI workspace daemon on Hypha Cloud";
+var author = "Amun AI AB";
+var license = "SEE LICENSE IN LICENSE";
+var type = "module";
+var bin = {
+	svamp: "./bin/svamp.mjs"
+};
+var files = [
+	"dist",
+	"bin"
+];
+var main = "./dist/index.mjs";
+var exports$1 = {
+	".": "./dist/index.mjs",
+	"./cli": "./dist/cli.mjs"
+};
+var scripts = {
+	build: "tsc --noEmit && pkgroll",
+	typecheck: "tsc --noEmit",
+	"test:hypha": "node --no-warnings test/test-hypha-service.mjs",
+	dev: "tsx src/cli.ts",
+	"dev:daemon": "tsx src/cli.ts daemon start-sync",
+	"test:e2e": "node --no-warnings test/e2e-session-tests.mjs"
+};
+var dependencies = {
+	"@agentclientprotocol/sdk": "^0.14.1",
+	"@modelcontextprotocol/sdk": "^1.25.3",
+	"hypha-rpc": "0.21.20",
+	zod: "^3.24.4"
+};
+var devDependencies = {
+	"@types/node": ">=20",
+	pkgroll: "^2.14.2",
+	tsx: "^4.20.6",
+	typescript: "5.9.3"
+};
+var packageManager = "yarn@1.22.22";
+var _package = {
+	name: name,
+	version: version,
+	description: description,
+	author: author,
+	license: license,
+	type: type,
+	bin: bin,
+	files: files,
+	main: main,
+	exports: exports$1,
+	scripts: scripts,
+	dependencies: dependencies,
+	devDependencies: devDependencies,
+	packageManager: packageManager
+};
+
+export { author, bin, _package as default, dependencies, description, devDependencies, exports$1 as exports, files, license, main, name, packageManager, scripts, type, version };

package/dist/{run-DaEcQsPx.mjs → run-4RUIHPcF.mjs}

@@ -224,14 +224,16 @@ async function runLocalMode(opts) {
   if (opts.claudeSessionId) {
     args.push("--resume", opts.claudeSessionId);
   }
-  args.push("--settings", opts.hookSettingsPath);
+  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");
+    process.stderr.write("Claude Code CLI not found. Install with: npm install -g @anthropic-ai/claude-code\n");
     return { type: "exit", code: 1 };
   }
   process.stdin.pause();
@@ -291,14 +293,15 @@ async function runRemoteMode(opts) {
   } catch {
   }
   if (!claudeBin || !existsSync(claudeBin)) {
-    console.error("Claude Code CLI not found.");
+    process.stderr.write("Claude Code CLI not found.\n");
     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");
+  const print = (s) => process.stderr.write(s + "\n");
+  print("\n\x1B[90m" + "\u2550".repeat(50) + "\x1B[0m");
+  print("\x1B[36m  Remote mode\x1B[0m \u2014 processing message from web app");
+  print("\x1B[90m  Press Space Space to switch to local mode\x1B[0m");
+  print("\x1B[90m  Press Ctrl-C Ctrl-C to exit\x1B[0m");
+  print("\x1B[90m" + "\u2550".repeat(50) + "\x1B[0m\n");
   let exitReason = null;
   let lastSpace = 0;
   let lastCtrlC = 0;
@@ -383,7 +386,7 @@ async function runRemoteMode(opts) {
         continue;
       }
       if (!exitReason && !abortController.signal.aborted) {
-        console.log("\n\x1B[90m  Agent idle. Waiting for next message...\x1B[0m");
+        process.stderr.write("\n\x1B[90m  Agent idle. Waiting for next message...\x1B[0m\n");
       }
     }
   } finally {
@@ -401,9 +404,12 @@ async function runClaudeTurn(opts) {
     "--verbose",
     "--input-format",
     "stream-json",
-    "--settings",
-    opts.hookSettingsPath
+    "--permission-prompt-tool",
+    "stdio"
   ];
+  if (opts.hookSettingsPath) {
+    args.push("--settings", opts.hookSettingsPath);
+  }
   if (opts.sessionId) {
     args.push("--resume", opts.sessionId);
   }
@@ -662,17 +668,11 @@ async function runInteractive(options) {
   const token = process.env.HYPHA_TOKEN;
   if (serverUrl && token) {
     try {
-      const origLog = console.log;
-      const origWarn = console.warn;
-      console.log = () => {
-      };
-      console.warn = () => {
-      };
+      suppressHyphaLogs();
       server = await connectToHypha({ serverUrl, token, name: "svamp-interactive" });
-      console.log = origLog;
-      console.warn = origWarn;
       log("Connected to Hypha");
     } catch (err) {
+      restoreConsoleLogs();
       console.error(`\x1B[33mNote:\x1B[0m Could not connect to Hypha (${err.message}). Running in offline mode.`);
     }
   } else {
@@ -715,6 +715,7 @@ async function runInteractive(options) {
     lifecycleState: "running",
     flavor: "claude"
   };
+  let currentMode = "local";
   if (server) {
     const callbacks = {
       onUserMessage: (content, _meta) => {
@@ -751,6 +752,7 @@ async function runInteractive(options) {
       );
       log(`Session service registered: svamp-session-${sessionId}`);
     } catch (err) {
+      restoreConsoleLogs();
       console.error(`\x1B[33mNote:\x1B[0m Could not register session on Hypha (${err.message}).`);
     }
   }
@@ -778,6 +780,7 @@ async function runInteractive(options) {
   }
   const cleanup = async () => {
     log("Cleaning up...");
+    restoreConsoleLogs();
     if (keepAliveInterval) clearInterval(keepAliveInterval);
     if (sessionService) {
       sessionService.sendSessionEnd();
@@ -808,12 +811,14 @@ async function runInteractive(options) {
   if (options.resumeSessionId) ; else if (options.continueSession) {
     claudeArgs.push("--continue");
   }
+  restoreConsoleLogs();
   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("");
+  if (server) suppressHyphaLogs();
   try {
     const exitCode = await loop({
       cwd,
@@ -824,7 +829,11 @@ async function runInteractive(options) {
       log,
       onModeChange: (mode) => {
         log(`Mode changed: ${mode}`);
+        currentMode = mode;
         if (sessionService) {
+          sessionService.updateAgentState({
+            controlledByUser: mode === "local"
+          });
           sessionService.updateMetadata({ ...metadata, lifecycleState: "running" });
           sessionService.sendKeepAlive(false, mode);
         }
@@ -888,5 +897,68 @@ function readMachineId() {
     return null;
   }
 }
+let _origLog = null;
+let _origWarn = null;
+let _origInfo = null;
+let _origStdoutWrite = null;
+const HYPHA_LOG_PATTERNS = [
+  "WebSocket connection",
+  "Connection established",
+  "reporting services",
+  "Successfully registered",
+  "Subscribing to",
+  "Successfully subscribed",
+  "Cleaning up all sessions",
+  "Cleaned up session",
+  "ClTaned up",
+  "Cleaned up ",
+  "Handling disconnection",
+  "Client ws-user-",
+  "WebSocket connection disconnected",
+  "disconnected, cleaning up",
+  "HYPHA SESSION",
+  "Listener registered",
+  "local RPC disconnection"
+];
+function isHyphaLogLine(text) {
+  return HYPHA_LOG_PATTERNS.some((p) => text.includes(p));
+}
+function suppressHyphaLogs() {
+  if (_origLog) return;
+  _origLog = console.log;
+  _origWarn = console.warn;
+  _origInfo = console.info;
+  _origStdoutWrite = process.stdout.write.bind(process.stdout);
+  console.log = (...args) => {
+    if (DEBUG) _origLog.call(console, "[hypha-log]", ...args);
+  };
+  console.warn = (...args) => {
+    if (DEBUG) _origWarn.call(console, "[hypha-warn]", ...args);
+  };
+  console.info = (...args) => {
+    if (DEBUG) _origInfo.call(console, "[hypha-info]", ...args);
+  };
+  process.stdout.write = function(chunk, ...rest) {
+    const text = typeof chunk === "string" ? chunk : chunk?.toString?.() || "";
+    if (isHyphaLogLine(text)) {
+      if (DEBUG) _origStdoutWrite(`[hypha-stdout] ${text}`);
+      return true;
+    }
+    return _origStdoutWrite.call(process.stdout, chunk, ...rest);
+  };
+}
+function restoreConsoleLogs() {
+  if (!_origLog) return;
+  console.log = _origLog;
+  console.warn = _origWarn;
+  console.info = _origInfo;
+  if (_origStdoutWrite) {
+    process.stdout.write = _origStdoutWrite;
+  }
+  _origLog = null;
+  _origWarn = null;
+  _origInfo = null;
+  _origStdoutWrite = null;
+}
 
 export { runInteractive };

package/dist/{run-COUdcjR7.mjs → run-CaGe8FtO.mjs}

@@ -233,7 +233,7 @@ async function runLocalMode(opts) {
   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");
+    process.stderr.write("Claude Code CLI not found. Install with: npm install -g @anthropic-ai/claude-code\n");
     return { type: "exit", code: 1 };
   }
   process.stdin.pause();
@@ -293,14 +293,15 @@ async function runRemoteMode(opts) {
   } catch {
   }
   if (!claudeBin || !existsSync(claudeBin)) {
-    console.error("Claude Code CLI not found.");
+    process.stderr.write("Claude Code CLI not found.\n");
     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");
+  const print = (s) => process.stderr.write(s + "\n");
+  print("\n\x1B[90m" + "\u2550".repeat(50) + "\x1B[0m");
+  print("\x1B[36m  Remote mode\x1B[0m \u2014 processing message from web app");
+  print("\x1B[90m  Press Space Space to switch to local mode\x1B[0m");
+  print("\x1B[90m  Press Ctrl-C Ctrl-C to exit\x1B[0m");
+  print("\x1B[90m" + "\u2550".repeat(50) + "\x1B[0m\n");
   let exitReason = null;
   let lastSpace = 0;
   let lastCtrlC = 0;
@@ -385,7 +386,7 @@ async function runRemoteMode(opts) {
         continue;
       }
       if (!exitReason && !abortController.signal.aborted) {
-        console.log("\n\x1B[90m  Agent idle. Waiting for next message...\x1B[0m");
+        process.stderr.write("\n\x1B[90m  Agent idle. Waiting for next message...\x1B[0m\n");
       }
     }
   } finally {
@@ -667,17 +668,11 @@ async function runInteractive(options) {
   const token = process.env.HYPHA_TOKEN;
   if (serverUrl && token) {
     try {
-      const origLog = console.log;
-      const origWarn = console.warn;
-      console.log = () => {
-      };
-      console.warn = () => {
-      };
+      suppressHyphaLogs();
       server = await connectToHypha({ serverUrl, token, name: "svamp-interactive" });
-      console.log = origLog;
-      console.warn = origWarn;
       log("Connected to Hypha");
     } catch (err) {
+      restoreConsoleLogs();
       console.error(`\x1B[33mNote:\x1B[0m Could not connect to Hypha (${err.message}). Running in offline mode.`);
     }
   } else {
@@ -720,6 +715,7 @@ async function runInteractive(options) {
     lifecycleState: "running",
     flavor: "claude"
   };
+  let currentMode = "local";
   if (server) {
     const callbacks = {
       onUserMessage: (content, _meta) => {
@@ -756,6 +752,7 @@ async function runInteractive(options) {
       );
       log(`Session service registered: svamp-session-${sessionId}`);
     } catch (err) {
+      restoreConsoleLogs();
       console.error(`\x1B[33mNote:\x1B[0m Could not register session on Hypha (${err.message}).`);
     }
   }
@@ -783,6 +780,7 @@ async function runInteractive(options) {
   }
   const cleanup = async () => {
     log("Cleaning up...");
+    restoreConsoleLogs();
     if (keepAliveInterval) clearInterval(keepAliveInterval);
     if (sessionService) {
       sessionService.sendSessionEnd();
@@ -813,12 +811,14 @@ async function runInteractive(options) {
   if (options.resumeSessionId) ; else if (options.continueSession) {
     claudeArgs.push("--continue");
   }
+  restoreConsoleLogs();
   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("");
+  if (server) suppressHyphaLogs();
   try {
     const exitCode = await loop({
       cwd,
@@ -829,7 +829,11 @@ async function runInteractive(options) {
       log,
       onModeChange: (mode) => {
         log(`Mode changed: ${mode}`);
+        currentMode = mode;
         if (sessionService) {
+          sessionService.updateAgentState({
+            controlledByUser: mode === "local"
+          });
           sessionService.updateMetadata({ ...metadata, lifecycleState: "running" });
           sessionService.sendKeepAlive(false, mode);
         }
@@ -893,5 +897,32 @@ function readMachineId() {
     return null;
   }
 }
+let _origLog = null;
+let _origWarn = null;
+let _origInfo = null;
+function suppressHyphaLogs() {
+  if (_origLog) return;
+  _origLog = console.log;
+  _origWarn = console.warn;
+  _origInfo = console.info;
+  console.log = (...args) => {
+    if (DEBUG) _origLog.call(console, "[hypha-log]", ...args);
+  };
+  console.warn = (...args) => {
+    if (DEBUG) _origWarn.call(console, "[hypha-warn]", ...args);
+  };
+  console.info = (...args) => {
+    if (DEBUG) _origInfo.call(console, "[hypha-info]", ...args);
+  };
+}
+function restoreConsoleLogs() {
+  if (!_origLog) return;
+  console.log = _origLog;
+  console.warn = _origWarn;
+  console.info = _origInfo;
+  _origLog = null;
+  _origWarn = null;
+  _origInfo = null;
+}
 
 export { runInteractive };

package/dist/run-CbrQx9o5.mjs

@@ -0,0 +1,964 @@
+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) {
+    process.stderr.write("Claude Code CLI not found. Install with: npm install -g @anthropic-ai/claude-code\n");
+    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)) {
+    process.stderr.write("Claude Code CLI not found.\n");
+    return "exit";
+  }
+  const print = (s) => process.stderr.write(s + "\n");
+  print("\n\x1B[90m" + "\u2550".repeat(50) + "\x1B[0m");
+  print("\x1B[36m  Remote mode\x1B[0m \u2014 processing message from web app");
+  print("\x1B[90m  Press Space Space to switch to local mode\x1B[0m");
+  print("\x1B[90m  Press Ctrl-C Ctrl-C to exit\x1B[0m");
+  print("\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) {
+        process.stderr.write("\n\x1B[90m  Agent idle. Waiting for next message...\x1B[0m\n");
+      }
+    }
+  } 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 {
+      suppressHyphaLogs();
+      server = await connectToHypha({ serverUrl, token, name: "svamp-interactive" });
+      log("Connected to Hypha");
+    } catch (err) {
+      restoreConsoleLogs();
+      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"
+  };
+  let currentMode = "local";
+  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) {
+      restoreConsoleLogs();
+      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;
+    }
+    restoreConsoleLogs();
+  };
+  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");
+  }
+  restoreConsoleLogs();
+  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("");
+  if (server) suppressHyphaLogs();
+  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}`);
+        currentMode = mode;
+        if (sessionService) {
+          sessionService.updateAgentState({
+            controlledByUser: mode === "local"
+          });
+          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;
+  }
+}
+let _origLog = null;
+let _origWarn = null;
+let _origInfo = null;
+let _origStdoutWrite = null;
+const HYPHA_LOG_PATTERNS = [
+  "WebSocket connection",
+  "Connection established",
+  "reporting services",
+  "Successfully registered",
+  "Subscribing to",
+  "Successfully subscribed",
+  "Cleaning up all sessions",
+  "Cleaned up session",
+  "ClTaned up",
+  "Cleaned up ",
+  "Handling disconnection",
+  "Client ws-user-",
+  "WebSocket connection disconnected",
+  "disconnected, cleaning up",
+  "HYPHA SESSION",
+  "Listener registered",
+  "local RPC disconnection"
+];
+function isHyphaLogLine(text) {
+  return HYPHA_LOG_PATTERNS.some((p) => text.includes(p));
+}
+function suppressHyphaLogs() {
+  if (_origLog) return;
+  _origLog = console.log;
+  _origWarn = console.warn;
+  _origInfo = console.info;
+  _origStdoutWrite = process.stdout.write.bind(process.stdout);
+  console.log = (...args) => {
+    if (DEBUG) _origLog.call(console, "[hypha-log]", ...args);
+  };
+  console.warn = (...args) => {
+    if (DEBUG) _origWarn.call(console, "[hypha-warn]", ...args);
+  };
+  console.info = (...args) => {
+    if (DEBUG) _origInfo.call(console, "[hypha-info]", ...args);
+  };
+  process.stdout.write = function(chunk, ...rest) {
+    const text = typeof chunk === "string" ? chunk : chunk?.toString?.() || "";
+    if (isHyphaLogLine(text)) {
+      if (DEBUG) _origStdoutWrite(`[hypha-stdout] ${text}`);
+      return true;
+    }
+    return _origStdoutWrite.call(process.stdout, chunk, ...rest);
+  };
+}
+function restoreConsoleLogs() {
+  if (!_origLog) return;
+  console.log = _origLog;
+  console.warn = _origWarn;
+  console.info = _origInfo;
+  if (_origStdoutWrite) {
+    process.stdout.write = _origStdoutWrite;
+  }
+  _origLog = null;
+  _origWarn = null;
+  _origInfo = null;
+  _origStdoutWrite = null;
+}
+
+export { runInteractive };

package/package.json

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