svamp-cli 0.2.7 → 0.2.8

package/dist/serveManager-BPyT20Q8.mjs

@@ -0,0 +1,648 @@
+import * as http from 'http';
+import * as fs from 'fs';
+import * as path from 'path';
+import { findAvailablePort, setCorsHeaders, serveFile, resolveSafePath, collectBody, generateDirectoryListing, escapeHtml } from './staticServer-_-FoZQpD.mjs';
+import 'net';
+
+const AUTH0_NAMESPACES = ["https://api.imjoy.io/", "https://amun.ai/"];
+const COOKIE_NAME = "svamp_serve_token";
+const DEFAULT_CACHE_TTL_MS = 5 * 60 * 1e3;
+const DEFAULT_CACHE_MAX_SIZE = 1e3;
+class TokenCache {
+  cache = /* @__PURE__ */ new Map();
+  ttlMs;
+  maxSize;
+  constructor(ttlMs = DEFAULT_CACHE_TTL_MS, maxSize = DEFAULT_CACHE_MAX_SIZE) {
+    this.ttlMs = ttlMs;
+    this.maxSize = maxSize;
+  }
+  get(token) {
+    const info = this.cache.get(token);
+    if (!info) return null;
+    if (Date.now() > info.expiresAt) {
+      this.cache.delete(token);
+      return null;
+    }
+    return info;
+  }
+  set(token, email) {
+    if (this.cache.size >= this.maxSize) {
+      const oldest = this.cache.keys().next().value;
+      if (oldest) this.cache.delete(oldest);
+    }
+    this.cache.set(token, {
+      email,
+      expiresAt: Date.now() + this.ttlMs
+    });
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+function extractToken(req) {
+  const cookies = parseCookies(req.headers.cookie || "");
+  if (cookies[COOKIE_NAME]) return cookies[COOKIE_NAME];
+  const auth = req.headers.authorization;
+  if (auth?.startsWith("Bearer ") || auth?.startsWith("bearer ")) {
+    return auth.slice(7).trim();
+  }
+  const url = new URL(req.url || "/", "http://localhost");
+  const qToken = url.searchParams.get("token");
+  if (qToken) return qToken;
+  return null;
+}
+function parseCookies(header) {
+  const cookies = {};
+  for (const pair of header.split(";")) {
+    const eq = pair.indexOf("=");
+    if (eq > 0) {
+      const key = pair.slice(0, eq).trim();
+      const value = pair.slice(eq + 1).trim();
+      cookies[key] = value;
+    }
+  }
+  return cookies;
+}
+function parseJwtEmail(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const payload = JSON.parse(
+      Buffer.from(parts[1], "base64url").toString("utf-8")
+    );
+    if (payload.exp && payload.exp * 1e3 < Date.now()) return null;
+    for (const ns of AUTH0_NAMESPACES) {
+      const email = payload[ns + "email"];
+      if (typeof email === "string" && email) return email.toLowerCase();
+    }
+    if (typeof payload.email === "string" && payload.email) return payload.email.toLowerCase();
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function verifyTokenViaHypha(token, hyphaServerUrl) {
+  try {
+    const baseUrl = hyphaServerUrl.replace(/\/$/, "");
+    const url = `${baseUrl}/public/services/ws/get_user_info`;
+    const resp = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`
+      },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!resp.ok) return null;
+    const data = await resp.json();
+    const email = data?.email;
+    if (typeof email === "string" && email) return email.toLowerCase();
+    return null;
+  } catch {
+    return null;
+  }
+}
+class ServeAuth {
+  cache;
+  hyphaServerUrl;
+  constructor(options) {
+    this.hyphaServerUrl = options.hyphaServerUrl.replace(/\/$/, "");
+    this.cache = new TokenCache(
+      options.cacheTtlMs || DEFAULT_CACHE_TTL_MS,
+      options.cacheMaxSize || DEFAULT_CACHE_MAX_SIZE
+    );
+  }
+  /**
+   * Authenticate a request and return the user's email, or null if not authenticated.
+   */
+  async authenticate(req) {
+    const token = extractToken(req);
+    if (!token) return null;
+    const cached = this.cache.get(token);
+    if (cached) return cached.email;
+    const localEmail = parseJwtEmail(token);
+    if (localEmail) {
+      this.cache.set(token, localEmail);
+      return localEmail;
+    }
+    const serverEmail = await verifyTokenViaHypha(token, this.hyphaServerUrl);
+    if (serverEmail) {
+      this.cache.set(token, serverEmail);
+      return serverEmail;
+    }
+    return null;
+  }
+  /**
+   * Check if a user email is authorized for a mount's access level.
+   */
+  isAuthorized(email, access, ownerEmail) {
+    if (access === "public") return true;
+    if (!email) return false;
+    if (access === "owner") {
+      return !!ownerEmail && email.toLowerCase() === ownerEmail.toLowerCase();
+    }
+    return access.some((e) => e.toLowerCase() === email.toLowerCase());
+  }
+  /**
+   * Generate the login page HTML. This page:
+   * 1. Calls hypha-login.start() to get a login URL
+   * 2. Redirects to the login URL
+   * 3. Polls hypha-login.check() for the token
+   * 4. Sets a cookie and redirects back
+   */
+  getLoginPageHtml(redirectUrl) {
+    return `<!DOCTYPE html>
+<html><head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Login \u2014 Svamp File Server</title>
+<style>
+*{box-sizing:border-box;margin:0;padding:0}
+body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;background:#f6f8fa;color:#24292f}
+.card{background:#fff;border:1px solid #d0d7de;border-radius:12px;padding:32px;max-width:400px;width:100%;text-align:center;box-shadow:0 4px 12px rgba(31,35,40,0.06)}
+h1{font-size:1.25rem;margin-bottom:8px}
+.subtitle{color:#656d76;font-size:0.9rem;margin-bottom:24px}
+button{background:#0969da;color:#fff;border:none;border-radius:8px;padding:12px 24px;font-size:1rem;cursor:pointer;font-weight:500;width:100%}
+button:hover{background:#0860c4}
+button:disabled{background:#94d3a2;cursor:wait}
+.status{margin-top:16px;color:#656d76;font-size:0.85rem;min-height:20px}
+.error{color:#cf222e}
+</style>
+</head><body>
+<div class="card">
+  <h1>Svamp File Server</h1>
+  <p class="subtitle">Authentication required to access this content.</p>
+  <button id="login-btn" onclick="startLogin()">Sign in with Hypha</button>
+  <div class="status" id="status"></div>
+</div>
+<script>
+const hyphaServer = ${JSON.stringify(this.hyphaServerUrl)};
+const redirectUrl = ${JSON.stringify(redirectUrl)};
+const cookieName = ${JSON.stringify(COOKIE_NAME)};
+
+async function startLogin() {
+    const btn = document.getElementById('login-btn');
+    const status = document.getElementById('status');
+    btn.disabled = true;
+    status.textContent = 'Starting login...';
+
+    try {
+        // Call hypha-login.start()
+        const startResp = await fetch(hyphaServer + '/public/services/hypha-login/start');
+        if (!startResp.ok) throw new Error('Failed to start login');
+        const { key, login_url } = await startResp.json();
+
+        status.textContent = 'Redirecting to login...';
+
+        // Open login in a popup
+        const popup = window.open(login_url, 'hypha-login', 'width=500,height=600');
+
+        // Poll for token
+        status.textContent = 'Waiting for authentication...';
+        let attempts = 0;
+        const maxAttempts = 120; // 2 minutes
+        const poll = setInterval(async () => {
+            attempts++;
+            if (attempts > maxAttempts) {
+                clearInterval(poll);
+                status.innerHTML = '<span class="error">Login timed out. Please try again.</span>';
+                btn.disabled = false;
+                return;
+            }
+            try {
+                const checkResp = await fetch(
+                    hyphaServer + '/public/services/hypha-login/check?key=' + encodeURIComponent('"' + key + '"') + '&timeout=' + encodeURIComponent('"0"')
+                );
+                if (!checkResp.ok) return;
+                const result = await checkResp.json();
+                if (result && result.token) {
+                    clearInterval(poll);
+                    if (popup && !popup.closed) popup.close();
+
+                    // Set cookie (session cookie \u2014 no explicit expiry)
+                    document.cookie = cookieName + '=' + result.token + '; path=/; SameSite=Lax; Secure';
+
+                    status.textContent = 'Login successful! Redirecting...';
+                    setTimeout(() => { window.location.href = redirectUrl; }, 500);
+                }
+            } catch { /* ignore polling errors */ }
+        }, 1000);
+    } catch (err) {
+        status.innerHTML = '<span class="error">Login failed: ' + err.message + '</span>';
+        btn.disabled = false;
+    }
+}
+<\/script>
+</body></html>`;
+  }
+  destroy() {
+    this.cache.clear();
+  }
+}
+
+const MOUNT_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+function validateMountName(name) {
+  if (!name || name.length > 128) {
+    throw new Error("Mount name must be 1\u2013128 characters");
+  }
+  if (!MOUNT_NAME_RE.test(name)) {
+    throw new Error("Mount name must start with alphanumeric and contain only alphanumeric, hyphens, dots, or underscores");
+  }
+}
+class ServeManager {
+  mounts = /* @__PURE__ */ new Map();
+  server = null;
+  port = 0;
+  tunnel = null;
+  serviceUrl = null;
+  auth = null;
+  persistFile;
+  serviceName = "static-serve";
+  log;
+  hyphaServerUrl;
+  constructor(svampHome, logger, hyphaServerUrl) {
+    this.persistFile = path.join(svampHome, "serve-mounts.json");
+    this.log = logger || ((msg) => console.log(`[SERVE] ${msg}`));
+    this.hyphaServerUrl = hyphaServerUrl || process.env.HYPHA_SERVER_URL || "https://hypha.aicell.io";
+    this.auth = new ServeAuth({ hyphaServerUrl: this.hyphaServerUrl });
+  }
+  // ── Public API ───────────────────────────────────────────────────────
+  /**
+   * Add a mount and start the server + tunnel if not already running.
+   * Returns the public URL for this mount.
+   */
+  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.`);
+    }
+    const mount = {
+      name,
+      directory: resolvedDir,
+      sessionId,
+      ownerEmail,
+      access,
+      addedAt: Date.now()
+    };
+    this.mounts.set(name, mount);
+    await this.ensureServerRunning();
+    this.persist();
+    const url = this.getMountUrl(name);
+    this.log(`Mount added: ${name} \u2192 ${resolvedDir} (${url})`);
+    return { url, mount };
+  }
+  /**
+   * Remove a mount. If no mounts remain, stop the server + tunnel.
+   */
+  async removeMount(name) {
+    if (!this.mounts.has(name)) {
+      throw new Error(`Mount '${name}' not found`);
+    }
+    this.mounts.delete(name);
+    this.persist();
+    this.log(`Mount removed: ${name}`);
+    if (this.mounts.size === 0) {
+      await this.stopServer();
+    }
+  }
+  /**
+   * List mounts, optionally filtered by sessionId.
+   */
+  listMounts(sessionId) {
+    const all = Array.from(this.mounts.values());
+    if (sessionId) {
+      return all.filter((m) => m.sessionId === sessionId);
+    }
+    return all;
+  }
+  /**
+   * Get server info (URL, port, running state, mount count).
+   */
+  getInfo() {
+    return {
+      url: this.serviceUrl,
+      port: this.port,
+      running: this.server !== null,
+      mountCount: this.mounts.size,
+      mounts: Array.from(this.mounts.values())
+    };
+  }
+  /**
+   * Restore mounts from disk and restart the server if there are persisted mounts.
+   * Called during daemon startup.
+   */
+  async restore() {
+    try {
+      if (!fs.existsSync(this.persistFile)) return;
+      const raw = JSON.parse(fs.readFileSync(this.persistFile, "utf-8"));
+      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 {
+          this.log(`Skipping mount '${m.name}': directory no longer exists (${m.directory})`);
+        }
+      }
+      if (restoredCount > 0) {
+        this.log(`Restoring ${restoredCount} mount(s)...`);
+        await this.ensureServerRunning();
+        this.persist();
+      }
+    } catch (err) {
+      this.log(`Error restoring serve state: ${err.message}`);
+    }
+  }
+  /**
+   * Shut down the server, tunnel, and clean up.
+   */
+  async shutdown() {
+    await this.stopServer();
+    this.auth?.destroy();
+  }
+  // ── Internal ─────────────────────────────────────────────────────────
+  getMountUrl(name) {
+    const base = this.serviceUrl || `http://127.0.0.1:${this.port}`;
+    return `${base}/${name}/`;
+  }
+  persist() {
+    const state = {
+      mounts: Array.from(this.mounts.values()),
+      serviceName: this.serviceName,
+      serviceUrl: this.serviceUrl
+    };
+    try {
+      fs.writeFileSync(this.persistFile, JSON.stringify(state, null, 2));
+    } catch (err) {
+      this.log(`Error persisting serve state: ${err.message}`);
+    }
+  }
+  async ensureServerRunning() {
+    if (this.server) return;
+    this.port = await findAvailablePort(18080);
+    this.server = http.createServer((req, res) => this.handleRequest(req, res));
+    await new Promise((resolve, reject) => {
+      this.server.listen(this.port, "127.0.0.1", () => resolve());
+      this.server.on("error", reject);
+    });
+    this.log(`Static server listening on 127.0.0.1:${this.port}`);
+    await this.ensureExposure();
+  }
+  async ensureExposure() {
+    try {
+      const { getSandboxEnv } = await import('./api-BRbsyqJ4.mjs');
+      const env = getSandboxEnv();
+      if (env.sandboxId) {
+        const { createServiceGroup, addBackend } = await import('./api-BRbsyqJ4.mjs');
+        try {
+          const group = await createServiceGroup(this.serviceName, [this.port]);
+          this.serviceUrl = group.ports?.[0]?.url || group.url || null;
+          await addBackend(this.serviceName);
+          this.log(`Cloud backend added. URL: ${this.serviceUrl}`);
+        } catch (err) {
+          if (err.message?.includes("already exists")) {
+            const { getServiceGroup } = await import('./api-BRbsyqJ4.mjs');
+            const existing = await getServiceGroup(this.serviceName);
+            this.serviceUrl = existing.ports?.[0]?.url || existing.url || null;
+            this.log(`Reusing existing service group. URL: ${this.serviceUrl}`);
+          } else {
+            throw err;
+          }
+        }
+      } else {
+        const { createServiceGroup } = await import('./api-BRbsyqJ4.mjs');
+        try {
+          const group = await createServiceGroup(this.serviceName, [this.port]);
+          this.serviceUrl = group.ports?.[0]?.url || group.url || null;
+        } catch (err) {
+          if (err.message?.includes("already exists")) {
+            const { getServiceGroup } = await import('./api-BRbsyqJ4.mjs');
+            const existing = await getServiceGroup(this.serviceName);
+            this.serviceUrl = existing.ports?.[0]?.url || existing.url || null;
+          } else {
+            throw err;
+          }
+        }
+        const { TunnelClient } = await import('./tunnel-BDKdemh0.mjs');
+        this.tunnel = new TunnelClient({
+          name: this.serviceName,
+          ports: [this.port],
+          maxReconnectAttempts: 0,
+          // infinite for daemon
+          onError: (err) => this.log(`Tunnel error: ${err.message}`),
+          onConnect: () => this.log(`Tunnel connected`),
+          onDisconnect: () => this.log(`Tunnel disconnected, reconnecting...`)
+        });
+        await this.tunnel.connect();
+        this.log(`Tunnel started. URL: ${this.serviceUrl}`);
+      }
+    } catch (err) {
+      this.log(`Warning: Could not expose server externally: ${err.message}`);
+      this.log(`Server is available locally at http://127.0.0.1:${this.port}`);
+    }
+  }
+  async stopServer() {
+    if (this.tunnel) {
+      this.tunnel.destroy();
+      this.tunnel = null;
+      this.log("Tunnel stopped");
+    }
+    if (this.server) {
+      await new Promise((resolve) => {
+        this.server.close(() => resolve());
+      });
+      this.server = null;
+      this.log("Static server stopped");
+    }
+    this.serviceUrl = null;
+    this.port = 0;
+  }
+  // ── HTTP Request Handler ─────────────────────────────────────────────
+  async handleRequest(req, res) {
+    setCorsHeaders(res);
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url || "/", "http://localhost");
+    const pathname = decodeURIComponent(url.pathname);
+    if (pathname === "/__login__/" || pathname === "/__login__") {
+      const redirect = url.searchParams.get("redirect") || "/";
+      if (this.auth) {
+        const html = this.auth.getLoginPageHtml(redirect);
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(html);
+      } else {
+        res.writeHead(302, { Location: redirect });
+        res.end();
+      }
+      return;
+    }
+    if (pathname === "/" || pathname === "") {
+      this.serveIndex(req, res);
+      return;
+    }
+    const segments = pathname.split("/").filter(Boolean);
+    const mountName = segments[0];
+    const mount = this.mounts.get(mountName);
+    if (!mount) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end(`Mount '${mountName}' not found. Visit / for available mounts.`);
+      return;
+    }
+    if (mount.access !== "public" && this.auth) {
+      const email = await this.auth.authenticate(req);
+      if (!this.auth.isAuthorized(email, mount.access, mount.ownerEmail)) {
+        const currentUrl = req.url || "/";
+        res.writeHead(302, { Location: `/__login__/?redirect=${encodeURIComponent(currentUrl)}` });
+        res.end();
+        return;
+      }
+    }
+    const subPath = "/" + segments.slice(1).join("/");
+    const mountDir = mount.directory;
+    try {
+      const mountStat = fs.statSync(mountDir);
+      if (mountStat.isFile()) {
+        if (req.method === "GET" || req.method === "HEAD") {
+          serveFile(mountDir, req, res);
+        } else {
+          res.writeHead(405, { "Content-Type": "text/plain" });
+          res.end("Method Not Allowed on single-file mount");
+        }
+        return;
+      }
+    } catch {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Mount directory not accessible");
+      return;
+    }
+    const filePath = resolveSafePath(mountDir, subPath);
+    if (!filePath) {
+      res.writeHead(403, { "Content-Type": "text/plain" });
+      res.end("Forbidden");
+      return;
+    }
+    this.handleMountRequest(req, res, filePath, mountDir, `/${mountName}${subPath}`, mountName);
+  }
+  async handleMountRequest(req, res, filePath, mountDir, displayPath, mountName) {
+    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: displayPath }));
+      } 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: displayPath, 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);
+      if (stat.isDirectory()) {
+        const indexPath = path.join(filePath, "index.html");
+        if (fs.existsSync(indexPath) && fs.statSync(indexPath).isFile()) {
+          serveFile(indexPath, req, res);
+        } else {
+          if (!displayPath.endsWith("/")) {
+            res.writeHead(301, { Location: displayPath + "/" });
+            res.end();
+            return;
+          }
+          const html = generateDirectoryListing(filePath, displayPath);
+          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(html);
+        }
+      } 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");
+    }
+  }
+  serveIndex(_req, res) {
+    const mountList = Array.from(this.mounts.values());
+    const rows = mountList.sort((a, b) => a.name.localeCompare(b.name)).map((m) => {
+      const href = `/${m.name}/`;
+      const session = m.sessionId ? escapeHtml(m.sessionId.slice(0, 8)) : "-";
+      const added = new Date(m.addedAt).toISOString().slice(0, 16).replace("T", " ");
+      const accessLabel = m.access === "public" ? "&#127760; public" : m.access === "owner" ? "&#128274; owner" : `&#128274; ${Array.isArray(m.access) ? m.access.length + " users" : "restricted"}`;
+      return `<tr>
+<td class="icon-cell">&#128193;</td>
+<td class="name-cell"><a href="${escapeHtml(href)}">${escapeHtml(m.name)}</a></td>
+<td class="access-cell">${accessLabel}</td>
+<td class="session-cell">${session}</td>
+<td class="date-cell">${added}</td>
+</tr>`;
+    }).join("\n");
+    const html = `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Svamp File Server</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:4px}
+.subtitle{color:#656d76;font-size:0.9rem;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}
+th{text-align:left;padding:8px 12px;font-size:0.85rem;color:#656d76;border-bottom:2px solid #d0d7de}
+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}
+.access-cell{color:#656d76;font-size:0.85rem}
+.session-cell{color:#656d76;font-size:0.85rem;font-family:monospace}
+.date-cell{color:#656d76;font-size:0.85rem}
+.empty{padding:32px;text-align:center;color:#656d76}
+</style>
+</head><body>
+<h1>Svamp File Server</h1>
+<p class="subtitle">${mountList.length} mount(s) registered</p>
+${mountList.length === 0 ? '<div class="empty">No mounts registered. Use <code>svamp serve &lt;name&gt; [directory]</code> to add one.</div>' : `<table><thead><tr><th></th><th>Mount</th><th>Access</th><th>Session</th><th>Added</th></tr></thead>
+<tbody>${rows}</tbody></table>`}
+</body></html>`;
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(html);
+  }
+}
+
+export { ServeManager };

package/dist/{staticServer-CWcmMF5V.mjs → staticServer-_-FoZQpD.mjs}

@@ -474,4 +474,4 @@ function serveFile(filePath, req, res) {
   });
 }
 
-export { startStaticServer };
+export { collectBody, escapeHtml, findAvailablePort, generateDirectoryListing, getMimeType, resolveSafePath, serveFile, setCorsHeaders, startStaticServer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svamp-cli",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "Svamp CLI — AI workspace daemon on Hypha Cloud",
   "author": "Amun AI AB",
   "license": "SEE LICENSE IN LICENSE",
@@ -20,7 +20,7 @@
   "scripts": {
     "build": "rm -rf dist && tsc --noEmit && pkgroll",
     "typecheck": "tsc --noEmit",
-    "test": "npx tsx test/test-authorize.mjs && npx tsx test/test-session-helpers.mjs && npx tsx test/test-cli-routing.mjs && npx tsx test/test-security-context.mjs && npx tsx test/test-ralph-loop.mjs && npx tsx test/test-message-helpers.mjs && npx tsx test/test-agent-config.mjs && npx tsx test/test-wrap-command.mjs && npx tsx test/test-credential-staging.mjs && npx tsx test/test-output-formatters.mjs && npx tsx test/test-agent-types.mjs && npx tsx test/test-transport.mjs && npx tsx test/test-session-update-handlers.mjs && npx tsx test/test-session-scanner.mjs && npx tsx test/test-hypha-client.mjs && npx tsx test/test-hook-settings.mjs && npx tsx test/test-session-service-logic.mjs && npx tsx test/test-daemon-persistence.mjs && npx tsx test/test-detect-isolation.mjs && npx tsx test/test-machine-service-logic.mjs && npx tsx test/test-interactive-helpers.mjs && npx tsx test/test-codex-backend.mjs && npx tsx test/test-acp-backend.mjs && npx tsx test/test-acp-bridge.mjs && npx tsx test/test-hook-server.mjs && npx tsx test/test-session-commands.mjs && npx tsx test/test-interactive-console.mjs && npx tsx test/test-session-messages.mjs && npx tsx test/test-skills.mjs && npx tsx test/test-agent-grouping.mjs && npx tsx test/test-ralph-loop-integration.mjs && npx tsx test/test-ralph-loop-modes.mjs && npx tsx test/test-machine-list-directory.mjs && npx tsx test/test-service-commands.mjs && npx tsx test/test-supervisor.mjs && npx tsx test/test-clear-detection.mjs && npx tsx test/test-session-consolidation.mjs && npx tsx test/test-inbox.mjs && npx tsx test/test-session-rpc-dispatch.mjs && npx tsx test/test-sandbox-cli.mjs",
+    "test": "npx tsx test/test-authorize.mjs && npx tsx test/test-session-helpers.mjs && npx tsx test/test-cli-routing.mjs && npx tsx test/test-security-context.mjs && npx tsx test/test-ralph-loop.mjs && npx tsx test/test-message-helpers.mjs && npx tsx test/test-agent-config.mjs && npx tsx test/test-wrap-command.mjs && npx tsx test/test-credential-staging.mjs && npx tsx test/test-output-formatters.mjs && npx tsx test/test-agent-types.mjs && npx tsx test/test-transport.mjs && npx tsx test/test-session-update-handlers.mjs && npx tsx test/test-session-scanner.mjs && npx tsx test/test-hypha-client.mjs && npx tsx test/test-hook-settings.mjs && npx tsx test/test-session-service-logic.mjs && npx tsx test/test-daemon-persistence.mjs && npx tsx test/test-detect-isolation.mjs && npx tsx test/test-machine-service-logic.mjs && npx tsx test/test-interactive-helpers.mjs && npx tsx test/test-codex-backend.mjs && npx tsx test/test-acp-backend.mjs && npx tsx test/test-acp-bridge.mjs && npx tsx test/test-hook-server.mjs && npx tsx test/test-session-commands.mjs && npx tsx test/test-interactive-console.mjs && npx tsx test/test-session-messages.mjs && npx tsx test/test-skills.mjs && npx tsx test/test-agent-grouping.mjs && npx tsx test/test-ralph-loop-integration.mjs && npx tsx test/test-ralph-loop-modes.mjs && npx tsx test/test-machine-list-directory.mjs && npx tsx test/test-service-commands.mjs && npx tsx test/test-supervisor.mjs && npx tsx test/test-clear-detection.mjs && npx tsx test/test-session-consolidation.mjs && npx tsx test/test-inbox.mjs && npx tsx test/test-session-rpc-dispatch.mjs && npx tsx test/test-sandbox-cli.mjs && npx tsx test/test-serve-manager.mjs",
     "test:hypha": "node --no-warnings test/test-hypha-service.mjs",
     "dev": "tsx src/cli.ts",
     "dev:daemon": "tsx src/cli.ts daemon start-sync",