pubblue 0.4.5 → 0.4.7

package/dist/{chunk-BV423NLA.js → chunk-F4VBBHDR.js}

@@ -1,4 +1,12 @@
 // src/lib/tunnel-api.ts
+var TunnelApiError = class extends Error {
+  constructor(message, status, retryAfterSeconds) {
+    super(message);
+    this.status = status;
+    this.retryAfterSeconds = retryAfterSeconds;
+    this.name = "TunnelApiError";
+  }
+};
 var TunnelApiClient = class {
   constructor(baseUrl, apiKey) {
     this.baseUrl = baseUrl;
@@ -14,13 +22,22 @@ var TunnelApiClient = class {
         ...options.headers
       }
     });
+    const retryAfterHeader = res.headers.get("Retry-After");
+    const parsedRetryAfterSeconds = typeof retryAfterHeader === "string" ? Number.parseInt(retryAfterHeader, 10) : void 0;
+    const retryAfterSeconds = parsedRetryAfterSeconds !== void 0 && Number.isFinite(parsedRetryAfterSeconds) ? parsedRetryAfterSeconds : void 0;
     let data;
     try {
       data = await res.json();
     } catch {
       data = {};
     }
-    if (!res.ok) throw new Error(data.error || `Request failed: ${res.status}`);
+    if (!res.ok) {
+      if (res.status === 429) {
+        const retrySuffix = retryAfterSeconds !== void 0 ? ` Retry after ${retryAfterSeconds}s.` : "";
+        throw new TunnelApiError(`Rate limit exceeded.${retrySuffix}`, res.status, retryAfterSeconds);
+      }
+      throw new TunnelApiError(data.error || `Request failed: ${res.status}`, res.status);
+    }
     return data;
   }
   async create(opts) {
@@ -53,5 +70,6 @@ var TunnelApiClient = class {
 };
 
 export {
+  TunnelApiError,
   TunnelApiClient
 };

package/dist/{chunk-AIEPM67G.js → chunk-HOHLQGQT.js}

@@ -485,13 +485,6 @@ async function startDaemon(config) {
     });
   });
   ipcServer.listen(socketPath);
-  const infoDir = path.dirname(infoPath);
-  if (!fs.existsSync(infoDir)) fs.mkdirSync(infoDir, { recursive: true });
-  fs.writeFileSync(
-    infoPath,
-    JSON.stringify({ pid: process.pid, tunnelId, socketPath, startedAt: startTime })
-  );
-  scheduleNextPoll(0);
   try {
     await runNegotiationCycle();
   } catch (error) {
@@ -500,6 +493,13 @@ async function startDaemon(config) {
     await cleanup();
     throw new Error(`Failed to generate WebRTC offer: ${message}`);
   }
+  const infoDir = path.dirname(infoPath);
+  if (!fs.existsSync(infoDir)) fs.mkdirSync(infoDir, { recursive: true });
+  fs.writeFileSync(
+    infoPath,
+    JSON.stringify({ pid: process.pid, tunnelId, socketPath, startedAt: startTime })
+  );
+  scheduleNextPoll(0);
   async function cleanup() {
     if (stopped) return;
     stopped = true;
@@ -518,9 +518,6 @@ async function startDaemon(config) {
     } catch (error) {
       debugLog("failed to remove daemon info file during cleanup", error);
     }
-    await apiClient.close(tunnelId).catch((error) => {
-      markError("failed to close tunnel on API during cleanup", error);
-    });
   }
   async function shutdown() {
     await cleanup();

package/dist/index.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import {
-  TunnelApiClient
-} from "./chunk-BV423NLA.js";
+  TunnelApiClient,
+  TunnelApiError
+} from "./chunk-F4VBBHDR.js";
 import {
   CHANNELS,
   generateMessageId
@@ -229,25 +230,133 @@ function resolveTunnelIdSelection(tunnelIdArg, tunnelOpt) {
 function buildDaemonForkStdio(logFd) {
   return ["ignore", logFd, logFd, "ipc"];
 }
+function getPublicTunnelUrl(tunnelId) {
+  const base = process.env.PUBBLUE_PUBLIC_URL || "https://pub.blue";
+  return `${base.replace(/\/$/, "")}/t/${tunnelId}`;
+}
+function pickReusableTunnel(tunnels, nowMs = Date.now()) {
+  const active = tunnels.filter((t) => t.status === "active" && t.expiresAt > nowMs).sort((a, b) => b.createdAt - a.createdAt);
+  return active[0] ?? null;
+}
+function readLogTail(logPath, maxChars = 4e3) {
+  if (!fs2.existsSync(logPath)) return null;
+  try {
+    const content = fs2.readFileSync(logPath, "utf-8");
+    if (content.length <= maxChars) return content;
+    return content.slice(-maxChars);
+  } catch {
+    return null;
+  }
+}
+function formatApiError(error) {
+  if (error instanceof TunnelApiError) {
+    if (error.status === 429 && error.retryAfterSeconds !== void 0) {
+      return `Rate limit exceeded. Retry after ${error.retryAfterSeconds}s.`;
+    }
+    return `${error.message} (HTTP ${error.status})`;
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+async function cleanupCreatedTunnelOnStartFailure(apiClient, target) {
+  if (!target.createdNew) return;
+  try {
+    await apiClient.close(target.tunnelId);
+  } catch (closeError) {
+    console.error(
+      `Failed to clean up newly created tunnel ${target.tunnelId}: ${formatApiError(closeError)}`
+    );
+  }
+}
 function registerTunnelCommands(program2) {
   const tunnel = program2.command("tunnel").description("P2P encrypted tunnel to browser");
-  tunnel.command("start").description("Start a new tunnel (spawns background daemon)").option("--expires <duration>", "Auto-close after duration (e.g. 4h, 1d)", "24h").option("--foreground", "Run in foreground (don't fork)").action(async (opts) => {
+  tunnel.command("start").description("Start a tunnel daemon (reuses existing tunnel when possible)").option("--expires <duration>", "Auto-close after duration (e.g. 4h, 1d)", "24h").option("-t, --tunnel <tunnelId>", "Attach/start daemon for an existing tunnel").option("--new", "Always create a new tunnel (skip single-tunnel reuse)").option("--foreground", "Run in foreground (don't fork)").action(async (opts) => {
     await ensureNodeDatachannelAvailable();
     const apiClient = createApiClient();
-    const result = await apiClient.create({
-      expiresIn: opts.expires
-    });
-    const socketPath = getSocketPath(result.tunnelId);
-    const infoPath = tunnelInfoPath(result.tunnelId);
+    let target = null;
+    if (opts.tunnel) {
+      try {
+        const existing = await apiClient.get(opts.tunnel);
+        if (existing.status === "closed" || existing.expiresAt <= Date.now()) {
+          console.error(`Tunnel ${opts.tunnel} is closed or expired.`);
+          process.exit(1);
+        }
+        target = {
+          createdNew: false,
+          expiresAt: existing.expiresAt,
+          mode: "existing",
+          tunnelId: existing.tunnelId,
+          url: getPublicTunnelUrl(existing.tunnelId)
+        };
+      } catch (error) {
+        console.error(`Failed to use tunnel ${opts.tunnel}: ${formatApiError(error)}`);
+        process.exit(1);
+      }
+    } else if (!opts.new) {
+      try {
+        const listed = await apiClient.list();
+        const active = listed.filter((t) => t.status === "active" && t.expiresAt > Date.now()).sort((a, b) => b.createdAt - a.createdAt);
+        const reusable = pickReusableTunnel(listed);
+        if (reusable) {
+          target = {
+            createdNew: false,
+            expiresAt: reusable.expiresAt,
+            mode: "existing",
+            tunnelId: reusable.tunnelId,
+            url: getPublicTunnelUrl(reusable.tunnelId)
+          };
+          if (active.length > 1) {
+            console.error(
+              [
+                `Multiple active tunnels found: ${active.map((t) => t.tunnelId).join(", ")}`,
+                `Reusing most recent active tunnel ${reusable.tunnelId}.`,
+                "Use --tunnel <id> to choose explicitly or --new to force creation."
+              ].join("\n")
+            );
+          } else {
+            console.error(
+              `Reusing existing active tunnel ${reusable.tunnelId}. Use --new to force creation.`
+            );
+          }
+        }
+      } catch (error) {
+        console.error(`Failed to list tunnels for reuse check: ${formatApiError(error)}`);
+        process.exit(1);
+      }
+    }
+    if (!target) {
+      try {
+        const created = await apiClient.create({
+          expiresIn: opts.expires
+        });
+        target = {
+          createdNew: true,
+          expiresAt: created.expiresAt,
+          mode: "created",
+          tunnelId: created.tunnelId,
+          url: created.url
+        };
+      } catch (error) {
+        console.error(`Failed to create tunnel: ${formatApiError(error)}`);
+        process.exit(1);
+      }
+    }
+    if (!target) {
+      console.error("Failed to resolve tunnel target.");
+      process.exit(1);
+    }
+    const socketPath = getSocketPath(target.tunnelId);
+    const infoPath = tunnelInfoPath(target.tunnelId);
+    const logPath = tunnelLogPath(target.tunnelId);
     if (opts.foreground) {
-      const { startDaemon } = await import("./tunnel-daemon-DR4A65ME.js");
-      console.log(`Tunnel started: ${result.url}`);
-      console.log(`Tunnel ID: ${result.tunnelId}`);
-      console.log(`Expires: ${new Date(result.expiresAt).toISOString()}`);
+      const { startDaemon } = await import("./tunnel-daemon-4LV6HLYN.js");
+      console.log(`Tunnel started: ${target.url}`);
+      console.log(`Tunnel ID: ${target.tunnelId}`);
+      console.log(`Expires: ${new Date(target.expiresAt).toISOString()}`);
+      if (target.mode === "existing") console.log("Mode: attached existing tunnel");
       console.log("Running in foreground. Press Ctrl+C to stop.");
       try {
         await startDaemon({
-          tunnelId: result.tunnelId,
+          tunnelId: target.tunnelId,
           apiClient,
           socketPath,
           infoPath
@@ -258,16 +367,33 @@ function registerTunnelCommands(program2) {
         process.exit(1);
       }
     } else {
+      if (isDaemonRunning(target.tunnelId)) {
+        try {
+          const status = await ipcCall(socketPath, { method: "status", params: {} });
+          if (!status.ok) throw new Error(String(status.error || "status check failed"));
+        } catch (error) {
+          console.error(
+            `Daemon process exists but is not responding: ${error instanceof Error ? error.message : String(error)}`
+          );
+          console.error("Run `pubblue tunnel close <id>` and start again.");
+          process.exit(1);
+        }
+        console.log(`Tunnel started: ${target.url}`);
+        console.log(`Tunnel ID: ${target.tunnelId}`);
+        console.log(`Expires: ${new Date(target.expiresAt).toISOString()}`);
+        console.log("Daemon already running for this tunnel.");
+        console.log(`Daemon log: ${logPath}`);
+        return;
+      }
       const daemonScript = path2.join(import.meta.dirname, "tunnel-daemon-entry.js");
       const config = getConfig();
-      const logPath = tunnelLogPath(result.tunnelId);
       const daemonLogFd = fs2.openSync(logPath, "a");
       const child = fork(daemonScript, [], {
         detached: true,
         stdio: buildDaemonForkStdio(daemonLogFd),
         env: {
           ...process.env,
-          PUBBLUE_DAEMON_TUNNEL_ID: result.tunnelId,
+          PUBBLUE_DAEMON_TUNNEL_ID: target.tunnelId,
           PUBBLUE_DAEMON_BASE_URL: config.baseUrl,
           PUBBLUE_DAEMON_API_KEY: config.apiKey,
           PUBBLUE_DAEMON_SOCKET: socketPath,
@@ -279,17 +405,47 @@ function registerTunnelCommands(program2) {
         child.disconnect();
       }
       child.unref();
-      const ready = await waitForDaemonReady(infoPath, child, 5e3);
-      if (!ready) {
-        console.error("Daemon failed to start. Cleaning up tunnel...");
+      console.log(`Starting daemon for tunnel ${target.tunnelId}...`);
+      const ready = await waitForDaemonReady({
+        child,
+        infoPath,
+        socketPath,
+        timeoutMs: 8e3
+      });
+      if (!ready.ok) {
+        console.error(`Daemon failed to start: ${ready.reason ?? "unknown reason"}`);
         console.error(`Daemon log: ${logPath}`);
-        await apiClient.close(result.tunnelId).catch(() => {
-        });
+        const tail = readLogTail(logPath);
+        if (tail) {
+          console.error("---- daemon log tail ----");
+          console.error(tail.trimEnd());
+          console.error("---- end daemon log tail ----");
+        }
+        await cleanupCreatedTunnelOnStartFailure(apiClient, target);
         process.exit(1);
       }
-      console.log(`Tunnel started: ${result.url}`);
-      console.log(`Tunnel ID: ${result.tunnelId}`);
-      console.log(`Expires: ${new Date(result.expiresAt).toISOString()}`);
+      const offerReady = await waitForAgentOffer({
+        apiClient,
+        tunnelId: target.tunnelId,
+        timeoutMs: 5e3
+      });
+      if (!offerReady.ok) {
+        console.error(`Daemon started but signaling is not ready: ${offerReady.reason}`);
+        console.error(`Daemon log: ${logPath}`);
+        const tail = readLogTail(logPath);
+        if (tail) {
+          console.error("---- daemon log tail ----");
+          console.error(tail.trimEnd());
+          console.error("---- end daemon log tail ----");
+        }
+        await cleanupCreatedTunnelOnStartFailure(apiClient, target);
+        process.exit(1);
+      }
+      console.log(`Tunnel started: ${target.url}`);
+      console.log(`Tunnel ID: ${target.tunnelId}`);
+      console.log(`Expires: ${new Date(target.expiresAt).toISOString()}`);
+      if (target.mode === "existing") console.log("Mode: attached existing tunnel");
+      console.log("Daemon health: OK");
       console.log(`Daemon log: ${logPath}`);
     }
   });
@@ -447,19 +603,16 @@ function registerTunnelCommands(program2) {
   });
   tunnel.command("close").description("Close a tunnel and stop its daemon").argument("<tunnelId>", "Tunnel ID").action(async (tunnelId) => {
     const socketPath = getSocketPath(tunnelId);
-    let closedByDaemon = false;
     try {
-      const daemonResult = await ipcCall(socketPath, { method: "close", params: {} });
-      closedByDaemon = daemonResult.ok;
+      await ipcCall(socketPath, { method: "close", params: {} });
     } catch {
-      closedByDaemon = false;
     }
-    if (!closedByDaemon) {
-      const apiClient = createApiClient();
-      try {
-        await apiClient.close(tunnelId);
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
+    const apiClient = createApiClient();
+    try {
+      await apiClient.close(tunnelId);
+    } catch (error) {
+      const message = formatApiError(error);
+      if (!/Tunnel not found/i.test(message)) {
         console.error(`Failed to close tunnel ${tunnelId}: ${message}`);
         process.exit(1);
       }
@@ -483,23 +636,65 @@ async function resolveActiveTunnel() {
   console.error(`Multiple active tunnels: ${active.join(", ")}. Specify one.`);
   process.exit(1);
 }
-function waitForDaemonReady(infoPath, child, timeoutMs) {
+function waitForDaemonReady({
+  child,
+  infoPath,
+  socketPath,
+  timeoutMs
+}) {
   return new Promise((resolve3) => {
     let settled = false;
-    const done = (value) => {
+    let pollInFlight = false;
+    let lastIpcError = null;
+    const done = (result) => {
       if (settled) return;
       settled = true;
       clearInterval(poll);
       clearTimeout(timeout);
-      resolve3(value);
+      child.off("exit", onExit);
+      resolve3(result);
+    };
+    const onExit = (code, signal) => {
+      const suffix = signal ? ` (signal ${signal})` : "";
+      done({ ok: false, reason: `daemon exited with code ${code ?? 0}${suffix}` });
     };
-    child.on("exit", () => done(false));
+    child.on("exit", onExit);
     const poll = setInterval(() => {
-      if (fs2.existsSync(infoPath)) done(true);
-    }, 100);
-    const timeout = setTimeout(() => done(false), timeoutMs);
+      if (pollInFlight || !fs2.existsSync(infoPath)) return;
+      pollInFlight = true;
+      void ipcCall(socketPath, { method: "status", params: {} }).then((status) => {
+        if (status.ok) done({ ok: true });
+      }).catch((error) => {
+        lastIpcError = error instanceof Error ? error.message : String(error);
+      }).finally(() => {
+        pollInFlight = false;
+      });
+    }, 120);
+    const timeout = setTimeout(() => {
+      const reason = lastIpcError ? `timed out after ${timeoutMs}ms waiting for daemon readiness (last IPC error: ${lastIpcError})` : `timed out after ${timeoutMs}ms waiting for daemon readiness`;
+      done({ ok: false, reason });
+    }, timeoutMs);
   });
 }
+async function waitForAgentOffer(params) {
+  const startedAt = Date.now();
+  let lastError = null;
+  while (Date.now() - startedAt < params.timeoutMs) {
+    try {
+      const tunnel = await params.apiClient.get(params.tunnelId);
+      if (typeof tunnel.agentOffer === "string" && tunnel.agentOffer.length > 0) {
+        return { ok: true };
+      }
+    } catch (error) {
+      lastError = formatApiError(error);
+    }
+    await new Promise((resolve3) => setTimeout(resolve3, 150));
+  }
+  return {
+    ok: false,
+    reason: lastError ? `agent offer was not published in time (last API error: ${lastError})` : "agent offer was not published in time"
+  };
+}
 
 // src/lib/api.ts
 var PubApiClient = class {
@@ -632,7 +827,7 @@ function readFile(filePath) {
     basename: path3.basename(resolved)
   };
 }
-program.name("pubblue").description("Publish static content and get shareable URLs").version("0.4.5");
+program.name("pubblue").description("Publish static content and get shareable URLs").version("0.4.7");
 program.command("configure").description("Configure the CLI with your API key").option("--api-key <key>", "Your API key (less secure: appears in shell history)").option("--api-key-stdin", "Read API key from stdin").action(async (opts) => {
   try {
     const apiKey = await resolveConfigureApiKey(opts);

package/dist/{tunnel-daemon-DR4A65ME.js → tunnel-daemon-4LV6HLYN.js}

@@ -2,7 +2,7 @@ import {
   getTunnelWriteReadinessError,
   shouldRecoverForBrowserAnswerChange,
   startDaemon
-} from "./chunk-AIEPM67G.js";
+} from "./chunk-HOHLQGQT.js";
 import "./chunk-MW35LBNH.js";
 export {
   getTunnelWriteReadinessError,

package/dist/tunnel-daemon-entry.js

@@ -1,9 +1,9 @@
 import {
   TunnelApiClient
-} from "./chunk-BV423NLA.js";
+} from "./chunk-F4VBBHDR.js";
 import {
   startDaemon
-} from "./chunk-AIEPM67G.js";
+} from "./chunk-HOHLQGQT.js";
 import "./chunk-MW35LBNH.js";
 
 // src/tunnel-daemon-entry.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pubblue",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "CLI tool for publishing static content via pub.blue",
   "type": "module",
   "bin": {