svamp-cli 0.2.257 → 0.2.259

package/dist/{scheduler-Dbqmnd_o.mjs → scheduler-CN8jChyQ.mjs}

@@ -1,4 +1,4 @@
-import { n as resolveProjectRoot, H as listWorkflows, I as isWorkflowEnabled, J as workflowCrons, C as runWorkflow, K as cronMatches } from './run-BtGnnEMI.mjs';
+import { n as resolveProjectRoot, H as listWorkflows, I as isWorkflowEnabled, J as workflowCrons, C as runWorkflow, K as cronMatches } from './run-CT8Leg3-.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -14,10 +14,7 @@ import 'node:path';
 import 'node:events';
 import 'node:os';
 import '@agentclientprotocol/sdk';
-import '@modelcontextprotocol/sdk/client/index.js';
-import '@modelcontextprotocol/sdk/client/stdio.js';
-import '@modelcontextprotocol/sdk/types.js';
-import 'zod';
+import 'node:readline';
 import 'node:fs/promises';
 import 'node:util';
 import 'yaml';

package/dist/{serveCommands-DueTsJSe.mjs → serveCommands-sWtLnJRW.mjs}

@@ -54,7 +54,7 @@ async function handleServeCommand() {
   }
 }
 async function serveAdd(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-CE1PdEJJ.mjs');
+  const { connectAndGetMachine } = await import('./commands-BtXxn3tI.mjs');
   const pos = positionalArgs(args);
   const name = pos[0];
   if (!name) {
@@ -93,7 +93,7 @@ async function serveAdd(args, machineId) {
   }
 }
 async function serveApply(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-CE1PdEJJ.mjs');
+  const { connectAndGetMachine } = await import('./commands-BtXxn3tI.mjs');
   const fs = await import('fs');
   const yaml = await import('yaml');
   const file = positionalArgs(args)[0];
@@ -182,7 +182,7 @@ async function serveApply(args, machineId) {
   }
 }
 async function serveRemove(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-CE1PdEJJ.mjs');
+  const { connectAndGetMachine } = await import('./commands-BtXxn3tI.mjs');
   const pos = positionalArgs(args);
   const name = pos[0];
   if (!name) {
@@ -202,7 +202,7 @@ async function serveRemove(args, machineId) {
   }
 }
 async function serveList(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-CE1PdEJJ.mjs');
+  const { connectAndGetMachine } = await import('./commands-BtXxn3tI.mjs');
   const all = hasFlag(args, "--all", "-a");
   const json = hasFlag(args, "--json");
   const sessionId = getFlag(args, "--session");
@@ -235,7 +235,7 @@ async function serveList(args, machineId) {
   }
 }
 async function serveInfo(machineId) {
-  const { connectAndGetMachine } = await import('./commands-CE1PdEJJ.mjs');
+  const { connectAndGetMachine } = await import('./commands-BtXxn3tI.mjs');
   const { machine, server } = await connectAndGetMachine(machineId);
   try {
     const info = await machine.serveInfo();

package/dist/{serveManager-BclzoPIb.mjs → serveManager-BuXk1_SH.mjs}

@@ -1,10 +1,11 @@
-import { spawn } from 'child_process';
+import { spawn, execSync } from 'child_process';
 import * as crypto from 'crypto';
 import * as fs from 'fs';
 import * as http from 'http';
 import * as net from 'net';
 import * as path from 'path';
-import { l as getHyphaServerUrl, S as ServeAuth, m as hasCookieToken } from './run-BtGnnEMI.mjs';
+import { serveStaticMount } from './staticFileServer-CbYnj2bH.mjs';
+import { l as getHyphaServerUrl, S as ServeAuth, m as hasCookieToken } from './run-CT8Leg3-.mjs';
 import 'os';
 import 'fs/promises';
 import 'url';
@@ -16,10 +17,7 @@ import 'node:path';
 import 'node:events';
 import 'node:os';
 import '@agentclientprotocol/sdk';
-import '@modelcontextprotocol/sdk/client/index.js';
-import '@modelcontextprotocol/sdk/client/stdio.js';
-import '@modelcontextprotocol/sdk/types.js';
-import 'zod';
+import 'node:readline';
 import 'node:fs/promises';
 import 'node:util';
 import 'yaml';
@@ -56,6 +54,27 @@ async function tryReservePort(preferred) {
     });
   });
 }
+function killOrphanedCaddy(log) {
+  if (process.platform === "win32") return;
+  try {
+    const out = execSync("ps -axo pid=,command=", { encoding: "utf-8" });
+    const pids = [];
+    for (const line of out.split("\n")) {
+      const m = /^\s*(\d+)\s+(.*)$/.exec(line);
+      if (!m) continue;
+      const [, pid, cmd] = m;
+      if (cmd.includes(".svamp/bin/caddy") && pid !== String(process.pid)) pids.push(pid);
+    }
+    for (const pid of pids) {
+      try {
+        process.kill(Number(pid), "SIGKILL");
+      } catch {
+      }
+    }
+    if (pids.length) log(`Reaped ${pids.length} orphaned Caddy process(es) \u2014 retired in favor of the native file server (#0358).`);
+  } catch {
+  }
+}
 const MOUNT_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 function validateMountName(name) {
   if (!name || name.length > 128) {
@@ -68,18 +87,14 @@ function validateMountName(name) {
 class ServeManager {
   mounts = /* @__PURE__ */ new Map();
   port = 0;
-  // auth proxy public port
-  caddyPort = 0;
-  // Caddy internal port
-  /** Last-used ports loaded from disk — used as preferred values on next start
+  // public HTTP server port (serves static files natively — #0358)
+  /** Last-used port loaded from disk — used as the preferred value on next start
    *  so external configs (tunnels, cron, bookmarks) survive daemon restarts. */
   persistedPort;
-  persistedCaddyPort;
   /** Per-mount frpc tunnel — each mount gets its own subdomain `static-<name>-<hash>`. */
   mountTunnels = /* @__PURE__ */ new Map();
   /** hostname (lowercased, no port) → mount name. Updated when tunnels connect. */
   hostToMount = /* @__PURE__ */ new Map();
-  caddy = null;
   proxyServer = null;
   auth = null;
   /** Live child processes for managed mounts. Keyed by mount name. */
@@ -159,9 +174,6 @@ class ServeManager {
     };
     this.mounts.set(spec.name, mount);
     await this.ensureRunning();
-    if (resolvedDir && this.caddy?.isRunning) {
-      await this.caddy.addMount(spec.name, resolvedDir);
-    }
     await this.startMountTunnel(spec.name);
     if (spec.process && !spec.process.wakeOnRequest) {
       try {
@@ -198,13 +210,6 @@ class ServeManager {
     for (const [host, mountName] of this.hostToMount.entries()) {
       if (mountName === name) this.hostToMount.delete(host);
     }
-    if (this.caddy?.isRunning) {
-      try {
-        await this.caddy.removeMount(name);
-      } catch (err) {
-        this.log(`Warning: Caddy mount removal failed: ${err.message}`);
-      }
-    }
     this.persist();
     this.log(`Mount removed: ${name}`);
     if (this.mounts.size === 0) {
@@ -225,12 +230,12 @@ class ServeManager {
    * Get server info — each mount has its own URL (per-mount subdomain).
    */
   getInfo() {
-    const running = this.caddy?.isRunning ?? false;
+    const running = this.proxyServer != null;
     const firstMount = this.mounts.values().next().value;
     const firstUrl = firstMount ? this.getMountUrl(firstMount.name) : null;
     return {
       url: firstUrl,
-      port: running ? this.caddy?.port ?? this.port : 0,
+      port: running ? this.port : 0,
       authProxyPort: running ? this.port : 0,
       running,
       mountCount: this.mounts.size,
@@ -249,7 +254,6 @@ class ServeManager {
       if (!fs.existsSync(this.persistFile)) return;
       const raw = JSON.parse(fs.readFileSync(this.persistFile, "utf-8"));
       this.persistedPort = raw.port;
-      this.persistedCaddyPort = raw.caddyPort;
       if (!raw.mounts || raw.mounts.length === 0) return;
       let restoredCount = 0;
       for (const m of raw.mounts) {
@@ -327,11 +331,6 @@ class ServeManager {
       await new Promise((resolve) => this.proxyServer.close(() => resolve()));
       this.proxyServer = null;
     }
-    if (this.caddy) {
-      await this.caddy.stop();
-      this.caddy = null;
-      this.log("Caddy stopped");
-    }
     this.auth?.destroy();
   }
   // ── Managed-process lifecycle ─────────────────────────────────────────
@@ -488,8 +487,7 @@ class ServeManager {
   persist() {
     const state = {
       mounts: Array.from(this.mounts.values()),
-      ...this.port > 0 ? { port: this.port } : {},
-      ...this.caddyPort > 0 ? { caddyPort: this.caddyPort } : {}
+      ...this.port > 0 ? { port: this.port } : {}
     };
     try {
       fs.writeFileSync(this.persistFile, JSON.stringify(state, null, 2));
@@ -499,32 +497,24 @@ class ServeManager {
   }
   /** Start auth proxy + Caddy if not already running. Per-mount tunnels are started separately. */
   async ensureRunning() {
-    if (this.caddy?.isRunning) return;
-    this.caddyPort = await tryReservePort(this.persistedCaddyPort);
+    if (this.proxyServer) return;
+    killOrphanedCaddy((m) => this.log(m));
     this.port = await tryReservePort(this.persistedPort);
-    const adminPort = await findFreePort();
     if (this.persistedPort && this.port !== this.persistedPort) {
       this.log(`\u26A0 Previous serve port ${this.persistedPort} unavailable \u2014 using ${this.port}. Downstream configs referencing the old port will need updating.`);
     }
-    if (this.persistedCaddyPort && this.caddyPort !== this.persistedCaddyPort) {
-      this.log(`\u26A0 Previous Caddy port ${this.persistedCaddyPort} unavailable \u2014 using ${this.caddyPort} (Caddy is internal; no downstream impact).`);
-    }
-    const { CaddyManager } = await import('./caddy-CuTbE3NY.mjs');
-    this.caddy = new CaddyManager({
-      listenPort: this.caddyPort,
-      adminPort,
-      configDir: path.join(path.dirname(this.persistFile), "caddy"),
-      log: (msg) => this.log(`[Caddy] ${msg}`)
-    });
-    for (const mount of this.mounts.values()) {
-      if (mount.directory) {
-        await this.caddy.addMount(mount.name, mount.directory);
-      }
-    }
-    await this.caddy.start();
-    this.log(`Caddy file server started on 127.0.0.1:${this.caddyPort}`);
     await this.startAuthProxy();
-    this.log(`Auth proxy started on 127.0.0.1:${this.port}`);
+    this.log(`Static file server started on 127.0.0.1:${this.port}`);
+  }
+  /** Minimal mount-listing page for the server root (replaces Caddy's root route). */
+  mountListHtml() {
+    const esc = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+    const items = Array.from(this.mounts.values()).filter((m) => m.directory).map((m) => `<li><a href="/${esc(m.name)}/">${esc(m.name)}</a> \u2014 ${esc(m.directory || "")}</li>`).join("\n");
+    return `<!DOCTYPE html><html><head><meta charset="utf-8"><title>Svamp File Server</title>
+<style>body{font-family:system-ui,sans-serif;max-width:700px;margin:40px auto;padding:0 20px;color:#333}
+h1{font-size:1.3rem}ul{list-style:none;padding:0}li{padding:8px 0;border-bottom:1px solid #eee}
+a{color:#0969da;text-decoration:none;font-weight:500}a:hover{text-decoration:underline}</style></head>
+<body><h1>Svamp File Server</h1><ul>${items || "<li>No mounts registered.</li>"}</ul></body></html>`;
   }
   /** Start a lightweight Node.js HTTP proxy with auth + upload support. */
   startAuthProxy() {
@@ -604,6 +594,21 @@ class ServeManager {
           const base = path.resolve(mount.directory);
           const fp = path.resolve(path.join(base, basePath));
           if (fp !== base && !fp.startsWith(base + path.sep)) return null;
+          try {
+            const realRoot = fs.realpathSync(base);
+            let ancestor = fp;
+            while (!fs.existsSync(ancestor) && path.dirname(ancestor) !== ancestor) {
+              ancestor = path.dirname(ancestor);
+            }
+            const realAncestor = fs.realpathSync(ancestor);
+            if (realAncestor !== realRoot && !realAncestor.startsWith(realRoot + path.sep)) return null;
+            if (fs.existsSync(fp) && fs.lstatSync(fp).isSymbolicLink()) {
+              const realTarget = fs.realpathSync(fp);
+              if (realTarget !== realRoot && !realTarget.startsWith(realRoot + path.sep)) return null;
+            }
+          } catch {
+            return null;
+          }
           return fp;
         };
         if ((req.method === "PUT" || req.method === "DELETE") && mount && mount.directory) {
@@ -658,7 +663,7 @@ class ServeManager {
           const handle = this.managedProcs.get(mount.name);
           if (handle) handle.lastRequestAt = Date.now();
           const targetPath = mountResolvedByHost ? req.url || "/" : (basePath || "/") + (url.search || "");
-          const proxyReq2 = http.request({
+          const proxyReq = http.request({
             hostname: "127.0.0.1",
             port: cfg.port,
             path: targetPath,
@@ -668,37 +673,135 @@ class ServeManager {
             res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
             proxyRes.pipe(res);
           });
-          proxyReq2.on("error", (err) => {
+          proxyReq.on("error", (err) => {
             if (!res.headersSent) {
               res.writeHead(502);
               res.end(`Backend error: ${err.message}`);
             }
           });
-          req.pipe(proxyReq2);
+          const abortUpstream = () => {
+            if (!proxyReq.destroyed) proxyReq.destroy();
+          };
+          req.on("aborted", abortUpstream);
+          res.on("close", () => {
+            if (!res.writableFinished) abortUpstream();
+          });
+          proxyReq.setTimeout(12e4, abortUpstream);
+          req.pipe(proxyReq);
+          return;
+        }
+        if (mount && mount.directory) {
+          serveStaticMount(req, res, {
+            rootDir: mount.directory,
+            relPath: basePath || "/",
+            // Path-based access is prefixed with /<mountName>; host-based has no prefix.
+            mountUrlPrefix: mountResolvedByHost ? "" : `/${mountName}`,
+            browse: true});
           return;
         }
-        let proxyPath = req.url || "/";
-        if (mountResolvedByHost && mountName) {
-          const search = url.search || "";
-          proxyPath = `/${mountName}${basePath === "/" ? "/" : basePath}${search}`;
+        const cors = { "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Methods": "GET, HEAD, OPTIONS", "Access-Control-Allow-Headers": "*" };
+        if (url.pathname === "/" || basePath === "/") {
+          res.writeHead(200, { ...cors, "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" });
+          res.end(this.mountListHtml());
+        } else {
+          res.writeHead(404, { ...cors, "Content-Type": "text/plain" });
+          res.end("Not found");
         }
-        const proxyReq = http.request({
-          hostname: "127.0.0.1",
-          port: this.caddyPort,
-          path: proxyPath,
-          method: req.method,
-          headers: req.headers
-        }, (proxyRes) => {
-          res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
-          proxyRes.pipe(res);
-        });
-        proxyReq.on("error", (err) => {
-          if (!res.headersSent) {
-            res.writeHead(502);
-            res.end("Proxy error");
+      });
+      server.on("upgrade", (req, clientSocket, head) => {
+        const deny = (code, reason) => {
+          try {
+            clientSocket.write(`HTTP/1.1 ${code} ${reason}\r
+Connection: close\r
+\r
+`);
+          } catch {
+          }
+          try {
+            clientSocket.destroy();
+          } catch {
+          }
+        };
+        void (async () => {
+          try {
+            const url = new URL(req.url || "/", `http://127.0.0.1:${this.port}`);
+            const incomingHost = (req.headers.host || "").split(":")[0].toLowerCase();
+            const hostMount = this.hostToMount.get(incomingHost);
+            let mountName;
+            let mountResolvedByHost = false;
+            if (hostMount && this.mounts.has(hostMount)) {
+              mountName = hostMount;
+              mountResolvedByHost = true;
+            } else {
+              mountName = url.pathname.split("/").filter(Boolean)[0];
+            }
+            const mount = mountName ? this.mounts.get(mountName) : void 0;
+            if (!mount || !mount.process) {
+              deny(404, "Not Found");
+              return;
+            }
+            if (mount.access !== "public" && mount.access !== "link") {
+              if (mount.access === "owner" && !mount.ownerEmail) {
+                deny(403, "Forbidden");
+                return;
+              }
+              const userEmail = this.auth ? await this.auth.authenticate(req).catch(() => null) : null;
+              const allowed = userEmail && this.auth ? this.auth.isAuthorized(userEmail, mount.access, mount.ownerEmail) : false;
+              if (!allowed) {
+                deny(userEmail ? 403 : 401, userEmail ? "Forbidden" : "Unauthorized");
+                return;
+              }
+            }
+            const cfg = mount.process;
+            if (cfg.wakeOnRequest || !this.managedProcs.has(mount.name)) {
+              try {
+                await this.ensureManagedRunning(mount.name);
+              } catch {
+                deny(503, "Backend Not Ready");
+                return;
+              }
+            }
+            const handle = this.managedProcs.get(mount.name);
+            if (handle) handle.lastRequestAt = Date.now();
+            const targetPath = mountResolvedByHost ? req.url || "/" : (url.pathname.slice(`/${mountName}`.length) || "/") + (url.search || "");
+            const upstream = net.connect(cfg.port, "127.0.0.1", () => {
+              const lines = [`${req.method} ${targetPath} HTTP/1.1`];
+              for (let i = 0; i < req.rawHeaders.length; i += 2) {
+                lines.push(`${req.rawHeaders[i]}: ${req.rawHeaders[i + 1]}`);
+              }
+              upstream.write(lines.join("\r\n") + "\r\n\r\n");
+              if (head && head.length) upstream.write(head);
+              upstream.pipe(clientSocket);
+              clientSocket.pipe(upstream);
+            });
+            const teardown = () => {
+              try {
+                upstream.destroy();
+              } catch {
+              }
+              try {
+                clientSocket.destroy();
+              } catch {
+              }
+            };
+            upstream.on("error", teardown);
+            clientSocket.on("error", teardown);
+            upstream.on("close", () => {
+              try {
+                clientSocket.destroy();
+              } catch {
+              }
+            });
+            clientSocket.on("close", () => {
+              try {
+                upstream.destroy();
+              } catch {
+              }
+            });
+          } catch {
+            deny(500, "Internal Server Error");
           }
-        });
-        req.pipe(proxyReq);
+        })();
       });
       this.proxyServer = server;
       server.listen(this.port, "127.0.0.1", () => resolve());
@@ -751,7 +854,7 @@ class ServeManager {
     const mount = this.mounts.get(mountName);
     const subdomainOverride = mount?.access === "link" && mount.linkToken ? /* @__PURE__ */ new Map([[this.port, buildLinkSubdomain(subdomainSafe, mount.linkToken)]]) : void 0;
     try {
-      const { FrpcTunnel } = await import('./frpc-QESvQN-s.mjs');
+      const { FrpcTunnel } = await import('./frpc-BCOnJSAM.mjs');
       let tunnel;
       tunnel = new FrpcTunnel({
         name: tunnelName,

package/dist/{sideband-C_ifGgde.mjs → sideband-ByYvGtj3.mjs}

@@ -1,4 +1,4 @@
-import { R as READ_ONLY_TOOLS, N as loadMachineContext, O as buildMachineInstructions, P as machineToolsForRole, Q as buildMachineTools } from './run-BtGnnEMI.mjs';
+import { R as READ_ONLY_TOOLS, N as loadMachineContext, O as buildMachineInstructions, P as machineToolsForRole, Q as buildMachineTools } from './run-CT8Leg3-.mjs';
 import 'node:child_process';
 import 'os';
 import 'fs/promises';
@@ -14,10 +14,7 @@ import 'node:path';
 import 'node:events';
 import 'node:os';
 import '@agentclientprotocol/sdk';
-import '@modelcontextprotocol/sdk/client/index.js';
-import '@modelcontextprotocol/sdk/client/stdio.js';
-import '@modelcontextprotocol/sdk/types.js';
-import 'zod';
+import 'node:readline';
 import 'node:fs/promises';
 import 'node:util';
 import 'yaml';