svamp-cli 0.1.76 → 0.1.78

package/dist/staticServer-CWcmMF5V.mjs

@@ -0,0 +1,477 @@
+import * as http from 'http';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as net from 'net';
+
+const MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".htm": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".xml": "application/xml; charset=utf-8",
+  ".csv": "text/csv; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".md": "text/markdown; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".eot": "application/vnd.ms-fontobject",
+  ".pdf": "application/pdf",
+  ".zip": "application/zip",
+  ".gz": "application/gzip",
+  ".tar": "application/x-tar",
+  ".wasm": "application/wasm",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mp3": "audio/mpeg",
+  ".ogg": "audio/ogg",
+  ".wav": "audio/wav",
+  ".yaml": "text/yaml; charset=utf-8",
+  ".yml": "text/yaml; charset=utf-8",
+  ".toml": "text/plain; charset=utf-8"
+};
+function getMimeType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+function setCorsHeaders(res) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, HEAD, POST, DELETE, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "*");
+  res.setHeader("Access-Control-Max-Age", "86400");
+}
+async function findAvailablePort(startPort) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.listen(startPort, "127.0.0.1", () => {
+      const addr = server.address();
+      server.close(() => resolve(addr.port));
+    });
+    server.on("error", () => {
+      if (startPort < 65535) {
+        findAvailablePort(startPort + 1).then(resolve, reject);
+      } else {
+        reject(new Error("No available ports"));
+      }
+    });
+  });
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+function getFileIcon(name, isDir) {
+  if (isDir) return "&#128193;";
+  const ext = path.extname(name).toLowerCase();
+  const imageExts = [".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".avif", ".ico"];
+  const codeExts = [".js", ".mjs", ".ts", ".tsx", ".jsx", ".py", ".go", ".rs", ".c", ".cpp", ".h", ".java", ".rb", ".sh", ".css", ".html", ".htm", ".xml", ".yaml", ".yml", ".toml", ".json"];
+  const docExts = [".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx", ".md", ".txt", ".csv"];
+  const archiveExts = [".zip", ".gz", ".tar", ".rar", ".7z"];
+  const videoExts = [".mp4", ".webm", ".avi", ".mov"];
+  const audioExts = [".mp3", ".ogg", ".wav", ".flac"];
+  if (imageExts.includes(ext)) return "&#128444;";
+  if (codeExts.includes(ext)) return "&#128196;";
+  if (docExts.includes(ext)) return "&#128203;";
+  if (archiveExts.includes(ext)) return "&#128230;";
+  if (videoExts.includes(ext)) return "&#127909;";
+  if (audioExts.includes(ext)) return "&#127925;";
+  return "&#128196;";
+}
+function generateDirectoryListing(dirPath, urlPath) {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  const items = entries.sort((a, b) => {
+    if (a.isDirectory() && !b.isDirectory()) return -1;
+    if (!a.isDirectory() && b.isDirectory()) return 1;
+    return a.name.localeCompare(b.name);
+  }).map((entry) => {
+    const isDir = entry.isDirectory();
+    const name = isDir ? `${entry.name}/` : entry.name;
+    const href = path.posix.join(urlPath, entry.name) + (isDir ? "/" : "");
+    let size = "";
+    let mtime = "";
+    if (!isDir) {
+      try {
+        const stat = fs.statSync(path.join(dirPath, entry.name));
+        size = formatSize(stat.size);
+        mtime = stat.mtime.toISOString().slice(0, 16).replace("T", " ");
+      } catch {
+      }
+    }
+    const icon = getFileIcon(entry.name, isDir);
+    return { name, href, size, mtime, icon, isDir, rawName: entry.name };
+  });
+  const rows = items.map((item) => {
+    const downloadBtn = !item.isDir ? `<a class="act-btn download-btn" href="${escapeHtml(item.href)}" download title="Download">&#11015;</a>` : "";
+    const menuBtn = `<button class="act-btn menu-btn" data-path="${escapeHtml(item.href)}" data-name="${escapeHtml(item.rawName)}" data-isdir="${item.isDir}" title="More actions">&#8943;</button>`;
+    return `<tr>
+<td class="icon-cell">${item.icon}</td>
+<td class="name-cell"><a href="${escapeHtml(item.href)}">${escapeHtml(item.name)}</a></td>
+<td class="size-cell">${item.size}</td>
+<td class="date-cell">${item.mtime}</td>
+<td class="action-cell">${downloadBtn}${menuBtn}</td>
+</tr>`;
+  }).join("\n");
+  const parentRow = urlPath !== "/" ? `<tr><td class="icon-cell">&#128193;</td><td class="name-cell"><a href="${escapeHtml(path.posix.dirname(urlPath))}/">..</a></td><td></td><td></td><td></td></tr>
+` : "";
+  return `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Index of ${escapeHtml(urlPath)}</title>
+<style>
+*{box-sizing:border-box;margin:0;padding:0}
+body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;color:#24292f;background:#fff;padding:24px;max-width:960px;margin:0 auto}
+h1{font-size:1.25rem;font-weight:600;margin-bottom:16px;padding-bottom:8px;border-bottom:1px solid #d0d7de}
+table{width:100%;border-collapse:collapse}
+tr{border-bottom:1px solid #eaeef2}
+tr:hover{background:#f6f8fa}
+td{padding:8px 12px;vertical-align:middle}
+.icon-cell{width:32px;text-align:center;font-size:1.1rem}
+.name-cell a{text-decoration:none;color:#0969da;font-weight:500}
+.name-cell a:hover{text-decoration:underline}
+.size-cell{width:80px;text-align:right;color:#656d76;font-size:0.85rem}
+.date-cell{width:140px;color:#656d76;font-size:0.85rem}
+.action-cell{width:70px;text-align:right;white-space:nowrap}
+.act-btn{background:none;border:none;cursor:pointer;padding:4px 6px;border-radius:4px;color:#656d76;font-size:1rem;text-decoration:none;display:inline-block;line-height:1}
+.act-btn:hover{background:#eaeef2;color:#24292f}
+.download-btn{font-size:0.85rem}
+
+/* Drop zone */
+#drop-overlay{display:none;position:fixed;inset:0;background:rgba(9,105,218,0.08);border:3px dashed #0969da;z-index:1000;align-items:center;justify-content:center;pointer-events:none}
+#drop-overlay.active{display:flex}
+#drop-overlay .label{background:#0969da;color:#fff;padding:12px 24px;border-radius:8px;font-size:1.1rem;font-weight:600}
+
+/* Upload progress */
+#upload-bar{display:none;position:fixed;bottom:0;left:0;right:0;background:#f6f8fa;border-top:1px solid #d0d7de;padding:12px 24px;z-index:999;font-size:0.9rem}
+#upload-bar.active{display:block}
+#upload-bar .bar{height:4px;background:#d0d7de;border-radius:2px;margin-top:8px;overflow:hidden}
+#upload-bar .bar .fill{height:100%;background:#0969da;transition:width 0.2s}
+
+/* Context menu */
+#ctx-menu{display:none;position:fixed;background:#fff;border:1px solid #d0d7de;border-radius:8px;box-shadow:0 8px 24px rgba(31,35,40,0.12);padding:4px 0;z-index:2000;min-width:160px}
+#ctx-menu.active{display:block}
+#ctx-menu button{display:flex;align-items:center;gap:8px;width:100%;background:none;border:none;padding:8px 16px;text-align:left;cursor:pointer;font-size:0.9rem;color:#24292f}
+#ctx-menu button:hover{background:#f6f8fa}
+#ctx-menu button.danger{color:#cf222e}
+#ctx-menu button.danger:hover{background:#fff1f0}
+#ctx-menu .divider{height:1px;background:#d0d7de;margin:4px 0}
+
+/* Toast */
+#toast{display:none;position:fixed;bottom:24px;left:50%;transform:translateX(-50%);background:#24292f;color:#fff;padding:8px 20px;border-radius:6px;font-size:0.85rem;z-index:3000}
+#toast.active{display:block}
+</style>
+</head><body>
+<h1>Index of ${escapeHtml(urlPath)}</h1>
+<table><thead><tr><th></th><th>Name</th><th style="text-align:right">Size</th><th>Modified</th><th></th></tr></thead>
+<tbody>${parentRow}${rows}</tbody></table>
+
+<div id="drop-overlay"><div class="label">Drop files to upload</div></div>
+<div id="upload-bar"><span id="upload-status">Uploading...</span><div class="bar"><div class="fill" id="upload-fill" style="width:0%"></div></div></div>
+<div id="ctx-menu">
+  <button id="ctx-download">&#11015; Download</button>
+  <button id="ctx-copy">&#128203; Copy path</button>
+  <div class="divider"></div>
+  <button id="ctx-delete" class="danger">&#128465; Delete</button>
+</div>
+<div id="toast"></div>
+
+<script>
+(function(){
+  const currentPath = ${JSON.stringify(urlPath)};
+  const dropOverlay = document.getElementById('drop-overlay');
+  const uploadBar = document.getElementById('upload-bar');
+  const uploadFill = document.getElementById('upload-fill');
+  const uploadStatus = document.getElementById('upload-status');
+  const ctxMenu = document.getElementById('ctx-menu');
+  const toast = document.getElementById('toast');
+  let ctxTarget = null;
+  let dragCounter = 0;
+
+  // Toast
+  function showToast(msg, ms) {
+    toast.textContent = msg;
+    toast.classList.add('active');
+    setTimeout(() => toast.classList.remove('active'), ms || 2000);
+  }
+
+  // Context menu
+  document.querySelectorAll('.menu-btn').forEach(btn => {
+    btn.addEventListener('click', (e) => {
+      e.stopPropagation();
+      ctxTarget = { path: btn.dataset.path, name: btn.dataset.name, isDir: btn.dataset.isdir === 'true' };
+      const rect = btn.getBoundingClientRect();
+      ctxMenu.style.top = rect.bottom + 4 + 'px';
+      ctxMenu.style.left = Math.min(rect.left, window.innerWidth - 180) + 'px';
+      ctxMenu.classList.add('active');
+      document.getElementById('ctx-download').style.display = ctxTarget.isDir ? 'none' : '';
+    });
+  });
+
+  document.addEventListener('click', () => ctxMenu.classList.remove('active'));
+
+  document.getElementById('ctx-copy').addEventListener('click', () => {
+    if (!ctxTarget) return;
+    const fullPath = new URL(ctxTarget.path, location.href).pathname;
+    navigator.clipboard.writeText(fullPath).then(() => showToast('Path copied'));
+  });
+
+  document.getElementById('ctx-download').addEventListener('click', () => {
+    if (!ctxTarget || ctxTarget.isDir) return;
+    const a = document.createElement('a');
+    a.href = ctxTarget.path;
+    a.download = ctxTarget.name;
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+  });
+
+  document.getElementById('ctx-delete').addEventListener('click', async () => {
+    if (!ctxTarget) return;
+    const label = ctxTarget.isDir ? 'directory' : 'file';
+    if (!confirm('Delete ' + label + ' "' + ctxTarget.name + '"?')) return;
+    try {
+      const res = await fetch(ctxTarget.path, { method: 'DELETE' });
+      if (res.ok) {
+        showToast('Deleted ' + ctxTarget.name);
+        setTimeout(() => location.reload(), 500);
+      } else {
+        const text = await res.text();
+        alert('Delete failed: ' + text);
+      }
+    } catch(err) {
+      alert('Delete failed: ' + err.message);
+    }
+  });
+
+  // Drag and drop
+  document.addEventListener('dragenter', (e) => {
+    e.preventDefault();
+    dragCounter++;
+    dropOverlay.classList.add('active');
+  });
+  document.addEventListener('dragleave', (e) => {
+    e.preventDefault();
+    dragCounter--;
+    if (dragCounter <= 0) { dragCounter = 0; dropOverlay.classList.remove('active'); }
+  });
+  document.addEventListener('dragover', (e) => e.preventDefault());
+  document.addEventListener('drop', async (e) => {
+    e.preventDefault();
+    dragCounter = 0;
+    dropOverlay.classList.remove('active');
+
+    const items = e.dataTransfer.items;
+    if (!items || items.length === 0) return;
+
+    // Collect all files (including from folder drops via webkitGetAsEntry)
+    const files = [];
+    const promises = [];
+    for (let i = 0; i < items.length; i++) {
+      const entry = items[i].webkitGetAsEntry ? items[i].webkitGetAsEntry() : null;
+      if (entry) {
+        promises.push(traverseEntry(entry, '', files));
+      } else if (items[i].kind === 'file') {
+        const f = items[i].getAsFile();
+        if (f) files.push({ file: f, relativePath: f.name });
+      }
+    }
+    await Promise.all(promises);
+    if (files.length === 0) return;
+
+    // Upload sequentially with progress
+    uploadBar.classList.add('active');
+    for (let i = 0; i < files.length; i++) {
+      const { file, relativePath } = files[i];
+      uploadStatus.textContent = 'Uploading ' + (i+1) + '/' + files.length + ': ' + relativePath;
+      uploadFill.style.width = Math.round((i / files.length) * 100) + '%';
+      const uploadPath = currentPath.replace(/\\/$/, '') + '/' + relativePath;
+      await uploadFile(uploadPath, file);
+    }
+    uploadFill.style.width = '100%';
+    uploadStatus.textContent = 'Done \u2014 ' + files.length + ' file(s) uploaded';
+    setTimeout(() => { uploadBar.classList.remove('active'); location.reload(); }, 1000);
+  });
+
+  function traverseEntry(entry, basePath, results) {
+    return new Promise((resolve) => {
+      if (entry.isFile) {
+        entry.file((f) => {
+          results.push({ file: f, relativePath: basePath ? basePath + '/' + f.name : f.name });
+          resolve();
+        }, () => resolve());
+      } else if (entry.isDirectory) {
+        const reader = entry.createReader();
+        reader.readEntries(async (entries) => {
+          const subBase = basePath ? basePath + '/' + entry.name : entry.name;
+          await Promise.all(entries.map(e => traverseEntry(e, subBase, results)));
+          resolve();
+        }, () => resolve());
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  async function uploadFile(urlPath, file) {
+    const res = await fetch(urlPath, { method: 'POST', body: file,
+      headers: { 'Content-Type': 'application/octet-stream' }
+    });
+    if (!res.ok) throw new Error('Upload failed: ' + (await res.text()));
+  }
+})();
+<\/script>
+</body></html>`;
+}
+function collectBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+function resolveSafePath(rootDir, urlPath) {
+  const decodedPath = decodeURIComponent(urlPath);
+  const normalizedPath = path.normalize(decodedPath);
+  if (normalizedPath.includes("..")) return null;
+  const filePath = path.join(rootDir, normalizedPath);
+  if (!filePath.startsWith(rootDir)) return null;
+  return filePath;
+}
+async function startStaticServer(options) {
+  const { directory, listing = true } = options;
+  const rootDir = path.resolve(directory);
+  if (!fs.existsSync(rootDir) || !fs.statSync(rootDir).isDirectory()) {
+    throw new Error(`Not a directory: ${rootDir}`);
+  }
+  const server = http.createServer(async (req, res) => {
+    setCorsHeaders(res);
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url || "/", `http://localhost`);
+    const filePath = resolveSafePath(rootDir, url.pathname);
+    if (!filePath) {
+      res.writeHead(403, { "Content-Type": "text/plain" });
+      res.end("Forbidden");
+      return;
+    }
+    if (req.method === "DELETE") {
+      try {
+        if (!fs.existsSync(filePath)) {
+          res.writeHead(404, { "Content-Type": "text/plain" });
+          res.end("Not Found");
+          return;
+        }
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+          fs.rmSync(filePath, { recursive: true, force: true });
+        } else {
+          fs.unlinkSync(filePath);
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ deleted: url.pathname }));
+      } catch (err) {
+        res.writeHead(500, { "Content-Type": "text/plain" });
+        res.end(`Delete failed: ${err.message}`);
+      }
+      return;
+    }
+    if (req.method === "POST") {
+      try {
+        const parentDir = path.dirname(filePath);
+        fs.mkdirSync(parentDir, { recursive: true });
+        const body = await collectBody(req);
+        fs.writeFileSync(filePath, body);
+        res.writeHead(201, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ uploaded: url.pathname, size: body.length }));
+      } catch (err) {
+        res.writeHead(500, { "Content-Type": "text/plain" });
+        res.end(`Upload failed: ${err.message}`);
+      }
+      return;
+    }
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      res.writeHead(405, { "Content-Type": "text/plain" });
+      res.end("Method Not Allowed");
+      return;
+    }
+    try {
+      const stat = fs.statSync(filePath);
+      const decodedPath = decodeURIComponent(url.pathname);
+      if (stat.isDirectory()) {
+        const indexPath = path.join(filePath, "index.html");
+        if (fs.existsSync(indexPath) && fs.statSync(indexPath).isFile()) {
+          serveFile(indexPath, req, res);
+        } else if (listing) {
+          if (!decodedPath.endsWith("/")) {
+            res.writeHead(301, { Location: decodedPath + "/" });
+            res.end();
+            return;
+          }
+          const html = generateDirectoryListing(filePath, decodedPath);
+          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(html);
+        } else {
+          res.writeHead(404, { "Content-Type": "text/plain" });
+          res.end("Not Found");
+        }
+      } else if (stat.isFile()) {
+        serveFile(filePath, req, res);
+      } else {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not Found");
+      }
+    } catch {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found");
+    }
+  });
+  const port = await findAvailablePort(options.port || 18080);
+  return new Promise((resolve, reject) => {
+    server.listen(port, "127.0.0.1", () => {
+      resolve({
+        server,
+        port,
+        close: () => server.close()
+      });
+    });
+    server.on("error", reject);
+  });
+}
+function serveFile(filePath, req, res) {
+  const stat = fs.statSync(filePath);
+  const contentType = getMimeType(filePath);
+  res.writeHead(200, {
+    "Content-Type": contentType,
+    "Content-Length": stat.size,
+    "Cache-Control": "no-cache"
+  });
+  if (req.method === "HEAD") {
+    res.end();
+    return;
+  }
+  const stream = fs.createReadStream(filePath);
+  stream.pipe(res);
+  stream.on("error", () => {
+    res.end();
+  });
+}
+
+export { startStaticServer };

package/dist/{tunnel-C2kqST5d.mjs → tunnel-BDKdemh0.mjs}

@@ -2,15 +2,20 @@ import * as os from 'os';
 import { requireSandboxApiEnv } from './api-BRbsyqJ4.mjs';
 import { WebSocket } from 'ws';
 
+const PING_INTERVAL_MS = 3e4;
+const PONG_TIMEOUT_MS = 1e4;
+const DEFAULT_MAX_RECONNECT_ATTEMPTS = 20;
 class TunnelClient {
   ws = null;
   options;
   env;
   sandboxId;
   reconnectAttempts = 0;
-  maxReconnectAttempts = 20;
+  maxReconnects;
   destroyed = false;
-  pingInterval = null;
+  pingTimer = null;
+  pongTimeoutTimer = null;
+  lastPongAt = 0;
   requestCount = 0;
   localWebSockets = /* @__PURE__ */ new Map();
   // request_id → local WS connection
@@ -22,6 +27,7 @@ class TunnelClient {
       requestTimeout: 12e4,
       ...options
     };
+    this.maxReconnects = options.maxReconnectAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS;
     this.env = options.env || requireSandboxApiEnv();
     this.sandboxId = options.sandboxId || this.env.sandboxId || `local-${os.hostname()}-${process.pid}`;
   }
@@ -52,6 +58,7 @@ class TunnelClient {
       }
       this.ws.on("open", () => {
         this.reconnectAttempts = 0;
+        this.lastPongAt = Date.now();
         this.startPingInterval();
         this.options.onConnect?.();
         resolve();
@@ -99,6 +106,20 @@ class TunnelClient {
   get activeWebSockets() {
     return this.localWebSockets.size;
   }
+  /** Whether the tunnel WebSocket is currently open. */
+  get isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  /** Snapshot of tunnel health for external monitoring. */
+  get status() {
+    return {
+      connected: this.ws?.readyState === WebSocket.OPEN,
+      reconnectAttempts: this.reconnectAttempts,
+      lastPongAt: this.lastPongAt,
+      totalRequests: this.requestCount,
+      activeWebSockets: this.localWebSockets.size
+    };
+  }
   // ── Message handling ────────────────────────────────────────────────
   handleMessage(raw) {
     let msg;
@@ -112,6 +133,10 @@ class TunnelClient {
       case "ping":
         this.send({ type: "pong" });
         break;
+      case "pong":
+        this.lastPongAt = Date.now();
+        this.clearPongTimeout();
+        break;
       case "request":
         this.options.onRequest?.(msg);
         if (msg.has_body) {
@@ -274,20 +299,37 @@ class TunnelClient {
   }
   startPingInterval() {
     this.stopPingInterval();
-    this.pingInterval = setInterval(() => {
+    this.pingTimer = setInterval(() => {
       this.send({ type: "ping" });
-    }, 3e4);
+      this.schedulePongTimeout();
+    }, PING_INTERVAL_MS);
   }
   stopPingInterval() {
-    if (this.pingInterval) {
-      clearInterval(this.pingInterval);
-      this.pingInterval = null;
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+    this.clearPongTimeout();
+  }
+  schedulePongTimeout() {
+    this.clearPongTimeout();
+    this.pongTimeoutTimer = setTimeout(() => {
+      this.options.onError?.(new Error("Tunnel: pong timeout \u2014 connection stale"));
+      if (this.ws) {
+        this.ws.terminate();
+      }
+    }, PONG_TIMEOUT_MS);
+  }
+  clearPongTimeout() {
+    if (this.pongTimeoutTimer) {
+      clearTimeout(this.pongTimeoutTimer);
+      this.pongTimeoutTimer = null;
     }
   }
   scheduleReconnect() {
-    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+    if (this.maxReconnects > 0 && this.reconnectAttempts >= this.maxReconnects) {
       this.options.onError?.(new Error(
-        `Tunnel disconnected: max reconnect attempts (${this.maxReconnectAttempts}) reached`
+        `Tunnel disconnected: max reconnect attempts (${this.maxReconnects}) reached`
       ));
       return;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svamp-cli",
-  "version": "0.1.76",
+  "version": "0.1.78",
   "description": "Svamp CLI — AI workspace daemon on Hypha Cloud",
   "author": "Amun AI AB",
   "license": "SEE LICENSE IN LICENSE",
@@ -30,7 +30,7 @@
     "@agentclientprotocol/sdk": "^0.14.1",
     "@modelcontextprotocol/sdk": "^1.25.3",
     "hypha-rpc": "0.21.34",
-    "node-pty": "^1.1.0",
+    "node-pty": "1.2.0-beta.11",
     "ws": "^8.18.0",
     "yaml": "^2.8.2",
     "zod": "^3.24.4"