pubblue 0.4.12 → 0.5.0

package/dist/{chunk-UW7JILRJ.js → chunk-5GSMS3YU.js}

@@ -1,6 +1,11 @@
 import {
-  TunnelApiError
-} from "./chunk-7NFHPJ76.js";
+  PubApiError,
+  buildBridgeForkStdio,
+  isBridgeRunning,
+  latestCliVersionPath,
+  readLatestCliVersion,
+  stopBridge
+} from "./chunk-YI45G6AG.js";
 import {
   CHANNELS,
   CONTROL_CHANNEL,
@@ -9,9 +14,10 @@ import {
   makeAckMessage,
   parseAckMessage,
   shouldAcknowledgeMessage
-} from "./chunk-4YTJ2WKF.js";
+} from "./chunk-PFZT7M3E.js";
 
 // src/lib/tunnel-daemon.ts
+import { fork } from "child_process";
 import * as fs from "fs";
 import * as net from "net";
 import * as path from "path";
@@ -57,13 +63,16 @@ function generateOffer(peer, timeoutMs) {
 }
 
 // src/lib/tunnel-daemon-shared.ts
+var BRIDGE_CHECK_INTERVAL_MS = 3e4;
+var BRIDGE_MAX_RAPID_RESTARTS = 3;
+var BRIDGE_RAPID_RESTART_WINDOW_MS = 5 * 60 * 1e3;
 var OFFER_TIMEOUT_MS = 1e4;
 var SIGNAL_POLL_WAITING_MS = 5e3;
 var SIGNAL_POLL_CONNECTED_MS = 15e3;
 var LOCAL_CANDIDATE_FLUSH_MS = 2e3;
 var RECOVERY_DELAY_MS = 1e3;
 var WRITE_ACK_TIMEOUT_MS = 5e3;
-var NOT_CONNECTED_WRITE_ERROR = "No browser connected. Ask the user to open the tunnel URL first, then retry.";
+var NOT_CONNECTED_WRITE_ERROR = "No browser connected. Ask the user to open the pub URL first, then retry.";
 function getTunnelWriteReadinessError(isConnected) {
   return isConnected ? null : NOT_CONNECTED_WRITE_ERROR;
 }
@@ -83,8 +92,11 @@ function getSignalPollDelayMs(params) {
 }
 
 // src/lib/tunnel-daemon.ts
+var IDLE_SLOWDOWN_AFTER_MS = 3 * 24 * 60 * 60 * 1e3;
+var IDLE_SIGNAL_POLL_MS = 5 * 60 * 1e3;
+var HEALTH_CHECK_INTERVAL_MS = 60 * 60 * 1e3;
 async function startDaemon(config) {
-  const { tunnelId, apiClient, socketPath, infoPath, cliVersion } = config;
+  const { slug, apiClient, socketPath, infoPath, cliVersion } = config;
   const ndc = await import("node-datachannel");
   const buffer = { messages: [] };
   const startTime = Date.now();
@@ -107,12 +119,15 @@ async function startDaemon(config) {
   let localCandidateInterval = null;
   let localCandidateStopTimer = null;
   let recoveryTimer = null;
+  let healthCheckTimer = null;
   let lastError = null;
   const debugEnabled = process.env.PUBBLUE_TUNNEL_DEBUG === "1";
+  let lastConnectedAt = startTime;
+  const versionFilePath = latestCliVersionPath();
   function debugLog(message, error) {
     if (!debugEnabled) return;
     const detail = error === void 0 ? "" : ` | ${error instanceof Error ? `${error.name}: ${error.message}` : typeof error === "string" ? error : JSON.stringify(error)}`;
-    console.error(`[pubblue-daemon:${tunnelId}] ${message}${detail}`);
+    console.error(`[pubblue-daemon:${slug}] ${message}${detail}`);
   }
   function markError(message, error) {
     const detail = error === void 0 ? message : `${message}: ${error instanceof Error ? error.message : typeof error === "string" ? error : JSON.stringify(error)}`;
@@ -141,6 +156,27 @@ async function startDaemon(config) {
       recoveryTimer = null;
     }
   }
+  function clearHealthCheckTimer() {
+    if (healthCheckTimer) {
+      clearInterval(healthCheckTimer);
+      healthCheckTimer = null;
+    }
+  }
+  function runHealthCheck() {
+    if (stopped) return;
+    if (cliVersion) {
+      const latest = readLatestCliVersion(versionFilePath);
+      if (latest && latest !== cliVersion) {
+        markError(`detected CLI upgrade (${cliVersion} \u2192 ${latest}); shutting down`);
+        void shutdown();
+      }
+    }
+  }
+  function startHealthCheckTimer() {
+    clearHealthCheckTimer();
+    healthCheckTimer = setInterval(runHealthCheck, HEALTH_CHECK_INTERVAL_MS);
+    runHealthCheck();
+  }
   function setupChannel(name, dc) {
     channels.set(name, dc);
     dc.onOpen(() => {
@@ -330,7 +366,7 @@ async function startDaemon(config) {
       if (localCandidates.length <= lastSentCandidateCount) return;
       const newOnes = localCandidates.slice(lastSentCandidateCount);
       lastSentCandidateCount = localCandidates.length;
-      await apiClient.signal(tunnelId, { candidates: newOnes }).catch((error) => {
+      await apiClient.signal(slug, { candidates: newOnes }).catch((error) => {
         debugLog("failed to publish local ICE candidates", error);
       });
     }, LOCAL_CANDIDATE_FLUSH_MS);
@@ -347,6 +383,7 @@ async function startDaemon(config) {
       if (stopped || currentPeer !== peer) return;
       if (state === "connected") {
         connected = true;
+        lastConnectedAt = Date.now();
         flushQueuedAcks();
         void replayStickyOutboundMessages();
         return;
@@ -401,9 +438,9 @@ async function startDaemon(config) {
     }, delayMs);
   }
   async function pollSignalingOnce() {
-    const tunnel = await apiClient.get(tunnelId);
+    const session = await apiClient.getLive(slug);
     if (shouldRecoverForBrowserAnswerChange({
-      incomingBrowserAnswer: tunnel.browserAnswer,
+      incomingBrowserAnswer: session.browserAnswer,
       lastAppliedBrowserAnswer,
       remoteDescriptionApplied
     })) {
@@ -411,13 +448,13 @@ async function startDaemon(config) {
       scheduleRecovery(0, true);
       return;
     }
-    if (tunnel.browserAnswer && !remoteDescriptionApplied) {
+    if (session.browserAnswer && !remoteDescriptionApplied) {
       if (!peer) return;
       try {
-        const answer = JSON.parse(tunnel.browserAnswer);
+        const answer = JSON.parse(session.browserAnswer);
         peer.setRemoteDescription(answer.sdp, answer.type);
         remoteDescriptionApplied = true;
-        lastAppliedBrowserAnswer = tunnel.browserAnswer;
+        lastAppliedBrowserAnswer = session.browserAnswer;
         while (pendingRemoteCandidates.length > 0) {
           const next = pendingRemoteCandidates.shift();
           if (!next) break;
@@ -431,9 +468,9 @@ async function startDaemon(config) {
         markError("failed to apply browser answer", error);
       }
     }
-    if (tunnel.browserCandidates.length > lastBrowserCandidateCount) {
-      const newCandidates = tunnel.browserCandidates.slice(lastBrowserCandidateCount);
-      lastBrowserCandidateCount = tunnel.browserCandidates.length;
+    if (session.browserCandidates.length > lastBrowserCandidateCount) {
+      const newCandidates = session.browserCandidates.slice(lastBrowserCandidateCount);
+      lastBrowserCandidateCount = session.browserCandidates.length;
       for (const c of newCandidates) {
         try {
           const parsed = JSON.parse(c);
@@ -457,18 +494,20 @@ async function startDaemon(config) {
     try {
       await pollSignalingOnce();
     } catch (error) {
-      if (error instanceof TunnelApiError && error.status === 429) {
+      if (error instanceof PubApiError && error.status === 429) {
         retryAfterSeconds = error.retryAfterSeconds;
       }
       markError("signaling poll failed", error);
     }
-    scheduleNextPoll(getSignalPollDelayMs({ remoteDescriptionApplied, retryAfterSeconds }));
+    const baseDelay = getSignalPollDelayMs({ remoteDescriptionApplied, retryAfterSeconds });
+    const idleSlowdown = !connected && Date.now() - lastConnectedAt >= IDLE_SLOWDOWN_AFTER_MS ? IDLE_SIGNAL_POLL_MS : 0;
+    scheduleNextPoll(Math.max(baseDelay, idleSlowdown));
   }
   async function runNegotiationCycle() {
     if (!peer) throw new Error("PeerConnection not initialized");
     resetNegotiationState();
     const offer = await generateOffer(peer, OFFER_TIMEOUT_MS);
-    await apiClient.signal(tunnelId, { offer });
+    await apiClient.signal(slug, { offer });
     startLocalCandidateFlush();
   }
   async function recoverPeer() {
@@ -548,15 +587,78 @@ async function startDaemon(config) {
   if (!fs.existsSync(infoDir)) fs.mkdirSync(infoDir, { recursive: true });
   fs.writeFileSync(
     infoPath,
-    JSON.stringify({ pid: process.pid, tunnelId, socketPath, startedAt: startTime, cliVersion })
+    JSON.stringify({ pid: process.pid, slug, socketPath, startedAt: startTime, cliVersion })
   );
+  startHealthCheckTimer();
   scheduleNextPoll(0);
+  let bridgeCheckTimer = null;
+  const bridgeRestartTimestamps = [];
+  function pruneBridgeRestartTimestamps() {
+    const cutoff = Date.now() - BRIDGE_RAPID_RESTART_WINDOW_MS;
+    while (bridgeRestartTimestamps.length > 0 && bridgeRestartTimestamps[0] < cutoff) {
+      bridgeRestartTimestamps.shift();
+    }
+  }
+  function restartBridge() {
+    if (stopped || !config.bridge) return;
+    const { bridgeMode, bridgeScript, bridgeInfoPath, bridgeLogPath, bridgeProcessEnv } = config.bridge;
+    pruneBridgeRestartTimestamps();
+    if (bridgeRestartTimestamps.length >= BRIDGE_MAX_RAPID_RESTARTS) {
+      markError(
+        `bridge crashed ${BRIDGE_MAX_RAPID_RESTARTS} times within ${BRIDGE_RAPID_RESTART_WINDOW_MS / 1e3}s; giving up`
+      );
+      return;
+    }
+    bridgeRestartTimestamps.push(Date.now());
+    debugLog("bridge process is dead; restarting");
+    try {
+      const logFd = fs.openSync(bridgeLogPath, "a");
+      const child = fork(bridgeScript, [], {
+        detached: true,
+        stdio: buildBridgeForkStdio(logFd),
+        env: {
+          ...bridgeProcessEnv,
+          PUBBLUE_BRIDGE_MODE: bridgeMode,
+          PUBBLUE_BRIDGE_SLUG: slug,
+          PUBBLUE_BRIDGE_SOCKET: socketPath,
+          PUBBLUE_BRIDGE_INFO: bridgeInfoPath
+        }
+      });
+      fs.closeSync(logFd);
+      if (child.connected) child.disconnect();
+      child.unref();
+    } catch (error) {
+      markError("failed to restart bridge process", error);
+    }
+  }
+  function checkBridgeLiveness() {
+    if (stopped || !config.bridge) return;
+    if (!isBridgeRunning(slug)) restartBridge();
+  }
+  function startBridgeCheckTimer() {
+    if (!config.bridge) return;
+    bridgeCheckTimer = setInterval(checkBridgeLiveness, BRIDGE_CHECK_INTERVAL_MS);
+  }
+  function clearBridgeCheckTimer() {
+    if (bridgeCheckTimer) {
+      clearInterval(bridgeCheckTimer);
+      bridgeCheckTimer = null;
+    }
+  }
+  async function stopBridgeProcess() {
+    const error = await stopBridge(slug);
+    if (error) debugLog(error);
+  }
+  startBridgeCheckTimer();
   async function cleanup() {
     if (stopped) return;
     stopped = true;
     clearPollingTimer();
     clearLocalCandidateTimers();
     clearRecoveryTimer();
+    clearHealthCheckTimer();
+    clearBridgeCheckTimer();
+    await stopBridgeProcess();
     closeCurrentPeer();
     ipcServer.close();
     try {
@@ -670,8 +772,5 @@ async function startDaemon(config) {
 }
 
 export {
-  getTunnelWriteReadinessError,
-  shouldRecoverForBrowserAnswerChange,
-  getSignalPollDelayMs,
   startDaemon
 };

package/dist/{chunk-4YTJ2WKF.js → chunk-PFZT7M3E.js}

@@ -48,6 +48,58 @@ function shouldAcknowledgeMessage(channel, msg) {
 var MAX_TUNNEL_EXPIRY_MS = 7 * 24 * 60 * 60 * 1e3;
 var DEFAULT_TUNNEL_EXPIRY_MS = 24 * 60 * 60 * 1e3;
 
+// src/lib/tunnel-ipc.ts
+import * as net from "net";
+function getSocketPath(slug) {
+  return `/tmp/pubblue-${slug}.sock`;
+}
+async function ipcCall(socketPath, request) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timeoutId = null;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      fn();
+    };
+    const client = net.createConnection(socketPath, () => {
+      client.write(`${JSON.stringify(request)}
+`);
+    });
+    let data = "";
+    client.on("data", (chunk) => {
+      data += chunk.toString();
+      const newlineIdx = data.indexOf("\n");
+      if (newlineIdx !== -1) {
+        const line = data.slice(0, newlineIdx);
+        client.end();
+        try {
+          finish(() => resolve(JSON.parse(line)));
+        } catch {
+          finish(() => reject(new Error("Invalid response from daemon")));
+        }
+      }
+    });
+    client.on("error", (err) => {
+      if (err.code === "ECONNREFUSED" || err.code === "ENOENT") {
+        finish(() => reject(new Error("Daemon not running. Is the tunnel still active?")));
+      } else {
+        finish(() => reject(err));
+      }
+    });
+    client.on("end", () => {
+      if (!data.includes("\n")) {
+        finish(() => reject(new Error("Daemon closed connection unexpectedly")));
+      }
+    });
+    timeoutId = setTimeout(() => {
+      client.destroy();
+      finish(() => reject(new Error("Daemon request timed out")));
+    }, 1e4);
+  });
+}
+
 export {
   CONTROL_CHANNEL,
   CHANNELS,
@@ -56,5 +108,7 @@ export {
   decodeMessage,
   makeAckMessage,
   parseAckMessage,
-  shouldAcknowledgeMessage
+  shouldAcknowledgeMessage,
+  getSocketPath,
+  ipcCall
 };