svamp-cli 0.1.50 → 0.1.52

package/dist/{run-Bc83CRUn.mjs → run-eYBOEaWw.mjs}

@@ -3872,7 +3872,9 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
         maxIterations: state.max_iterations,
         currentIteration: state.iteration,
         startedAt: state.started_at,
-        cooldownSeconds: state.cooldown_seconds
+        cooldownSeconds: state.cooldown_seconds,
+        contextMode: state.context_mode || "fresh",
+        lastIterationStartedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       if (!prevRalph?.active) {
         const progressRelPath = `.svamp/${sessionId}/ralph-progress.md`;
@@ -3897,7 +3899,7 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
         );
         logger.log(`[svampConfig] Ralph loop started: "${state.task.slice(0, 50)}..."`);
         onRalphLoopActivated?.();
-      } else if (prevRalph.currentIteration !== ralphLoop.currentIteration) {
+      } else if (prevRalph.currentIteration !== ralphLoop.currentIteration || prevRalph.task !== ralphLoop.task) {
         setMetadata((m) => ({ ...m, ralphLoop }));
         sessionService.updateMetadata(getMetadata());
       }
@@ -3947,12 +3949,14 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
     if ("ralph_loop" in patch) {
       const rl = patch.ralph_loop;
       if (rl && typeof rl === "object" && typeof rl.task === "string") {
+        const contextMode = rl.context_mode === "fresh" || rl.context_mode === "continue" ? rl.context_mode : void 0;
         writeRalphState(ralphStatePath, {
           iteration: rl.current_iteration || 1,
           max_iterations: typeof rl.max_iterations === "number" ? rl.max_iterations : 0,
           completion_promise: rl.completion_promise || "DONE",
           cooldown_seconds: typeof rl.cooldown_seconds === "number" ? rl.cooldown_seconds : 1,
           started_at: rl.started_at || (/* @__PURE__ */ new Date()).toISOString(),
+          context_mode: contextMode,
           task: rl.task.trim()
         });
         ralphChecker();
@@ -4085,9 +4089,16 @@ function buildRalphPrompt(task, state) {
     return task;
   }
   const iterStr = state.max_iterations > 0 ? `${state.iteration}/${state.max_iterations}` : `${state.iteration}`;
-  return task + `
-
-[Ralph iteration ${iterStr} \u2014 to complete: output <promise>${state.completion_promise}</promise> ONLY when truly done]`;
+  const reminder = [
+    "<system-reminder>",
+    `Ralph Loop \u2014 Iteration ${iterStr} (Continue Mode)`,
+    "Your conversation history persists. Continue from where you left off.",
+    `To signal completion, output EXACTLY: <promise>${state.completion_promise}</promise>`,
+    "Only output the promise when the task is FULLY and PERMANENTLY complete.",
+    "Do NOT output a false promise to exit the loop.",
+    "</system-reminder>"
+  ].join("\n");
+  return task + "\n\n" + reminder;
 }
 function getRalphProgressFilePath(directory, sessionId) {
   return join(getSessionDir(directory, sessionId), "ralph-progress.md");
@@ -4902,7 +4913,9 @@ The automated loop has finished. Review the progress above and let me know if yo
                             maxIterations: rlState.max_iterations,
                             currentIteration: nextIteration,
                             startedAt: rlState.started_at,
-                            cooldownSeconds: rlState.cooldown_seconds
+                            cooldownSeconds: rlState.cooldown_seconds,
+                            contextMode: rlState.context_mode || "fresh",
+                            lastIterationStartedAt: (/* @__PURE__ */ new Date()).toISOString()
                           };
                           sessionMetadata = { ...sessionMetadata, ralphLoop };
                           sessionService.updateMetadata(sessionMetadata);
@@ -5782,7 +5795,9 @@ The automated loop has finished. Review the progress above and let me know if yo
                 maxIterations: rlState.max_iterations,
                 currentIteration: nextIteration,
                 startedAt: rlState.started_at,
-                cooldownSeconds: rlState.cooldown_seconds
+                cooldownSeconds: rlState.cooldown_seconds,
+                contextMode: rlState.context_mode || "fresh",
+                lastIterationStartedAt: (/* @__PURE__ */ new Date()).toISOString()
               };
               sessionMetadata = { ...sessionMetadata, ralphLoop };
               sessionService.updateMetadata(sessionMetadata);

package/dist/tunnel-C2_V6y3d.mjs

@@ -0,0 +1,299 @@
+import * as os from 'os';
+import { r as requireSandboxApiEnv } from './commands-DwY2B7KW.mjs';
+import { WebSocket } from 'ws';
+
+class TunnelClient {
+  ws = null;
+  options;
+  env;
+  sandboxId;
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 20;
+  destroyed = false;
+  pingInterval = null;
+  requestCount = 0;
+  localWebSockets = /* @__PURE__ */ new Map();
+  // request_id → local WS connection
+  constructor(options) {
+    this.options = {
+      localHost: "localhost",
+      requestTimeout: 3e4,
+      ...options
+    };
+    this.env = options.env || requireSandboxApiEnv();
+    this.sandboxId = options.sandboxId || this.env.sandboxId || `local-${os.hostname()}-${process.pid}`;
+  }
+  /** Build the WebSocket URL for the tunnel endpoint. */
+  buildWsUrl() {
+    const baseUrl = this.env.apiUrl.replace(/\/+$/, "");
+    const wsBase = baseUrl.replace(/^http/, "ws");
+    const ns = this.env.namespace || "_tunnel";
+    const params = new URLSearchParams({
+      token: this.env.apiKey,
+      sandbox_id: this.sandboxId
+    });
+    return `${wsBase}/services/${ns}/${this.options.name}/tunnel?${params}`;
+  }
+  /** Connect to the tunnel endpoint. */
+  async connect() {
+    if (this.destroyed) return;
+    const url = this.buildWsUrl();
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new WebSocket(url);
+      } catch (err) {
+        reject(new Error(`Failed to create WebSocket: ${err.message}`));
+        return;
+      }
+      this.ws.on("open", () => {
+        this.reconnectAttempts = 0;
+        this.startPingInterval();
+        this.options.onConnect?.();
+        resolve();
+      });
+      this.ws.on("message", (data) => {
+        const raw = typeof data === "string" ? data : data.toString("utf8");
+        this.handleMessage(raw);
+      });
+      this.ws.on("close", () => {
+        this.stopPingInterval();
+        this.cleanupLocalWebSockets();
+        this.options.onDisconnect?.();
+        if (!this.destroyed) {
+          this.scheduleReconnect();
+        }
+      });
+      this.ws.on("error", (err) => {
+        this.options.onError?.(err);
+        if (this.reconnectAttempts === 0) {
+          reject(err);
+        }
+      });
+    });
+  }
+  /** Disconnect and stop reconnecting. */
+  destroy() {
+    this.destroyed = true;
+    this.stopPingInterval();
+    this.cleanupLocalWebSockets();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  /** Number of HTTP requests proxied. */
+  get totalRequests() {
+    return this.requestCount;
+  }
+  /** Number of active WebSocket connections being proxied. */
+  get activeWebSockets() {
+    return this.localWebSockets.size;
+  }
+  // ── Message handling ────────────────────────────────────────────────
+  handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    switch (msg.type) {
+      case "ping":
+        this.send({ type: "pong" });
+        break;
+      case "request":
+        this.options.onRequest?.(msg);
+        this.proxyRequest(msg).catch((err) => {
+          this.options.onError?.(err);
+        });
+        break;
+      case "ws_open":
+        this.handleWsOpen(msg).catch((err) => {
+          this.options.onError?.(err);
+        });
+        break;
+      case "ws_data":
+        this.handleWsData(msg);
+        break;
+      case "ws_close":
+        this.handleWsClose(msg);
+        break;
+    }
+  }
+  async proxyRequest(req) {
+    this.requestCount++;
+    const port = req.port || this.options.ports[0];
+    const url = `http://${this.options.localHost}:${port}${req.path}`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.options.requestTimeout);
+    const init = {
+      method: req.method,
+      headers: req.headers,
+      signal: controller.signal
+    };
+    if (req.body && !["GET", "HEAD"].includes(req.method.toUpperCase())) {
+      init.body = Buffer.from(req.body, "base64");
+    }
+    try {
+      const res = await fetch(url, init);
+      clearTimeout(timeout);
+      const bodyBuffer = await res.arrayBuffer();
+      const bodyBase64 = bodyBuffer.byteLength > 0 ? Buffer.from(bodyBuffer).toString("base64") : void 0;
+      const headers = {};
+      res.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+      this.send({
+        type: "response",
+        id: req.id,
+        status: res.status,
+        headers,
+        body: bodyBase64
+      });
+    } catch (err) {
+      clearTimeout(timeout);
+      if (err.name === "AbortError") {
+        this.send({
+          type: "response",
+          id: req.id,
+          status: 504,
+          headers: { "content-type": "text/plain" },
+          body: Buffer.from("Tunnel: request timeout").toString("base64")
+        });
+      } else {
+        this.send({
+          type: "response",
+          id: req.id,
+          status: 502,
+          headers: { "content-type": "text/plain" },
+          body: Buffer.from(`Tunnel: local service error: ${err.message}`).toString("base64")
+        });
+      }
+    }
+  }
+  // ── WebSocket proxying ───────────────────────────────────────────────
+  async handleWsOpen(msg) {
+    const port = msg.port || this.options.ports[0];
+    const localUrl = `ws://${this.options.localHost}:${port}${msg.path}`;
+    try {
+      const localWs = new WebSocket(localUrl, {
+        headers: msg.headers
+      });
+      this.localWebSockets.set(msg.id, localWs);
+      localWs.on("message", (data, isBinary) => {
+        const encoded = typeof data === "string" ? Buffer.from(data).toString("base64") : (data instanceof Buffer ? data : Buffer.from(data)).toString("base64");
+        this.send({
+          type: "ws_data",
+          id: msg.id,
+          data: encoded,
+          is_text: !isBinary
+        });
+      });
+      localWs.on("close", (code) => {
+        this.localWebSockets.delete(msg.id);
+        this.send({ type: "ws_close", id: msg.id, code: code || 1e3 });
+      });
+      localWs.on("error", () => {
+        this.localWebSockets.delete(msg.id);
+        this.send({ type: "ws_close", id: msg.id, code: 1011 });
+      });
+    } catch {
+      this.send({ type: "ws_close", id: msg.id, code: 1011 });
+    }
+  }
+  handleWsData(msg) {
+    const localWs = this.localWebSockets.get(msg.id);
+    if (!localWs || localWs.readyState !== WebSocket.OPEN) return;
+    const buf = Buffer.from(msg.data, "base64");
+    if (msg.is_text) {
+      localWs.send(buf.toString("utf8"));
+    } else {
+      localWs.send(buf);
+    }
+  }
+  handleWsClose(msg) {
+    const localWs = this.localWebSockets.get(msg.id);
+    if (localWs) {
+      this.localWebSockets.delete(msg.id);
+      localWs.close(msg.code || 1e3);
+    }
+  }
+  cleanupLocalWebSockets() {
+    for (const [id, ws] of this.localWebSockets) {
+      ws.close(1001);
+    }
+    this.localWebSockets.clear();
+  }
+  // ── WebSocket helpers ───────────────────────────────────────────────
+  send(msg) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  startPingInterval() {
+    this.stopPingInterval();
+    this.pingInterval = setInterval(() => {
+      this.send({ type: "ping" });
+    }, 3e4);
+  }
+  stopPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      this.options.onError?.(new Error(
+        `Tunnel disconnected: max reconnect attempts (${this.maxReconnectAttempts}) reached`
+      ));
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts - 1), 3e4);
+    setTimeout(() => {
+      if (!this.destroyed) {
+        this.connect().catch((err) => {
+          this.options.onError?.(err);
+        });
+      }
+    }, delay);
+  }
+}
+async function runTunnel(name, ports) {
+  const portList = ports.join(", ");
+  const client = new TunnelClient({
+    name,
+    ports,
+    onConnect: () => {
+      console.log(`Tunnel connected: ${name} \u2192 localhost:[${portList}]`);
+    },
+    onDisconnect: () => {
+      console.log("Tunnel disconnected, reconnecting...");
+    },
+    onRequest: (req) => {
+      console.log(`  ${req.method} :${req.port || ports[0]}${req.path}`);
+    },
+    onError: (err) => {
+      console.error(`Tunnel error: ${err.message}`);
+    }
+  });
+  const cleanup = () => {
+    console.log("\nTunnel shutting down...");
+    client.destroy();
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  try {
+    await client.connect();
+    console.log(`Tunnel is active. Press Ctrl+C to stop.`);
+    await new Promise(() => {
+    });
+  } catch (err) {
+    console.error(`Failed to establish tunnel: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+export { TunnelClient, runTunnel };

package/package.json

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