svamp-cli 0.2.45 → 0.2.47

package/dist/{run-DZhogQUH.mjs → run-DR7E3IZL.mjs}

@@ -1,8 +1,8 @@
 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-D59qJKn_.mjs';
+import { resolve, join } from 'node:path';
+import { existsSync, readFileSync, watch } from 'node:fs';
+import { c as connectToHypha, a as registerSessionService, h as generateHookSettings } from './run-6umeTX-K.mjs';
 import { createServer } from 'node:http';
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
@@ -66,56 +66,6 @@ async function startHookServer(onSessionHook, log) {
   });
 }
 
-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",

package/dist/{serveCommands-DtKlt1DY.mjs → serveCommands-FUE8m232.mjs}

@@ -45,6 +45,8 @@ async function handleServeCommand() {
     await serveInfo(machineId);
   } else if (sub === "add") {
     await serveAdd(filteredArgs.slice(1), machineId);
+  } else if (sub === "apply") {
+    await serveApply(filteredArgs.slice(1), machineId);
   } else if (sub && !sub.startsWith("-")) {
     await serveAdd(filteredArgs, machineId);
   } else {
@@ -52,7 +54,7 @@ async function handleServeCommand() {
   }
 }
 async function serveAdd(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-Cd_I1MXo.mjs');
+  const { connectAndGetMachine } = await import('./commands-JWrmpGcs.mjs');
   const pos = positionalArgs(args);
   const name = pos[0];
   if (!name) {
@@ -83,8 +85,93 @@ async function serveAdd(args, machineId) {
     });
   }
 }
+async function serveApply(args, machineId) {
+  const { connectAndGetMachine } = await import('./commands-JWrmpGcs.mjs');
+  const fs = await import('fs');
+  const yaml = await import('yaml');
+  const file = positionalArgs(args)[0];
+  if (!file) {
+    console.error("Usage: svamp serve apply <yaml-or-json-file> [--machine <id>]");
+    console.error("");
+    console.error("YAML format:");
+    console.error("  name: my-app");
+    console.error("  # Static mount:");
+    console.error("  directory: ./public");
+    console.error("  # OR managed-process mount:");
+    console.error("  process:");
+    console.error("    command: npm");
+    console.error("    args: [start]");
+    console.error("    port: 3000");
+    console.error("    workdir: .");
+    console.error("    warmup_path: /          # default '/'");
+    console.error("    warmup_timeout_ms: 30000");
+    console.error("    idle_timeout_sec: 600   # 0 = always running");
+    console.error("    wake_on_request: true   # spawn lazily on first request");
+    console.error("  access: public            # public | owner (default) | [emails]");
+    process.exit(1);
+  }
+  if (!fs.existsSync(file)) {
+    console.error(`Error: file not found: ${file}`);
+    process.exit(1);
+  }
+  const raw = fs.readFileSync(file, "utf-8");
+  let parsed;
+  try {
+    parsed = file.endsWith(".json") ? JSON.parse(raw) : yaml.parse(raw);
+  } catch (err) {
+    console.error(`Error: failed to parse ${file}: ${err.message}`);
+    process.exit(1);
+  }
+  if (!parsed || typeof parsed !== "object") {
+    console.error("Error: top-level config must be an object");
+    process.exit(1);
+  }
+  if (!parsed.name) {
+    console.error("Error: name is required");
+    process.exit(1);
+  }
+  if (!parsed.directory && !parsed.process) {
+    console.error("Error: must specify either directory (static) or process (managed)");
+    process.exit(1);
+  }
+  const proc = parsed.process ? {
+    command: parsed.process.command,
+    args: parsed.process.args,
+    port: parsed.process.port,
+    workdir: parsed.process.workdir ? path.resolve(parsed.process.workdir) : void 0,
+    env: parsed.process.env,
+    warmupPath: parsed.process.warmupPath ?? parsed.process.warmup_path,
+    warmupTimeoutMs: parsed.process.warmupTimeoutMs ?? parsed.process.warmup_timeout_ms,
+    idleTimeoutSec: parsed.process.idleTimeoutSec ?? parsed.process.idle_timeout_sec,
+    wakeOnRequest: parsed.process.wakeOnRequest ?? parsed.process.wake_on_request
+  } : void 0;
+  const params = {
+    name: parsed.name,
+    directory: parsed.directory ? path.resolve(parsed.directory) : void 0,
+    process: proc,
+    sessionId: parsed.sessionId ?? parsed.session_id,
+    access: parsed.access ?? "owner",
+    ownerEmail: parsed.ownerEmail ?? parsed.owner_email
+  };
+  const { machine, server } = await connectAndGetMachine(machineId);
+  try {
+    const result = await machine.serveApply(params);
+    const kind = proc ? "managed" : "static";
+    const what = proc ? `${proc.command}${proc.args?.length ? " " + proc.args.join(" ") : ""} (port ${proc.port})` : params.directory;
+    console.log(`Mount applied (${kind}): ${params.name} \u2192 ${what}`);
+    if (proc?.wakeOnRequest) console.log("Wake-on-request: enabled (process starts on first incoming request)");
+    if (proc?.idleTimeoutSec) console.log(`Idle timeout: ${proc.idleTimeoutSec}s`);
+    console.log(`URL: ${result.url}`);
+  } catch (err) {
+    console.error(`Error: ${err.message || err}`);
+    process.exit(1);
+  } finally {
+    await server.disconnect().catch(() => {
+    });
+  }
+}
 async function serveRemove(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-Cd_I1MXo.mjs');
+  const { connectAndGetMachine } = await import('./commands-JWrmpGcs.mjs');
   const pos = positionalArgs(args);
   const name = pos[0];
   if (!name) {
@@ -104,7 +191,7 @@ async function serveRemove(args, machineId) {
   }
 }
 async function serveList(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-Cd_I1MXo.mjs');
+  const { connectAndGetMachine } = await import('./commands-JWrmpGcs.mjs');
   const all = hasFlag(args, "--all", "-a");
   const json = hasFlag(args, "--json");
   const sessionId = getFlag(args, "--session");
@@ -137,7 +224,7 @@ async function serveList(args, machineId) {
   }
 }
 async function serveInfo(machineId) {
-  const { connectAndGetMachine } = await import('./commands-Cd_I1MXo.mjs');
+  const { connectAndGetMachine } = await import('./commands-JWrmpGcs.mjs');
   const { machine, server } = await connectAndGetMachine(machineId);
   try {
     const info = await machine.serveInfo();
@@ -164,6 +251,9 @@ Multiple sessions can register different mount points without port conflicts.
 Usage:
   svamp serve <name> [directory]       Add a mount and print its URL (dir defaults to .)
   svamp serve add <name> [directory]   Same as above
+  svamp serve apply <yaml>             Apply a declarative mount config (idempotent).
+                                       Supports static and managed-process mounts
+                                       with wake-on-request and idle timeout.
   svamp serve remove <name>            Remove a mount
   svamp serve list [--all] [--json]    List mounts (default: current session only)
   svamp serve info                     Show server status and URL
@@ -183,8 +273,21 @@ Examples:
   svamp serve my-report ./output               # Owner-only (default)
   svamp serve dashboard ./dist --public        # Anyone can access
   svamp serve data ./csv --access a@x.com,b@y.com  # Specific users
+  svamp serve apply my-app.yaml                # Declarative apply
   svamp serve list --all                       # Show all mounts
   svamp serve remove my-report                 # Stop serving
+
+Declarative apply (svamp serve apply <yaml>):
+  name: my-app
+  process:
+    command: npm
+    args: [start]
+    port: 3000
+    workdir: .
+    warmup_path: /
+    idle_timeout_sec: 600
+    wake_on_request: true
+  access: public
 `);
 }
 

package/dist/{serveManager-DOXI2QzY.mjs → serveManager-RvRL-weX.mjs}

@@ -1,3 +1,4 @@
+import { spawn } from 'child_process';
 import * as fs from 'fs';
 import * as http from 'http';
 import * as net from 'net';
@@ -281,6 +282,10 @@ class ServeManager {
   caddy = null;
   proxyServer = null;
   auth = null;
+  /** Live child processes for managed mounts. Keyed by mount name. */
+  managedProcs = /* @__PURE__ */ new Map();
+  /** Single timer that scans managed mounts every 30s for idle eviction. */
+  idleTimer = null;
   persistFile;
   log;
   hyphaServerUrl;
@@ -292,35 +297,72 @@ class ServeManager {
   }
   // ── Public API ───────────────────────────────────────────────────────
   /**
-   * Add a mount and start Caddy + frpc tunnel if not already running.
-   * Returns the public URL for this mount.
+   * Add a static mount (backward-compatible thin wrapper around applyMount).
+   * Throws if a mount with the same name already exists, preserving the
+   * pre-existing semantics that callers may depend on.
    */
   async addMount(name, directory, sessionId, access = "owner", ownerEmail) {
-    validateMountName(name);
-    const resolvedDir = path.resolve(directory);
-    if (!fs.existsSync(resolvedDir)) {
-      throw new Error(`Path does not exist: ${resolvedDir}`);
-    }
     if (this.mounts.has(name)) {
       throw new Error(`Mount '${name}' already exists. Remove it first or choose a different name.`);
     }
+    return this.applyMount({ name, directory, sessionId, access, ownerEmail });
+  }
+  /**
+   * Apply a mount declaratively. Unifies static and managed-process mounts:
+   * pass `directory` for static, `process` for managed (or both — `process`
+   * takes precedence for routing). Replaces an existing mount with the same
+   * name (idempotent), so repeated `svamp serve apply` is safe.
+   *
+   * Backward-compatible: existing `addMount(name, directory, ...)` callers
+   * still work and produce the same result as `applyMount({name, directory, ...})`.
+   */
+  async applyMount(spec) {
+    validateMountName(spec.name);
+    if (!spec.directory && !spec.process) {
+      throw new Error(`Mount '${spec.name}': must specify either directory (static) or process (managed)`);
+    }
+    if (spec.process) {
+      if (!spec.process.command) {
+        throw new Error(`Mount '${spec.name}': process.command is required`);
+      }
+      if (!spec.process.port || spec.process.port <= 0) {
+        throw new Error(`Mount '${spec.name}': process.port must be a positive integer`);
+      }
+    }
+    const resolvedDir = spec.directory ? path.resolve(spec.directory) : void 0;
+    if (resolvedDir && !fs.existsSync(resolvedDir)) {
+      throw new Error(`Path does not exist: ${resolvedDir}`);
+    }
+    if (this.mounts.has(spec.name)) {
+      await this.removeMount(spec.name);
+    }
     const mount = {
-      name,
+      name: spec.name,
       directory: resolvedDir,
-      sessionId,
-      ownerEmail,
-      access,
+      process: spec.process,
+      sessionId: spec.sessionId,
+      ownerEmail: spec.ownerEmail,
+      access: spec.access ?? "owner",
       addedAt: Date.now()
     };
-    this.mounts.set(name, mount);
+    this.mounts.set(spec.name, mount);
     await this.ensureRunning();
-    if (this.caddy?.isRunning) {
-      await this.caddy.addMount(name, resolvedDir);
+    if (resolvedDir && this.caddy?.isRunning) {
+      await this.caddy.addMount(spec.name, resolvedDir);
     }
-    await this.startMountTunnel(name);
+    await this.startMountTunnel(spec.name);
+    if (spec.process && !spec.process.wakeOnRequest) {
+      try {
+        await this.ensureManagedRunning(spec.name);
+      } catch (err) {
+        this.log(`Mount '${spec.name}': initial process start failed: ${err.message}`);
+      }
+    }
+    this.ensureIdleTimer();
     this.persist();
-    const url = this.getMountUrl(name);
-    this.log(`Mount added: ${name} \u2192 ${resolvedDir} (${url ?? "tunnel pending"})`);
+    const url = this.getMountUrl(spec.name);
+    const what = spec.process ? `${spec.process.command}${spec.process.args?.length ? " " + spec.process.args.join(" ") : ""} (port ${spec.process.port})` : resolvedDir;
+    this.log(`Mount applied: ${spec.name} \u2192 ${what} (${url ?? "tunnel pending"})`);
     return { url: url || "", mount };
   }
   /**
@@ -331,6 +373,8 @@ class ServeManager {
       throw new Error(`Mount '${name}' not found`);
     }
     this.mounts.delete(name);
+    await this.stopManagedProcess(name).catch(() => {
+    });
     const tunnel = this.mountTunnels.get(name);
     if (tunnel) {
       try {
@@ -375,6 +419,7 @@ class ServeManager {
     return {
       url: firstUrl,
       port: running ? this.caddy?.port ?? this.port : 0,
+      authProxyPort: running ? this.port : 0,
       running,
       mountCount: this.mounts.size,
       mounts: Array.from(this.mounts.values()).map((m) => ({
@@ -396,12 +441,16 @@ class ServeManager {
       if (!raw.mounts || raw.mounts.length === 0) return;
       let restoredCount = 0;
       for (const m of raw.mounts) {
-        if (fs.existsSync(m.directory)) {
-          this.mounts.set(m.name, m);
-          restoredCount++;
-        } else {
+        if (m.directory && !fs.existsSync(m.directory)) {
           this.log(`Skipping mount '${m.name}': directory no longer exists (${m.directory})`);
+          continue;
         }
+        if (!m.directory && !m.process) {
+          this.log(`Skipping mount '${m.name}': neither directory nor process configured`);
+          continue;
+        }
+        this.mounts.set(m.name, m);
+        restoredCount++;
       }
       if (restoredCount > 0) {
         this.log(`Restoring ${restoredCount} mount(s)...`);
@@ -412,7 +461,15 @@ class ServeManager {
           } catch (err) {
             this.log(`Failed to start tunnel for restored mount '${m.name}': ${err.message}`);
           }
+          if (m.process && !m.process.wakeOnRequest) {
+            try {
+              await this.ensureManagedRunning(m.name);
+            } catch (err) {
+              this.log(`Restored managed process '${m.name}' failed to start: ${err.message}`);
+            }
+          }
         }
+        this.ensureIdleTimer();
         this.persist();
       }
     } catch (err) {
@@ -420,9 +477,18 @@ class ServeManager {
     }
   }
   /**
-   * Shut down auth proxy + Caddy + all per-mount frpc tunnels.
+   * Shut down auth proxy + Caddy + all per-mount frpc tunnels + all
+   * managed processes.
    */
   async shutdown() {
+    for (const name of Array.from(this.managedProcs.keys())) {
+      await this.stopManagedProcess(name).catch(() => {
+      });
+    }
+    if (this.idleTimer) {
+      clearInterval(this.idleTimer);
+      this.idleTimer = null;
+    }
     for (const [name, tunnel] of this.mountTunnels.entries()) {
       try {
         tunnel.destroy();
@@ -443,6 +509,141 @@ class ServeManager {
     }
     this.auth?.destroy();
   }
+  // ── Managed-process lifecycle ─────────────────────────────────────────
+  /**
+   * Ensure the managed process for a mount is running and warm. If a warmup
+   * is already in flight, awaits the same promise (no duplicate spawns).
+   * Throws if warmup probe never returns 200/3xx within warmupTimeoutMs.
+   */
+  async ensureManagedRunning(name) {
+    const mount = this.mounts.get(name);
+    if (!mount?.process) return;
+    const handle = this.managedProcs.get(name);
+    if (handle && handle.warmupPromise) {
+      return handle.warmupPromise;
+    }
+    if (handle && handle.child.exitCode === null && !handle.child.killed) {
+      handle.lastRequestAt = Date.now();
+      return;
+    }
+    const cfg = mount.process;
+    const child = spawn(cfg.command, cfg.args ?? [], {
+      cwd: cfg.workdir ?? process.cwd(),
+      env: { ...process.env, ...cfg.env ?? {} },
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false
+    });
+    child.stdout?.on("data", (d) => {
+      const line = d.toString().trimEnd();
+      if (line) this.log(`[${name}] ${line}`);
+    });
+    child.stderr?.on("data", (d) => {
+      const line = d.toString().trimEnd();
+      if (line) this.log(`[${name}] ${line}`);
+    });
+    child.on("exit", (code, signal) => {
+      this.log(`Managed process '${name}' exited (code=${code}, signal=${signal})`);
+      const h = this.managedProcs.get(name);
+      if (h && h.child === child) this.managedProcs.delete(name);
+    });
+    const warmupPath = cfg.warmupPath ?? "/";
+    const warmupTimeoutMs = cfg.warmupTimeoutMs ?? 3e4;
+    const warmupPromise = this.warmupProbe(`http://127.0.0.1:${cfg.port}${warmupPath}`, warmupTimeoutMs).then(() => {
+      const h = this.managedProcs.get(name);
+      if (h) {
+        h.warmupPromise = null;
+        h.lastRequestAt = Date.now();
+      }
+      this.log(`Managed process '${name}' ready on 127.0.0.1:${cfg.port}`);
+    }).catch((err) => {
+      this.log(`Managed process '${name}' warmup failed: ${err.message}`);
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      this.managedProcs.delete(name);
+      throw err;
+    });
+    const newHandle = {
+      child,
+      pid: child.pid ?? 0,
+      lastRequestAt: Date.now(),
+      warmupPromise
+    };
+    this.managedProcs.set(name, newHandle);
+    this.log(`Managed process '${name}' starting: ${cfg.command} ${(cfg.args ?? []).join(" ")} (port ${cfg.port})`);
+    return warmupPromise;
+  }
+  /** Poll a URL until it returns <500 or the deadline passes. */
+  async warmupProbe(url, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    let lastErr;
+    while (Date.now() < deadline) {
+      try {
+        const ctrl = new AbortController();
+        const t = setTimeout(() => ctrl.abort(), 2e3);
+        let resp;
+        try {
+          resp = await fetch(url, {
+            method: "GET",
+            signal: ctrl.signal,
+            redirect: "manual"
+          });
+        } finally {
+          clearTimeout(t);
+        }
+        if (resp.status < 500) return;
+        lastErr = new Error(`status ${resp.status}`);
+      } catch (err) {
+        lastErr = err;
+      }
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    throw new Error(`warmup probe ${url} did not respond within ${timeoutMs}ms (${lastErr?.message || "no response"})`);
+  }
+  /** Stop a managed process (SIGTERM + SIGKILL after 5s). */
+  async stopManagedProcess(name) {
+    const h = this.managedProcs.get(name);
+    if (!h) return;
+    this.managedProcs.delete(name);
+    try {
+      h.child.kill("SIGTERM");
+    } catch {
+    }
+    const child = h.child;
+    await new Promise((resolve) => {
+      const t = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        resolve();
+      }, 5e3);
+      child.once("exit", () => {
+        clearTimeout(t);
+        resolve();
+      });
+    });
+    this.log(`Managed process '${name}' stopped`);
+  }
+  /** Idle eviction loop — stops processes that have been idle longer than configured. */
+  ensureIdleTimer() {
+    if (this.idleTimer) return;
+    this.idleTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [name, mount] of this.mounts) {
+        const cfg = mount.process;
+        if (!cfg || !cfg.idleTimeoutSec || cfg.idleTimeoutSec <= 0) continue;
+        const h = this.managedProcs.get(name);
+        if (!h || h.warmupPromise) continue;
+        if (now - h.lastRequestAt >= cfg.idleTimeoutSec * 1e3) {
+          this.log(`Idle eviction: stopping '${name}' (idle ${Math.round((now - h.lastRequestAt) / 1e3)}s \u2265 ${cfg.idleTimeoutSec}s)`);
+          this.stopManagedProcess(name).catch(() => {
+          });
+        }
+      }
+    }, 3e4);
+  }
   // ── Internal ─────────────────────────────────────────────────────────
   /** Get the public URL for a mount (mount-specific subdomain). */
   getMountUrl(name) {
@@ -484,7 +685,9 @@ class ServeManager {
       log: (msg) => this.log(`[Caddy] ${msg}`)
     });
     for (const mount of this.mounts.values()) {
-      await this.caddy.addMount(mount.name, mount.directory);
+      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}`);
@@ -510,6 +713,18 @@ class ServeManager {
           basePath = mountName ? url.pathname.slice(`/${mountName}`.length) || "/" : url.pathname;
         }
         const mount = mountName ? this.mounts.get(mountName) : void 0;
+        if (basePath === "/__svamp_health" || url.pathname === "/__svamp_health") {
+          res.writeHead(200, {
+            "Content-Type": "application/json",
+            "Cache-Control": "no-store"
+          });
+          res.end(JSON.stringify({
+            ok: true,
+            mount: mountName || null,
+            ts: Date.now()
+          }));
+          return;
+        }
         if (basePath === "/__login__" || url.pathname === "/__login__") {
           const returnUrl = url.searchParams.get("return") || "/";
           const safeReturn = returnUrl.startsWith("/__login__") ? "/" : returnUrl;
@@ -535,7 +750,7 @@ class ServeManager {
             return;
           }
         }
-        if (req.method === "PUT" && mount) {
+        if (req.method === "PUT" && mount && mount.directory) {
           const filePath = path.join(mount.directory, basePath);
           fs.mkdirSync(path.dirname(filePath), { recursive: true });
           const ws = fs.createWriteStream(filePath);
@@ -550,7 +765,7 @@ class ServeManager {
           });
           return;
         }
-        if (req.method === "DELETE" && mount) {
+        if (req.method === "DELETE" && mount && mount.directory) {
           const filePath = path.join(mount.directory, basePath);
           try {
             fs.unlinkSync(filePath);
@@ -562,6 +777,39 @@ class ServeManager {
           }
           return;
         }
+        if (mount && mount.process) {
+          const cfg = mount.process;
+          if (cfg.wakeOnRequest || !this.managedProcs.has(mount.name)) {
+            try {
+              await this.ensureManagedRunning(mount.name);
+            } catch (err) {
+              res.writeHead(503, { "Content-Type": "text/plain" });
+              res.end(`Backend not ready: ${err?.message || err}`);
+              return;
+            }
+          }
+          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({
+            hostname: "127.0.0.1",
+            port: cfg.port,
+            path: targetPath,
+            method: req.method,
+            headers: req.headers
+          }, (proxyRes) => {
+            res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
+            proxyRes.pipe(res);
+          });
+          proxyReq2.on("error", (err) => {
+            if (!res.headersSent) {
+              res.writeHead(502);
+              res.end(`Backend error: ${err.message}`);
+            }
+          });
+          req.pipe(proxyReq2);
+          return;
+        }
         let proxyPath = req.url || "/";
         if (mountResolvedByHost && mountName) {
           const search = url.search || "";
@@ -634,10 +882,17 @@ class ServeManager {
     const subdomainSafe = mountName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
     const tunnelName = `static-${subdomainSafe}`;
     try {
-      const { FrpcTunnel } = await import('./frpc-DzRFx60H.mjs');
-      const tunnel = new FrpcTunnel({
+      const { FrpcTunnel } = await import('./frpc-j60b46eU.mjs');
+      let tunnel;
+      tunnel = new FrpcTunnel({
         name: tunnelName,
         ports: [this.port],
+        // End-to-end probe: the daemon's health loop watches probe.ok
+        // to detect ghosted tunnel registrations (frpc says "connected"
+        // but no traffic actually flows). The sentinel route is served
+        // by the auth proxy without auth.
+        probePath: "/__svamp_health",
+        probeIntervalMs: 3e4,
         onError: (err) => this.log(`frpc error [${mountName}]: ${err.message}`),
         onConnect: () => {
           const url2 = tunnel.getUrls().get(this.port);
@@ -650,7 +905,8 @@ class ServeManager {
             this.log(`frpc tunnel connected for '${mountName}'. URL: ${url2}/`);
           }
         },
-        onDisconnect: () => this.log(`frpc tunnel for '${mountName}' disconnected, will auto-reconnect...`)
+        onDisconnect: () => this.log(`frpc tunnel for '${mountName}' disconnected, will auto-reconnect...`),
+        onProbeFail: (err) => this.log(`probe fail [${mountName}]: ${err.message}`)
       });
       await tunnel.connect();
       this.mountTunnels.set(mountName, tunnel);

package/package.json

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