pubblue 0.4.0 → 0.4.2

package/dist/{chunk-OLY5PC4A.js → chunk-3RFMAQOM.js}

@@ -9,6 +9,11 @@ import {
 import * as fs from "fs";
 import * as net from "net";
 import * as path from "path";
+var OFFER_TIMEOUT_MS = 1e4;
+var NOT_CONNECTED_WRITE_ERROR = "No browser connected. Ask the user to open the tunnel URL first, then retry.";
+function getTunnelWriteReadinessError(isConnected) {
+  return isConnected ? null : NOT_CONNECTED_WRITE_ERROR;
+}
 async function startDaemon(config) {
   const { tunnelId, apiClient, socketPath, infoPath } = config;
   const ndc = await import("node-datachannel");
@@ -99,12 +104,83 @@ async function startDaemon(config) {
   peer.onDataChannel((dc) => {
     setupChannel(dc.getLabel(), dc);
   });
-  const offer = await new Promise((resolve) => {
-    peer.onLocalDescription((sdp, type) => {
-      resolve(JSON.stringify({ sdp, type }));
+  if (fs.existsSync(socketPath)) {
+    let stale = true;
+    try {
+      const raw = fs.readFileSync(infoPath, "utf-8");
+      const info = JSON.parse(raw);
+      process.kill(info.pid, 0);
+      stale = false;
+    } catch {
+      stale = true;
+    }
+    if (stale) {
+      try {
+        fs.unlinkSync(socketPath);
+      } catch {
+      }
+    } else {
+      throw new Error(`Daemon already running (socket: ${socketPath})`);
+    }
+  }
+  const ipcServer = net.createServer((conn) => {
+    let data = "";
+    conn.on("data", (chunk) => {
+      data += chunk.toString();
+      const newlineIdx = data.indexOf("\n");
+      if (newlineIdx === -1) return;
+      const line = data.slice(0, newlineIdx);
+      data = data.slice(newlineIdx + 1);
+      let request;
+      try {
+        request = JSON.parse(line);
+      } catch {
+        conn.write(`${JSON.stringify({ ok: false, error: "Invalid JSON" })}
+`);
+        return;
+      }
+      handleIpcRequest(request).then((response) => conn.write(`${JSON.stringify(response)}
+`)).catch((err) => conn.write(`${JSON.stringify({ ok: false, error: String(err) })}
+`));
     });
-    peer.setLocalDescription();
   });
+  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 })
+  );
+  async function cleanup() {
+    if (pollingInterval) clearInterval(pollingInterval);
+    for (const dc of channels.values()) dc.close();
+    peer.close();
+    ipcServer.close();
+    try {
+      fs.unlinkSync(socketPath);
+    } catch {
+    }
+    try {
+      fs.unlinkSync(infoPath);
+    } catch {
+    }
+    await apiClient.close(tunnelId).catch(() => {
+    });
+  }
+  async function shutdown() {
+    await cleanup();
+    process.exit(0);
+  }
+  process.on("SIGTERM", () => void shutdown());
+  process.on("SIGINT", () => void shutdown());
+  let offer;
+  try {
+    offer = await generateOffer(peer, OFFER_TIMEOUT_MS);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await cleanup();
+    throw new Error(`Failed to generate WebRTC offer: ${message}`);
+  }
   await apiClient.signal(tunnelId, { offer });
   setTimeout(async () => {
     if (localCandidates.length > 0) {
@@ -161,52 +237,12 @@ async function startDaemon(config) {
     } catch {
     }
   }, 500);
-  if (fs.existsSync(socketPath)) {
-    const infoFile = infoPath;
-    let stale = true;
-    try {
-      const raw = fs.readFileSync(infoFile, "utf-8");
-      const info = JSON.parse(raw);
-      process.kill(info.pid, 0);
-      stale = false;
-    } catch {
-      stale = true;
-    }
-    if (stale) {
-      try {
-        fs.unlinkSync(socketPath);
-      } catch {
-      }
-    } else {
-      throw new Error(`Daemon already running (socket: ${socketPath})`);
-    }
-  }
-  const ipcServer = net.createServer((conn) => {
-    let data = "";
-    conn.on("data", (chunk) => {
-      data += chunk.toString();
-      const newlineIdx = data.indexOf("\n");
-      if (newlineIdx === -1) return;
-      const line = data.slice(0, newlineIdx);
-      data = data.slice(newlineIdx + 1);
-      let request;
-      try {
-        request = JSON.parse(line);
-      } catch {
-        conn.write(`${JSON.stringify({ ok: false, error: "Invalid JSON" })}
-`);
-        return;
-      }
-      handleIpcRequest(request).then((response) => conn.write(`${JSON.stringify(response)}
-`)).catch((err) => conn.write(`${JSON.stringify({ ok: false, error: String(err) })}
-`));
-    });
-  });
-  ipcServer.listen(socketPath);
   async function handleIpcRequest(req) {
     switch (req.method) {
       case "write": {
         const channel = req.params.channel || CHANNELS.CHAT;
+        const readinessError = getTunnelWriteReadinessError(connected);
+        if (readinessError) return { ok: false, error: readinessError };
         const msg = req.params.msg;
         const binaryBase64 = typeof req.params.binaryBase64 === "string" ? req.params.binaryBase64 : void 0;
         const dc = channels.get(channel);
@@ -274,38 +310,40 @@ async function startDaemon(config) {
         return { ok: false, error: `Unknown method: ${req.method}` };
     }
   }
-  async function shutdown() {
-    if (pollingInterval) clearInterval(pollingInterval);
-    for (const dc of channels.values()) dc.close();
-    peer.close();
-    ipcServer.close();
-    try {
-      fs.unlinkSync(socketPath);
-    } catch {
-    }
-    try {
-      fs.unlinkSync(infoPath);
-    } catch {
-    }
-    await apiClient.close(tunnelId).catch(() => {
+}
+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);
     });
-    process.exit(0);
-  }
-  process.on("SIGTERM", () => void shutdown());
-  process.on("SIGINT", () => void shutdown());
-  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
-    })
-  );
+    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,
   startDaemon
 };

package/dist/index.js

@@ -227,19 +227,25 @@ function registerTunnelCommands(program2) {
     const socketPath = getSocketPath(result.tunnelId);
     const infoPath = tunnelInfoPath(result.tunnelId);
     if (opts.foreground) {
-      const { startDaemon } = await import("./tunnel-daemon-CHNV373I.js");
+      const { startDaemon } = await import("./tunnel-daemon-K7Z7FUFN.js");
       console.log(`Tunnel started: ${result.url}`);
       console.log(`Tunnel ID: ${result.tunnelId}`);
       console.log(`Expires: ${new Date(result.expiresAt).toISOString()}`);
       console.log("Running in foreground. Press Ctrl+C to stop.");
-      await startDaemon({
-        tunnelId: result.tunnelId,
-        apiClient,
-        socketPath,
-        infoPath
-      });
+      try {
+        await startDaemon({
+          tunnelId: result.tunnelId,
+          apiClient,
+          socketPath,
+          infoPath
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Daemon failed: ${message}`);
+        process.exit(1);
+      }
     } else {
-      const daemonScript = path2.join(import.meta.dirname, "..", "tunnel-daemon-entry.js");
+      const daemonScript = path2.join(import.meta.dirname, "tunnel-daemon-entry.js");
       const config = getConfig();
       const child = fork(daemonScript, [], {
         detached: true,
@@ -254,6 +260,13 @@ function registerTunnelCommands(program2) {
         }
       });
       child.unref();
+      const ready = await waitForDaemonReady(infoPath, child, 5e3);
+      if (!ready) {
+        console.error("Daemon failed to start. Cleaning up tunnel...");
+        await apiClient.close(result.tunnelId).catch(() => {
+        });
+        process.exit(1);
+      }
       console.log(`Tunnel started: ${result.url}`);
       console.log(`Tunnel ID: ${result.tunnelId}`);
       console.log(`Expires: ${new Date(result.expiresAt).toISOString()}`);
@@ -425,6 +438,23 @@ async function resolveActiveTunnel() {
   console.error(`Multiple active tunnels: ${active.join(", ")}. Specify one.`);
   process.exit(1);
 }
+function waitForDaemonReady(infoPath, child, timeoutMs) {
+  return new Promise((resolve3) => {
+    let settled = false;
+    const done = (value) => {
+      if (settled) return;
+      settled = true;
+      clearInterval(poll);
+      clearTimeout(timeout);
+      resolve3(value);
+    };
+    child.on("exit", () => done(false));
+    const poll = setInterval(() => {
+      if (fs2.existsSync(infoPath)) done(true);
+    }, 100);
+    const timeout = setTimeout(() => done(false), timeoutMs);
+  });
+}
 
 // src/lib/api.ts
 var PubApiClient = class {
@@ -549,7 +579,7 @@ function readFile(filePath) {
     basename: path3.basename(resolved)
   };
 }
-program.name("pubblue").description("Publish static content and get shareable URLs").version("0.4.0");
+program.name("pubblue").description("Publish static content and get shareable URLs").version("0.4.2");
 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-K7Z7FUFN.js

@@ -0,0 +1,9 @@
+import {
+  getTunnelWriteReadinessError,
+  startDaemon
+} from "./chunk-3RFMAQOM.js";
+import "./chunk-56IKFMJ2.js";
+export {
+  getTunnelWriteReadinessError,
+  startDaemon
+};

package/dist/tunnel-daemon-entry.js

@@ -3,7 +3,7 @@ import {
 } from "./chunk-BV423NLA.js";
 import {
   startDaemon
-} from "./chunk-OLY5PC4A.js";
+} from "./chunk-3RFMAQOM.js";
 import "./chunk-56IKFMJ2.js";
 
 // src/tunnel-daemon-entry.ts

package/package.json

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

package/dist/tunnel-daemon-CHNV373I.js

@@ -1,7 +0,0 @@
-import {
-  startDaemon
-} from "./chunk-OLY5PC4A.js";
-import "./chunk-56IKFMJ2.js";
-export {
-  startDaemon
-};