pubblue 0.4.7 → 0.4.11

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

@@ -1,4 +1,4 @@
-// src/lib/bridge-protocol.ts
+// ../shared/bridge-protocol-core.ts
 var CONTROL_CHANNEL = "_control";
 var CHANNELS = {
   CHAT: "chat",

package/dist/{chunk-F4VBBHDR.js → chunk-7NFHPJ76.js}

@@ -34,7 +34,11 @@ var TunnelApiClient = class {
     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(
+          `Rate limit exceeded.${retrySuffix}`,
+          res.status,
+          retryAfterSeconds
+        );
       }
       throw new TunnelApiError(data.error || `Request failed: ${res.status}`, res.status);
     }

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

@@ -6,21 +6,54 @@ import {
   makeAckMessage,
   parseAckMessage,
   shouldAcknowledgeMessage
-} from "./chunk-MW35LBNH.js";
+} from "./chunk-4YTJ2WKF.js";
 
 // src/lib/tunnel-daemon.ts
 import * as fs from "fs";
 import * as net from "net";
 import * as path from "path";
 
-// src/lib/ack-routing.ts
+// ../shared/ack-routing-core.ts
 function resolveAckChannel(input) {
   if (input.messageChannelOpen) return input.messageChannel;
   if (input.controlChannelOpen) return CONTROL_CHANNEL;
   return null;
 }
 
-// src/lib/tunnel-daemon.ts
+// src/lib/tunnel-daemon-offer.ts
+function generateOffer(peer, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let resolved = false;
+    const done = (sdp, type) => {
+      if (resolved) return;
+      resolved = true;
+      clearTimeout(timeout);
+      resolve(JSON.stringify({ sdp, type }));
+    };
+    peer.onLocalDescription((sdp, type) => {
+      done(sdp, type);
+    });
+    peer.onGatheringStateChange((state) => {
+      if (state === "complete" && !resolved) {
+        const desc = peer.localDescription();
+        if (desc) done(desc.sdp, desc.type);
+      }
+    });
+    const timeout = setTimeout(() => {
+      if (resolved) return;
+      const desc = peer.localDescription();
+      if (desc) {
+        done(desc.sdp, desc.type);
+      } else {
+        resolved = true;
+        reject(new Error(`Timed out after ${timeoutMs}ms`));
+      }
+    }, timeoutMs);
+    peer.setLocalDescription();
+  });
+}
+
+// src/lib/tunnel-daemon-shared.ts
 var OFFER_TIMEOUT_MS = 1e4;
 var SIGNAL_POLL_WAITING_MS = 500;
 var SIGNAL_POLL_CONNECTED_MS = 2e3;
@@ -36,8 +69,10 @@ function shouldRecoverForBrowserAnswerChange(params) {
   if (!incomingBrowserAnswer) return false;
   return incomingBrowserAnswer !== lastAppliedBrowserAnswer;
 }
+
+// src/lib/tunnel-daemon.ts
 async function startDaemon(config) {
-  const { tunnelId, apiClient, socketPath, infoPath } = config;
+  const { tunnelId, apiClient, socketPath, infoPath, cliVersion } = config;
   const ndc = await import("node-datachannel");
   const buffer = { messages: [] };
   const startTime = Date.now();
@@ -497,7 +532,7 @@ 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 })
+    JSON.stringify({ pid: process.pid, tunnelId, socketPath, startedAt: startTime, cliVersion })
   );
   scheduleNextPoll(0);
   async function cleanup() {
@@ -617,37 +652,6 @@ async function startDaemon(config) {
     }
   }
 }
-function generateOffer(peer, timeoutMs) {
-  return new Promise((resolve, reject) => {
-    let resolved = false;
-    const done = (sdp, type) => {
-      if (resolved) return;
-      resolved = true;
-      clearTimeout(timeout);
-      resolve(JSON.stringify({ sdp, type }));
-    };
-    peer.onLocalDescription((sdp, type) => {
-      done(sdp, type);
-    });
-    peer.onGatheringStateChange((state) => {
-      if (state === "complete" && !resolved) {
-        const desc = peer.localDescription();
-        if (desc) done(desc.sdp, desc.type);
-      }
-    });
-    const timeout = setTimeout(() => {
-      if (resolved) return;
-      const desc = peer.localDescription();
-      if (desc) {
-        done(desc.sdp, desc.type);
-      } else {
-        resolved = true;
-        reject(new Error(`Timed out after ${timeoutMs}ms`));
-      }
-    }, timeoutMs);
-    peer.setLocalDescription();
-  });
-}
 
 export {
   getTunnelWriteReadinessError,

package/dist/chunk-HJ5LTUHS.js

@@ -0,0 +1,56 @@
+// src/lib/tunnel-ipc.ts
+import * as net from "net";
+function getSocketPath(tunnelId) {
+  return `/tmp/pubblue-${tunnelId}.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 {
+  getSocketPath,
+  ipcCall
+};