@openacp/cli 2026.330.2 → 2026.331.1

package/dist/{tunnel-service-ZMO4THKE.js → tunnel-service-TBAHDXMF.js}

@@ -1,531 +1,19 @@
 import {
-  commandExists
-} from "./chunk-ZSLHHQPQ.js";
+  TunnelRegistry
+} from "./chunk-NHD5XDD2.js";
 import {
   createChildLogger
 } from "./chunk-R6KZYF7D.js";
+import "./chunk-ZSLHHQPQ.js";
 
 // src/plugins/tunnel/tunnel-service.ts
 import { serve } from "@hono/node-server";
 
-// src/plugins/tunnel/tunnel-registry.ts
-import fs2 from "fs";
-import path2 from "path";
-import os2 from "os";
-
-// src/plugins/tunnel/providers/cloudflare.ts
-import { spawn } from "child_process";
-import fs from "fs";
-import path from "path";
-import os from "os";
-var log = createChildLogger({ module: "cloudflare-tunnel" });
-var CloudflareTunnelProvider = class {
-  child = null;
-  publicUrl = "";
-  options;
-  constructor(options = {}) {
-    this.options = options;
-  }
-  async start(localPort) {
-    let binaryPath = this.findBinary();
-    if (!binaryPath) {
-      log.warn("cloudflared not found locally, attempting auto-install as fallback...");
-      try {
-        const { ensureCloudflared } = await import("./install-cloudflared-JRJ4BSOM.js");
-        binaryPath = await ensureCloudflared();
-      } catch (err) {
-        throw new Error(`cloudflared is not installed and auto-install failed: ${err.message}`);
-      }
-    }
-    const args = ["tunnel", "--url", `http://localhost:${localPort}`];
-    if (this.options.domain) {
-      args.push("--hostname", String(this.options.domain));
-    }
-    return new Promise((resolve2, reject) => {
-      const timeout = setTimeout(() => {
-        this.stop();
-        reject(new Error("Cloudflare tunnel timed out after 30s"));
-      }, 3e4);
-      try {
-        this.child = spawn(binaryPath, args, { stdio: ["ignore", "pipe", "pipe"] });
-      } catch {
-        clearTimeout(timeout);
-        reject(new Error(`Failed to start cloudflared at ${binaryPath}`));
-        return;
-      }
-      const urlPattern = /https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/;
-      const onData = (data) => {
-        const line = data.toString();
-        log.debug(line.trim());
-        const match = line.match(urlPattern);
-        if (match) {
-          clearTimeout(timeout);
-          this.publicUrl = match[0];
-          log.info({ url: this.publicUrl }, "Cloudflare tunnel ready");
-          resolve2(this.publicUrl);
-        }
-      };
-      this.child.stdout?.on("data", onData);
-      this.child.stderr?.on("data", onData);
-      this.child.on("error", (err) => {
-        clearTimeout(timeout);
-        reject(new Error(`cloudflared failed to start: ${err.message}`));
-      });
-      this.child.on("exit", (code) => {
-        if (!this.publicUrl) {
-          clearTimeout(timeout);
-          reject(new Error(`cloudflared exited with code ${code} before establishing tunnel`));
-        }
-      });
-    });
-  }
-  async stop() {
-    if (this.child) {
-      this.child.kill("SIGTERM");
-      this.child = null;
-      log.info("Cloudflare tunnel stopped");
-    }
-  }
-  getPublicUrl() {
-    return this.publicUrl;
-  }
-  findBinary() {
-    if (commandExists("cloudflared")) return "cloudflared";
-    const binPath = path.join(os.homedir(), ".openacp", "bin", "cloudflared");
-    if (fs.existsSync(binPath)) return binPath;
-    return null;
-  }
-};
-
-// src/plugins/tunnel/providers/ngrok.ts
-import { spawn as spawn2 } from "child_process";
-var log2 = createChildLogger({ module: "ngrok-tunnel" });
-var NgrokTunnelProvider = class {
-  child = null;
-  publicUrl = "";
-  options;
-  constructor(options = {}) {
-    this.options = options;
-  }
-  async start(localPort) {
-    const args = ["http", String(localPort), "--log", "stdout", "--log-format", "json"];
-    if (this.options.authtoken) {
-      args.push("--authtoken", String(this.options.authtoken));
-    }
-    if (this.options.domain) {
-      args.push("--domain", String(this.options.domain));
-    }
-    if (this.options.region) {
-      args.push("--region", String(this.options.region));
-    }
-    return new Promise((resolve2, reject) => {
-      const timeout = setTimeout(() => {
-        this.stop();
-        reject(new Error("ngrok tunnel timed out after 30s. Is ngrok installed?"));
-      }, 3e4);
-      try {
-        this.child = spawn2("ngrok", args, { stdio: ["ignore", "pipe", "pipe"] });
-      } catch {
-        clearTimeout(timeout);
-        reject(new Error(
-          "Failed to start ngrok. Install it from https://ngrok.com/download"
-        ));
-        return;
-      }
-      const urlPattern = /https:\/\/[a-zA-Z0-9-]+\.ngrok(-free)?\.app/;
-      const onData = (data) => {
-        const line = data.toString();
-        log2.debug(line.trim());
-        const match = line.match(urlPattern);
-        if (match) {
-          clearTimeout(timeout);
-          this.publicUrl = match[0];
-          log2.info({ url: this.publicUrl }, "ngrok tunnel ready");
-          resolve2(this.publicUrl);
-        }
-      };
-      this.child.stdout?.on("data", onData);
-      this.child.stderr?.on("data", onData);
-      this.child.on("error", (err) => {
-        clearTimeout(timeout);
-        reject(new Error(
-          `ngrok failed to start: ${err.message}. Install it from https://ngrok.com/download`
-        ));
-      });
-      this.child.on("exit", (code) => {
-        if (!this.publicUrl) {
-          clearTimeout(timeout);
-          reject(new Error(`ngrok exited with code ${code} before establishing tunnel`));
-        }
-      });
-    });
-  }
-  async stop() {
-    if (this.child) {
-      this.child.kill("SIGTERM");
-      this.child = null;
-      log2.info("ngrok tunnel stopped");
-    }
-  }
-  getPublicUrl() {
-    return this.publicUrl;
-  }
-};
-
-// src/plugins/tunnel/providers/bore.ts
-import { spawn as spawn3 } from "child_process";
-var log3 = createChildLogger({ module: "bore-tunnel" });
-var BoreTunnelProvider = class {
-  child = null;
-  publicUrl = "";
-  options;
-  constructor(options = {}) {
-    this.options = options;
-  }
-  async start(localPort) {
-    const server = String(this.options.server || "bore.pub");
-    const args = ["local", String(localPort), "--to", server];
-    if (this.options.port) {
-      args.push("--port", String(this.options.port));
-    }
-    if (this.options.secret) {
-      args.push("--secret", String(this.options.secret));
-    }
-    return new Promise((resolve2, reject) => {
-      const timeout = setTimeout(() => {
-        this.stop();
-        reject(new Error("Bore tunnel timed out after 30s. Is bore installed?"));
-      }, 3e4);
-      try {
-        this.child = spawn3("bore", args, { stdio: ["ignore", "pipe", "pipe"] });
-      } catch {
-        clearTimeout(timeout);
-        reject(new Error(
-          "Failed to start bore. Install it from https://github.com/ekzhang/bore"
-        ));
-        return;
-      }
-      const urlPattern = /listening at ([^\s]+):(\d+)/;
-      const onData = (data) => {
-        const line = data.toString();
-        log3.debug(line.trim());
-        const match = line.match(urlPattern);
-        if (match) {
-          clearTimeout(timeout);
-          this.publicUrl = `http://${match[1]}:${match[2]}`;
-          log3.info({ url: this.publicUrl }, "Bore tunnel ready");
-          resolve2(this.publicUrl);
-        }
-      };
-      this.child.stdout?.on("data", onData);
-      this.child.stderr?.on("data", onData);
-      this.child.on("error", (err) => {
-        clearTimeout(timeout);
-        reject(new Error(
-          `bore failed to start: ${err.message}. Install it from https://github.com/ekzhang/bore`
-        ));
-      });
-      this.child.on("exit", (code) => {
-        if (!this.publicUrl) {
-          clearTimeout(timeout);
-          reject(new Error(`bore exited with code ${code} before establishing tunnel`));
-        }
-      });
-    });
-  }
-  async stop() {
-    if (this.child) {
-      this.child.kill("SIGTERM");
-      this.child = null;
-      log3.info("Bore tunnel stopped");
-    }
-  }
-  getPublicUrl() {
-    return this.publicUrl;
-  }
-};
-
-// src/plugins/tunnel/providers/tailscale.ts
-import { spawn as spawn4, execSync } from "child_process";
-var log4 = createChildLogger({ module: "tailscale-tunnel" });
-var TailscaleTunnelProvider = class {
-  child = null;
-  publicUrl = "";
-  options;
-  constructor(options = {}) {
-    this.options = options;
-  }
-  async start(localPort) {
-    let hostname = "";
-    try {
-      const statusJson = execSync("tailscale status --json", { encoding: "utf-8" });
-      const status = JSON.parse(statusJson);
-      hostname = String(status.Self.DNSName).replace(/\.$/, "");
-      log4.debug({ hostname }, "Resolved Tailscale hostname");
-    } catch (err) {
-      log4.warn("Failed to resolve Tailscale hostname via status --json");
-    }
-    const args = ["funnel", String(localPort)];
-    if (this.options.bg) {
-      args.push("--bg");
-    }
-    return new Promise((resolve2, reject) => {
-      const timeout = setTimeout(() => {
-        this.stop();
-        reject(new Error("Tailscale funnel timed out after 30s. Is tailscale installed?"));
-      }, 3e4);
-      try {
-        this.child = spawn4("tailscale", args, { stdio: ["ignore", "pipe", "pipe"] });
-      } catch {
-        clearTimeout(timeout);
-        reject(new Error(
-          "Failed to start tailscale. Install it from https://tailscale.com/download"
-        ));
-        return;
-      }
-      const urlPattern = /https:\/\/[^\s]+/;
-      const onData = (data) => {
-        const line = data.toString();
-        log4.debug(line.trim());
-        const match = line.match(urlPattern);
-        if (match) {
-          clearTimeout(timeout);
-          this.publicUrl = match[0];
-          log4.info({ url: this.publicUrl }, "Tailscale funnel ready");
-          resolve2(this.publicUrl);
-        }
-      };
-      this.child.stdout?.on("data", onData);
-      this.child.stderr?.on("data", onData);
-      this.child.on("error", (err) => {
-        clearTimeout(timeout);
-        reject(new Error(
-          `tailscale failed to start: ${err.message}. Install it from https://tailscale.com/download`
-        ));
-      });
-      this.child.on("exit", (code) => {
-        if (!this.publicUrl) {
-          clearTimeout(timeout);
-          if (hostname) {
-            this.publicUrl = `https://${hostname}`;
-            log4.info({ url: this.publicUrl }, "Tailscale funnel ready (constructed from hostname)");
-            resolve2(this.publicUrl);
-          } else {
-            reject(new Error(`tailscale exited with code ${code} before establishing funnel`));
-          }
-        }
-      });
-    });
-  }
-  async stop() {
-    if (this.child) {
-      this.child.kill("SIGTERM");
-      this.child = null;
-      log4.info("Tailscale funnel stopped");
-    }
-  }
-  getPublicUrl() {
-    return this.publicUrl;
-  }
-};
-
-// src/plugins/tunnel/tunnel-registry.ts
-var log5 = createChildLogger({ module: "tunnel-registry" });
-var REGISTRY_PATH = path2.join(os2.homedir(), ".openacp", "tunnels.json");
-var TunnelRegistry = class {
-  entries = /* @__PURE__ */ new Map();
-  saveTimeout = null;
-  maxUserTunnels;
-  providerOptions;
-  constructor(opts = {}) {
-    this.maxUserTunnels = opts.maxUserTunnels ?? 5;
-    this.providerOptions = opts.providerOptions ?? {};
-  }
-  async add(port, opts) {
-    if (this.entries.has(port)) {
-      const existing = this.entries.get(port);
-      if (existing.entry.status === "active" || existing.entry.status === "starting") {
-        throw new Error(`Port ${port} is already tunneled \u2192 ${existing.entry.publicUrl || "starting..."}`);
-      }
-      this.entries.delete(port);
-    }
-    if (opts.type === "user") {
-      const userCount = this.list(false).filter((e) => e.status === "active" || e.status === "starting").length;
-      if (userCount >= this.maxUserTunnels) {
-        throw new Error(`Max user tunnels (${this.maxUserTunnels}) reached. Stop a tunnel first.`);
-      }
-    }
-    const entry = {
-      port,
-      type: opts.type,
-      provider: opts.provider,
-      label: opts.label,
-      sessionId: opts.sessionId,
-      status: "starting",
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const provider = this.createProvider(opts.provider);
-    const spawnPromise = provider.start(port).then((url) => {
-      entry.publicUrl = url;
-      entry.status = "active";
-      log5.info({ port, url, label: opts.label }, "Tunnel active");
-      this.scheduleSave();
-      return url;
-    }).catch((err) => {
-      entry.status = "failed";
-      log5.error({ port, err: err.message }, "Tunnel failed to start");
-      this.scheduleSave();
-      throw err;
-    });
-    this.entries.set(port, { entry, process: provider, spawnPromise });
-    this.scheduleSave();
-    await spawnPromise;
-    return entry;
-  }
-  async stop(port) {
-    const live = this.entries.get(port);
-    if (!live) return;
-    if (live.entry.type === "system") {
-      throw new Error("Cannot stop system tunnel");
-    }
-    if (live.spawnPromise) {
-      try {
-        await live.spawnPromise;
-      } catch {
-      }
-    }
-    if (live.process) {
-      await live.process.stop();
-    }
-    this.entries.delete(port);
-    this.scheduleSave();
-    log5.info({ port, label: live.entry.label }, "Tunnel stopped");
-  }
-  async stopBySession(sessionId) {
-    const stopped = [];
-    const toStop = this.getBySession(sessionId);
-    for (const entry of toStop) {
-      try {
-        await this.stop(entry.port);
-        stopped.push(entry);
-      } catch {
-      }
-    }
-    return stopped;
-  }
-  async stopAllUser() {
-    const userEntries = this.list(false);
-    for (const entry of userEntries) {
-      try {
-        await this.stop(entry.port);
-      } catch {
-      }
-    }
-  }
-  async shutdown() {
-    for (const [, live] of this.entries) {
-      if (live.spawnPromise) {
-        try {
-          await live.spawnPromise;
-        } catch {
-        }
-      }
-      if (live.process) {
-        await live.process.stop();
-      }
-    }
-    this.entries.clear();
-    this.scheduleSave();
-  }
-  list(includeSystem = false) {
-    const entries = Array.from(this.entries.values()).map((l) => l.entry);
-    if (includeSystem) return entries;
-    return entries.filter((e) => e.type === "user");
-  }
-  get(port) {
-    return this.entries.get(port)?.entry ?? null;
-  }
-  getBySession(sessionId) {
-    return this.list(false).filter((e) => e.sessionId === sessionId);
-  }
-  getSystemEntry() {
-    for (const live of this.entries.values()) {
-      if (live.entry.type === "system") return live.entry;
-    }
-    return null;
-  }
-  async restore() {
-    if (!fs2.existsSync(REGISTRY_PATH)) return;
-    try {
-      const raw = JSON.parse(fs2.readFileSync(REGISTRY_PATH, "utf-8"));
-      log5.info({ count: raw.length }, "Restoring tunnels");
-      const userEntries = raw.filter((e) => e.type === "user");
-      for (const persisted of userEntries) {
-        try {
-          await this.add(persisted.port, {
-            type: persisted.type,
-            provider: persisted.provider,
-            label: persisted.label,
-            sessionId: persisted.sessionId
-          });
-        } catch (err) {
-          log5.warn({ port: persisted.port, err: err.message }, "Failed to restore tunnel");
-        }
-      }
-    } catch (err) {
-      log5.warn({ err: err.message }, "Failed to read tunnels.json");
-    }
-  }
-  createProvider(name) {
-    switch (name) {
-      case "cloudflare":
-        return new CloudflareTunnelProvider(this.providerOptions);
-      case "ngrok":
-        return new NgrokTunnelProvider(this.providerOptions);
-      case "bore":
-        return new BoreTunnelProvider(this.providerOptions);
-      case "tailscale":
-        return new TailscaleTunnelProvider(this.providerOptions);
-      default:
-        log5.warn({ provider: name }, "Unknown provider, falling back to cloudflare");
-        return new CloudflareTunnelProvider(this.providerOptions);
-    }
-  }
-  scheduleSave() {
-    if (this.saveTimeout) clearTimeout(this.saveTimeout);
-    this.saveTimeout = setTimeout(() => this.save(), 2e3);
-  }
-  save() {
-    const data = Array.from(this.entries.values()).map((l) => ({
-      port: l.entry.port,
-      type: l.entry.type,
-      provider: l.entry.provider,
-      label: l.entry.label,
-      sessionId: l.entry.sessionId,
-      createdAt: l.entry.createdAt
-    }));
-    try {
-      const dir = path2.dirname(REGISTRY_PATH);
-      fs2.mkdirSync(dir, { recursive: true });
-      fs2.writeFileSync(REGISTRY_PATH, JSON.stringify(data, null, 2));
-    } catch (err) {
-      log5.error({ err: err.message }, "Failed to save tunnels.json");
-    }
-  }
-  flush() {
-    if (this.saveTimeout) {
-      clearTimeout(this.saveTimeout);
-      this.saveTimeout = null;
-    }
-    this.save();
-  }
-};
-
 // src/plugins/tunnel/viewer-store.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs from "fs";
+import * as path from "path";
 import { nanoid } from "nanoid";
-var log6 = createChildLogger({ module: "viewer-store" });
+var log = createChildLogger({ module: "viewer-store" });
 var MAX_CONTENT_SIZE = 1e6;
 var EXTENSION_LANGUAGE = {
   ".ts": "typescript",
@@ -573,11 +61,11 @@ var ViewerStore = class {
   }
   storeFile(sessionId, filePath, content, workingDirectory) {
     if (!this.isPathAllowed(filePath, workingDirectory)) {
-      log6.warn({ filePath, workingDirectory }, "Path outside workspace, rejecting");
+      log.warn({ filePath, workingDirectory }, "Path outside workspace, rejecting");
       return null;
     }
     if (content.length > MAX_CONTENT_SIZE) {
-      log6.debug({ filePath, size: content.length }, "File too large for viewer");
+      log.debug({ filePath, size: content.length }, "File too large for viewer");
       return null;
     }
     const id = nanoid(12);
@@ -593,17 +81,17 @@ var ViewerStore = class {
       createdAt: now,
       expiresAt: now + this.ttlMs
     });
-    log6.debug({ id, filePath }, "Stored file for viewing");
+    log.debug({ id, filePath }, "Stored file for viewing");
     return id;
   }
   storeDiff(sessionId, filePath, oldContent, newContent, workingDirectory) {
     if (!this.isPathAllowed(filePath, workingDirectory)) {
-      log6.warn({ filePath, workingDirectory }, "Path outside workspace, rejecting");
+      log.warn({ filePath, workingDirectory }, "Path outside workspace, rejecting");
       return null;
     }
     const combined = oldContent.length + newContent.length;
     if (combined > MAX_CONTENT_SIZE) {
-      log6.debug({ filePath, size: combined }, "Diff content too large for viewer");
+      log.debug({ filePath, size: combined }, "Diff content too large for viewer");
       return null;
     }
     const id = nanoid(12);
@@ -620,12 +108,12 @@ var ViewerStore = class {
       createdAt: now,
       expiresAt: now + this.ttlMs
     });
-    log6.debug({ id, filePath }, "Stored diff for viewing");
+    log.debug({ id, filePath }, "Stored diff for viewing");
     return id;
   }
   storeOutput(sessionId, label, output) {
     if (output.length > MAX_CONTENT_SIZE) {
-      log6.debug({ label, size: output.length }, "Output too large for viewer");
+      log.debug({ label, size: output.length }, "Output too large for viewer");
       return null;
     }
     const id = nanoid(12);
@@ -641,7 +129,7 @@ var ViewerStore = class {
       createdAt: now,
       expiresAt: now + this.ttlMs
     });
-    log6.debug({ id, label }, "Stored output for viewing");
+    log.debug({ id, label }, "Stored output for viewing");
     return id;
   }
   get(id) {
@@ -663,7 +151,7 @@ var ViewerStore = class {
       }
     }
     if (removed > 0) {
-      log6.debug({ removed, remaining: this.entries.size }, "Cleaned up expired viewer entries");
+      log.debug({ removed, remaining: this.entries.size }, "Cleaned up expired viewer entries");
     }
   }
   isPathAllowed(filePath, workingDirectory) {
@@ -671,24 +159,24 @@ var ViewerStore = class {
     let resolved;
     let workspace;
     try {
-      resolved = fs3.realpathSync(path3.resolve(workingDirectory, filePath));
+      resolved = fs.realpathSync(path.resolve(workingDirectory, filePath));
     } catch {
-      resolved = path3.resolve(workingDirectory, filePath);
+      resolved = path.resolve(workingDirectory, filePath);
     }
     try {
-      workspace = fs3.realpathSync(path3.resolve(workingDirectory));
+      workspace = fs.realpathSync(path.resolve(workingDirectory));
     } catch {
-      workspace = path3.resolve(workingDirectory);
+      workspace = path.resolve(workingDirectory);
     }
     if (caseInsensitive) {
       const rLower = resolved.toLowerCase();
       const wLower = workspace.toLowerCase();
-      return rLower.startsWith(wLower + path3.sep) || rLower === wLower;
+      return rLower.startsWith(wLower + path.sep) || rLower === wLower;
     }
-    return resolved.startsWith(workspace + path3.sep) || resolved === workspace;
+    return resolved.startsWith(workspace + path.sep) || resolved === workspace;
   }
   detectLanguage(filePath) {
-    const ext = path3.extname(filePath).toLowerCase();
+    const ext = path.extname(filePath).toLowerCase();
     return EXTENSION_LANGUAGE[ext];
   }
   destroy() {
@@ -1142,7 +630,7 @@ function createTunnelServer(store, authToken) {
 }
 
 // src/plugins/tunnel/tunnel-service.ts
-var log7 = createChildLogger({ module: "tunnel" });
+var log2 = createChildLogger({ module: "tunnel" });
 var TunnelService = class {
   registry;
   store;
@@ -1150,12 +638,13 @@ var TunnelService = class {
   config;
   systemPort = 0;
   startError;
-  constructor(config) {
+  constructor(config, registryPath) {
     this.config = config;
     this.store = new ViewerStore(config.storeTtlMinutes);
     this.registry = new TunnelRegistry({
       maxUserTunnels: config.maxUserTunnels ?? 5,
-      providerOptions: config.options
+      providerOptions: config.options,
+      registryPath
     });
   }
   async start() {
@@ -1166,23 +655,28 @@ var TunnelService = class {
     for (let i = 0; i < maxRetries; i++) {
       const port = this.config.port + i;
       const server = serve({ fetch: app.fetch, port });
-      const ok = await new Promise((resolve2) => {
-        server.on("listening", () => resolve2(true));
-        server.on("error", () => resolve2(false));
+      const result = await new Promise((resolve2) => {
+        server.on("listening", () => resolve2({ ok: true }));
+        server.on("error", (err) => resolve2({ ok: false, code: err.code }));
       });
-      if (ok) {
+      if (result.ok) {
         this.server = server;
         actualPort = port;
         if (i > 0) {
-          log7.info({ configuredPort: this.config.port, actualPort }, "Configured port in use, using next available");
+          log2.info({ configuredPort: this.config.port, actualPort }, "Configured port in use, using next available");
         }
-        log7.info({ port: actualPort }, "Tunnel HTTP server started");
+        log2.info({ port: actualPort }, "Tunnel HTTP server started");
         break;
       }
       server.close();
+      if (result.code === "EACCES") {
+        log2.error({ port }, "Permission denied binding to port (try a port > 1024)");
+        break;
+      }
     }
     if (!this.server) {
-      log7.warn({ port: this.config.port }, "Could not find available port for tunnel HTTP server");
+      log2.error({ port: this.config.port }, "Failed to start tunnel HTTP server \u2014 no available port");
+      this.startError = `HTTP server failed to bind (tried ports ${this.config.port}-${this.config.port + maxRetries - 1})`;
       return `http://localhost:${this.config.port}`;
     }
     this.systemPort = actualPort;
@@ -1194,7 +688,7 @@ var TunnelService = class {
       });
     } catch (err) {
       this.startError = err.message;
-      log7.warn({ err: this.startError }, "System tunnel failed, running on localhost");
+      log2.warn({ err: this.startError }, "System tunnel failed, running on localhost");
     }
     await this.registry.restore();
     const systemEntry = this.registry.getSystemEntry();
@@ -1208,7 +702,7 @@ var TunnelService = class {
       this.server = null;
     }
     this.store.destroy();
-    log7.info("Tunnel service stopped");
+    log2.info("Tunnel service stopped");
   }
   // --- User tunnel management ---
   async addTunnel(port, opts) {
@@ -1258,4 +752,4 @@ var TunnelService = class {
 export {
   TunnelService
 };
-//# sourceMappingURL=tunnel-service-ZMO4THKE.js.map
+//# sourceMappingURL=tunnel-service-TBAHDXMF.js.map