pubblue 0.4.5 → 0.4.10

package/dist/{chunk-BV423NLA.js → chunk-7NFHPJ76.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,26 @@ 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 +74,6 @@ var TunnelApiClient = class {
 };
 
 export {
+  TunnelApiError,
   TunnelApiClient
 };

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
+};

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();