pubblue 0.4.3 → 0.4.4

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

@@ -2,21 +2,40 @@ import {
   CHANNELS,
   CONTROL_CHANNEL,
   decodeMessage,
-  encodeMessage
-} from "./chunk-56IKFMJ2.js";
+  encodeMessage,
+  makeAckMessage,
+  parseAckMessage,
+  shouldAcknowledgeMessage
+} from "./chunk-MW35LBNH.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
+function resolveAckChannel(input) {
+  if (input.messageChannelOpen) return input.messageChannel;
+  if (input.controlChannelOpen) return CONTROL_CHANNEL;
+  return null;
+}
+
+// src/lib/tunnel-daemon.ts
 var OFFER_TIMEOUT_MS = 1e4;
 var SIGNAL_POLL_WAITING_MS = 500;
 var SIGNAL_POLL_CONNECTED_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.";
 function getTunnelWriteReadinessError(isConnected) {
   return isConnected ? null : NOT_CONNECTED_WRITE_ERROR;
 }
+function shouldRecoverForBrowserAnswerChange(params) {
+  const { incomingBrowserAnswer, lastAppliedBrowserAnswer, remoteDescriptionApplied } = params;
+  if (!remoteDescriptionApplied) return false;
+  if (!incomingBrowserAnswer) return false;
+  return incomingBrowserAnswer !== lastAppliedBrowserAnswer;
+}
 async function startDaemon(config) {
   const { tunnelId, apiClient, socketPath, infoPath } = config;
   const ndc = await import("node-datachannel");
@@ -26,10 +45,14 @@ async function startDaemon(config) {
   let connected = false;
   let recovering = false;
   let remoteDescriptionApplied = false;
+  let lastAppliedBrowserAnswer = null;
   let lastBrowserCandidateCount = 0;
   let lastSentCandidateCount = 0;
   const pendingRemoteCandidates = [];
   const localCandidates = [];
+  const stickyOutboundByChannel = /* @__PURE__ */ new Map();
+  const pendingOutboundAcks = /* @__PURE__ */ new Map();
+  const pendingDeliveryAcks = /* @__PURE__ */ new Map();
   let peer = null;
   let channels = /* @__PURE__ */ new Map();
   let pendingInboundBinaryMeta = /* @__PURE__ */ new Map();
@@ -37,6 +60,18 @@ async function startDaemon(config) {
   let localCandidateInterval = null;
   let localCandidateStopTimer = null;
   let recoveryTimer = null;
+  let lastError = null;
+  const debugEnabled = process.env.PUBBLUE_TUNNEL_DEBUG === "1";
+  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}`);
+  }
+  function markError(message, error) {
+    const detail = error === void 0 ? message : `${message}: ${error instanceof Error ? error.message : typeof error === "string" ? error : JSON.stringify(error)}`;
+    lastError = detail;
+    debugLog(message, error);
+  }
   function clearPollingTimer() {
     if (pollingTimer) {
       clearTimeout(pollingTimer);
@@ -61,14 +96,25 @@ async function startDaemon(config) {
   }
   function setupChannel(name, dc) {
     channels.set(name, dc);
+    dc.onOpen(() => {
+      if (name === CONTROL_CHANNEL) flushQueuedAcks();
+    });
     dc.onMessage((data) => {
       if (typeof data === "string") {
         const msg = decodeMessage(data);
         if (!msg) return;
+        const ack = parseAckMessage(msg);
+        if (ack) {
+          settlePendingAck(ack.messageId, true);
+          return;
+        }
         if (msg.type === "binary" && !msg.data) {
           pendingInboundBinaryMeta.set(name, msg);
           return;
         }
+        if (shouldAcknowledgeMessage(name, msg)) {
+          queueAck(msg.id, name);
+        }
         buffer.messages.push({ channel: name, msg, timestamp: Date.now() });
         return;
       }
@@ -85,9 +131,75 @@ async function startDaemon(config) {
         data: data.toString("base64"),
         meta: { size: data.length }
       };
+      if (shouldAcknowledgeMessage(name, binMsg)) {
+        queueAck(binMsg.id, name);
+      }
       buffer.messages.push({ channel: name, msg: binMsg, timestamp: Date.now() });
     });
   }
+  function getAckKey(messageId, channel) {
+    return `${channel}:${messageId}`;
+  }
+  function queueAck(messageId, channel) {
+    pendingOutboundAcks.set(getAckKey(messageId, channel), { messageId, channel });
+    flushQueuedAcks();
+  }
+  function flushQueuedAcks() {
+    const controlDc = channels.get(CONTROL_CHANNEL);
+    for (const [ackKey, ack] of pendingOutboundAcks) {
+      const messageDc = channels.get(ack.channel);
+      const targetChannel = resolveAckChannel({
+        controlChannelOpen: Boolean(controlDc?.isOpen()),
+        messageChannelOpen: Boolean(messageDc?.isOpen()),
+        messageChannel: ack.channel
+      });
+      if (!targetChannel) continue;
+      const encodedAck = encodeMessage(makeAckMessage(ack.messageId, ack.channel));
+      const primaryDc = targetChannel === CONTROL_CHANNEL ? controlDc : messageDc;
+      try {
+        if (primaryDc?.isOpen()) {
+          primaryDc.sendMessage(encodedAck);
+          pendingOutboundAcks.delete(ackKey);
+          continue;
+        }
+      } catch (error) {
+        markError("failed to flush queued ack on primary channel", error);
+      }
+      const fallbackChannel = targetChannel === ack.channel ? CONTROL_CHANNEL : ack.channel;
+      const fallbackDc = fallbackChannel === CONTROL_CHANNEL ? controlDc : messageDc;
+      try {
+        if (fallbackDc?.isOpen()) {
+          fallbackDc.sendMessage(encodedAck);
+          pendingOutboundAcks.delete(ackKey);
+        }
+      } catch (error) {
+        markError("failed to flush queued ack on fallback channel", error);
+      }
+    }
+  }
+  function waitForDeliveryAck(messageId, timeoutMs) {
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        pendingDeliveryAcks.delete(messageId);
+        resolve(false);
+      }, timeoutMs);
+      pendingDeliveryAcks.set(messageId, { resolve, timeout });
+    });
+  }
+  function settlePendingAck(messageId, received) {
+    const pending = pendingDeliveryAcks.get(messageId);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    pendingDeliveryAcks.delete(messageId);
+    pending.resolve(received);
+  }
+  function failPendingAcks() {
+    for (const [messageId, pending] of pendingDeliveryAcks) {
+      clearTimeout(pending.timeout);
+      pending.resolve(false);
+      pendingDeliveryAcks.delete(messageId);
+    }
+  }
   function openDataChannel(name) {
     if (!peer) throw new Error("PeerConnection not initialized");
     const existing = channels.get(name);
@@ -113,9 +225,52 @@ async function startDaemon(config) {
       });
     });
   }
+  function maybePersistStickyOutbound(channel, msg, binaryPayload) {
+    if (channel !== CHANNELS.CANVAS) return;
+    if (msg.type === "event" && msg.data === "hide") {
+      stickyOutboundByChannel.delete(channel);
+      return;
+    }
+    if (msg.type !== "html") return;
+    stickyOutboundByChannel.set(channel, {
+      msg: {
+        ...msg,
+        meta: msg.meta ? { ...msg.meta } : void 0
+      },
+      binaryPayload
+    });
+  }
+  async function replayStickyOutboundMessages() {
+    if (!connected || recovering || stopped) return;
+    for (const [channel, sticky] of stickyOutboundByChannel) {
+      try {
+        let targetDc = channels.get(channel);
+        if (!targetDc) targetDc = openDataChannel(channel);
+        await waitForChannelOpen(targetDc, 3e3);
+        if (sticky.msg.type === "binary" && sticky.binaryPayload) {
+          targetDc.sendMessage(
+            encodeMessage({
+              ...sticky.msg,
+              meta: {
+                ...sticky.msg.meta || {},
+                size: sticky.binaryPayload.length
+              }
+            })
+          );
+          targetDc.sendMessageBinary(sticky.binaryPayload);
+        } else {
+          targetDc.sendMessage(encodeMessage(sticky.msg));
+        }
+      } catch (error) {
+        debugLog(`sticky outbound replay failed for channel ${channel}`, error);
+      }
+    }
+  }
   function resetNegotiationState() {
     connected = false;
+    failPendingAcks();
     remoteDescriptionApplied = false;
+    lastAppliedBrowserAnswer = null;
     lastBrowserCandidateCount = 0;
     lastSentCandidateCount = 0;
     pendingRemoteCandidates.length = 0;
@@ -128,7 +283,8 @@ async function startDaemon(config) {
       if (localCandidates.length <= lastSentCandidateCount) return;
       const newOnes = localCandidates.slice(lastSentCandidateCount);
       lastSentCandidateCount = localCandidates.length;
-      await apiClient.signal(tunnelId, { candidates: newOnes }).catch(() => {
+      await apiClient.signal(tunnelId, { candidates: newOnes }).catch((error) => {
+        debugLog("failed to publish local ICE candidates", error);
       });
     }, 500);
     localCandidateStopTimer = setTimeout(() => {
@@ -144,9 +300,11 @@ async function startDaemon(config) {
       if (stopped || currentPeer !== peer) return;
       if (state === "connected") {
         connected = true;
+        flushQueuedAcks();
+        void replayStickyOutboundMessages();
         return;
       }
-      if (state === "disconnected" || state === "failed") {
+      if (state === "disconnected" || state === "failed" || state === "closed") {
         connected = false;
         scheduleRecovery();
       }
@@ -169,10 +327,12 @@ async function startDaemon(config) {
     openDataChannel(CHANNELS.CANVAS);
   }
   function closeCurrentPeer() {
+    failPendingAcks();
     for (const dc of channels.values()) {
       try {
         dc.close();
-      } catch {
+      } catch (error) {
+        debugLog("failed to close data channel cleanly", error);
       }
     }
     channels.clear();
@@ -180,7 +340,8 @@ async function startDaemon(config) {
     if (peer) {
       try {
         peer.close();
-      } catch {
+      } catch (error) {
+        debugLog("failed to close peer connection cleanly", error);
       }
       peer = null;
     }
@@ -194,21 +355,33 @@ async function startDaemon(config) {
   }
   async function pollSignalingOnce() {
     const tunnel = await apiClient.get(tunnelId);
+    if (shouldRecoverForBrowserAnswerChange({
+      incomingBrowserAnswer: tunnel.browserAnswer,
+      lastAppliedBrowserAnswer,
+      remoteDescriptionApplied
+    })) {
+      connected = false;
+      scheduleRecovery(0, true);
+      return;
+    }
     if (tunnel.browserAnswer && !remoteDescriptionApplied) {
       if (!peer) return;
       try {
         const answer = JSON.parse(tunnel.browserAnswer);
         peer.setRemoteDescription(answer.sdp, answer.type);
         remoteDescriptionApplied = true;
+        lastAppliedBrowserAnswer = tunnel.browserAnswer;
         while (pendingRemoteCandidates.length > 0) {
           const next = pendingRemoteCandidates.shift();
           if (!next) break;
           try {
             peer.addRemoteCandidate(next.candidate, next.sdpMid);
-          } catch {
+          } catch (error) {
+            debugLog("failed to apply queued remote ICE candidate", error);
           }
         }
-      } catch {
+      } catch (error) {
+        markError("failed to apply browser answer", error);
       }
     }
     if (tunnel.browserCandidates.length > lastBrowserCandidateCount) {
@@ -225,7 +398,8 @@ async function startDaemon(config) {
           }
           if (!peer) continue;
           peer.addRemoteCandidate(parsed.candidate, sdpMid);
-        } catch {
+        } catch (error) {
+          debugLog("failed to parse/apply browser ICE candidate", error);
         }
       }
     }
@@ -234,7 +408,8 @@ async function startDaemon(config) {
     if (stopped) return;
     try {
       await pollSignalingOnce();
-    } catch {
+    } catch (error) {
+      markError("signaling poll failed", error);
     }
     scheduleNextPoll(remoteDescriptionApplied ? SIGNAL_POLL_CONNECTED_MS : SIGNAL_POLL_WAITING_MS);
   }
@@ -256,13 +431,14 @@ async function startDaemon(config) {
       recovering = false;
     }
   }
-  function scheduleRecovery(delayMs = RECOVERY_DELAY_MS) {
+  function scheduleRecovery(delayMs = RECOVERY_DELAY_MS, force = false) {
     if (stopped || recovering || recoveryTimer) return;
     recoveryTimer = setTimeout(() => {
       recoveryTimer = null;
-      if (stopped || connected) return;
-      void recoverPeer().catch(() => {
-        if (!stopped) scheduleRecovery(delayMs);
+      if (stopped || !force && connected) return;
+      void recoverPeer().catch((error) => {
+        markError("peer recovery failed", error);
+        if (!stopped) scheduleRecovery(delayMs, force);
       });
     }, delayMs);
   }
@@ -279,7 +455,8 @@ async function startDaemon(config) {
     if (stale) {
       try {
         fs.unlinkSync(socketPath);
-      } catch {
+      } catch (error) {
+        debugLog("failed to remove stale daemon socket", error);
       }
     } else {
       throw new Error(`Daemon already running (socket: ${socketPath})`);
@@ -319,6 +496,7 @@ async function startDaemon(config) {
     await runNegotiationCycle();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
+    markError("initial negotiation failed", error);
     await cleanup();
     throw new Error(`Failed to generate WebRTC offer: ${message}`);
   }
@@ -332,13 +510,16 @@ async function startDaemon(config) {
     ipcServer.close();
     try {
       fs.unlinkSync(socketPath);
-    } catch {
+    } catch (error) {
+      debugLog("failed to remove daemon socket during cleanup", error);
     }
     try {
       fs.unlinkSync(infoPath);
-    } catch {
+    } catch (error) {
+      debugLog("failed to remove daemon info file during cleanup", error);
     }
-    await apiClient.close(tunnelId).catch(() => {
+    await apiClient.close(tunnelId).catch((error) => {
+      markError("failed to close tunnel on API during cleanup", error);
     });
   }
   async function shutdown() {
@@ -359,30 +540,50 @@ async function startDaemon(config) {
         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 binaryPayload = msg.type === "binary" && binaryBase64 ? Buffer.from(binaryBase64, "base64") : void 0;
         let targetDc = channels.get(channel);
         if (!targetDc) targetDc = openDataChannel(channel);
         try {
           await waitForChannelOpen(targetDc);
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error);
+          markError(`channel "${channel}" failed to open`, error);
           return { ok: false, error: `Channel "${channel}" not open: ${message}` };
         }
-        if (msg.type === "binary" && binaryBase64) {
-          const payload = Buffer.from(binaryBase64, "base64");
-          targetDc.sendMessage(
-            encodeMessage({
-              ...msg,
-              meta: {
-                ...msg.meta || {},
-                size: payload.length
-              }
-            })
-          );
-          targetDc.sendMessageBinary(payload);
-        } else {
-          targetDc.sendMessage(encodeMessage(msg));
+        const waitForAck = shouldAcknowledgeMessage(channel, msg) ? waitForDeliveryAck(msg.id, WRITE_ACK_TIMEOUT_MS) : null;
+        try {
+          if (msg.type === "binary" && binaryPayload) {
+            targetDc.sendMessage(
+              encodeMessage({
+                ...msg,
+                meta: {
+                  ...msg.meta || {},
+                  size: binaryPayload.length
+                }
+              })
+            );
+            targetDc.sendMessageBinary(binaryPayload);
+          } else {
+            targetDc.sendMessage(encodeMessage(msg));
+          }
+        } catch (error) {
+          if (waitForAck) settlePendingAck(msg.id, false);
+          const message = error instanceof Error ? error.message : String(error);
+          markError(`failed to send message on channel "${channel}"`, error);
+          return { ok: false, error: `Failed to send on channel "${channel}": ${message}` };
         }
-        return { ok: true };
+        if (waitForAck) {
+          const acked = await waitForAck;
+          if (!acked) {
+            markError(`delivery ack timeout for message ${msg.id}`);
+            return {
+              ok: false,
+              error: `Delivery not confirmed for message ${msg.id} within ${WRITE_ACK_TIMEOUT_MS}ms.`
+            };
+          }
+        }
+        maybePersistStickyOutbound(channel, msg, binaryPayload);
+        return { ok: true, delivered: true };
       }
       case "read": {
         const channel = req.params.channel;
@@ -406,7 +607,8 @@ async function startDaemon(config) {
           connected,
           uptime: Math.floor((Date.now() - startTime) / 1e3),
           channels: [...channels.keys()],
-          bufferedMessages: buffer.messages.length
+          bufferedMessages: buffer.messages.length,
+          lastError
         };
       }
       case "close": {
@@ -452,5 +654,6 @@ function generateOffer(peer, timeoutMs) {
 
 export {
   getTunnelWriteReadinessError,
+  shouldRecoverForBrowserAnswerChange,
   startDaemon
 };

package/dist/chunk-MW35LBNH.js

@@ -0,0 +1,60 @@
+// src/lib/bridge-protocol.ts
+var CONTROL_CHANNEL = "_control";
+var CHANNELS = {
+  CHAT: "chat",
+  CANVAS: "canvas",
+  AUDIO: "audio",
+  MEDIA: "media",
+  FILE: "file"
+};
+var idCounter = 0;
+function generateMessageId() {
+  const ts = Date.now().toString(36);
+  const seq = (idCounter++).toString(36);
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `${ts}-${seq}-${rand}`;
+}
+function encodeMessage(msg) {
+  return JSON.stringify(msg);
+}
+function decodeMessage(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.id === "string" && typeof parsed.type === "string") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function makeEventMessage(event, meta) {
+  return { id: generateMessageId(), type: "event", data: event, meta };
+}
+function makeAckMessage(messageId, channel) {
+  return makeEventMessage("ack", { messageId, channel, receivedAt: Date.now() });
+}
+function parseAckMessage(msg) {
+  if (msg.type !== "event" || msg.data !== "ack" || !msg.meta) return null;
+  const messageId = typeof msg.meta.messageId === "string" ? msg.meta.messageId : null;
+  const channel = typeof msg.meta.channel === "string" ? msg.meta.channel : null;
+  if (!messageId || !channel) return null;
+  const receivedAt = typeof msg.meta.receivedAt === "number" ? msg.meta.receivedAt : void 0;
+  return { messageId, channel, receivedAt };
+}
+function shouldAcknowledgeMessage(channel, msg) {
+  return channel !== CONTROL_CHANNEL && parseAckMessage(msg) === null;
+}
+var MAX_TUNNEL_EXPIRY_MS = 7 * 24 * 60 * 60 * 1e3;
+var DEFAULT_TUNNEL_EXPIRY_MS = 24 * 60 * 60 * 1e3;
+
+export {
+  CONTROL_CHANNEL,
+  CHANNELS,
+  generateMessageId,
+  encodeMessage,
+  decodeMessage,
+  makeAckMessage,
+  parseAckMessage,
+  shouldAcknowledgeMessage
+};

package/dist/index.js

@@ -3,8 +3,9 @@ import {
   TunnelApiClient
 } from "./chunk-BV423NLA.js";
 import {
+  CHANNELS,
   generateMessageId
-} from "./chunk-56IKFMJ2.js";
+} from "./chunk-MW35LBNH.js";
 
 // src/index.ts
 import * as fs3 from "fs";
@@ -185,6 +186,9 @@ function tunnelInfoDir() {
 function tunnelInfoPath(tunnelId) {
   return path2.join(tunnelInfoDir(), `${tunnelId}.json`);
 }
+function tunnelLogPath(tunnelId) {
+  return path2.join(tunnelInfoDir(), `${tunnelId}.log`);
+}
 function createApiClient() {
   const config = getConfig();
   return new TunnelApiClient(config.baseUrl, config.apiKey);
@@ -219,6 +223,9 @@ function getFollowReadDelayMs(disconnected, consecutiveFailures) {
   if (!disconnected) return 1e3;
   return Math.min(5e3, 1e3 * 2 ** Math.min(consecutiveFailures, 3));
 }
+function resolveTunnelIdSelection(tunnelIdArg, tunnelOpt) {
+  return tunnelOpt || tunnelIdArg;
+}
 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) => {
@@ -230,7 +237,7 @@ function registerTunnelCommands(program2) {
     const socketPath = getSocketPath(result.tunnelId);
     const infoPath = tunnelInfoPath(result.tunnelId);
     if (opts.foreground) {
-      const { startDaemon } = await import("./tunnel-daemon-QPXIGRW7.js");
+      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()}`);
@@ -250,9 +257,11 @@ function registerTunnelCommands(program2) {
     } else {
       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: "ignore",
+        stdio: ["ignore", daemonLogFd, daemonLogFd],
         env: {
           ...process.env,
           PUBBLUE_DAEMON_TUNNEL_ID: result.tunnelId,
@@ -262,10 +271,12 @@ function registerTunnelCommands(program2) {
           PUBBLUE_DAEMON_INFO: infoPath
         }
       });
+      fs2.closeSync(daemonLogFd);
       child.unref();
       const ready = await waitForDaemonReady(infoPath, child, 5e3);
       if (!ready) {
         console.error("Daemon failed to start. Cleaning up tunnel...");
+        console.error(`Daemon log: ${logPath}`);
         await apiClient.close(result.tunnelId).catch(() => {
         });
         process.exit(1);
@@ -273,6 +284,7 @@ function registerTunnelCommands(program2) {
       console.log(`Tunnel started: ${result.url}`);
       console.log(`Tunnel ID: ${result.tunnelId}`);
       console.log(`Expires: ${new Date(result.expiresAt).toISOString()}`);
+      console.log(`Daemon log: ${logPath}`);
     }
   });
   tunnel.command("write").description("Write data to a channel").argument("[message]", "Text message (or use --file)").option("-t, --tunnel <tunnelId>", "Tunnel ID (auto-detected if one active)").option("-c, --channel <channel>", "Channel name", "chat").option("-f, --file <file>", "Read content from file").action(
@@ -333,18 +345,24 @@ function registerTunnelCommands(program2) {
       }
     }
   );
-  tunnel.command("read").description("Read buffered messages from channels").argument("[tunnelId]", "Tunnel ID (auto-detected if one active)").option("-c, --channel <channel>", "Filter by channel").option("--follow", "Stream messages continuously").action(
+  tunnel.command("read").description("Read buffered messages from channels").argument("[tunnelId]", "Tunnel ID (auto-detected if one active)").option("-t, --tunnel <tunnelId>", "Tunnel ID (alternative to positional arg)").option("-c, --channel <channel>", "Filter by channel").option("--follow", "Stream messages continuously").option("--all", "With --follow, include all channels instead of chat-only default").action(
     async (tunnelIdArg, opts) => {
-      const tunnelId = tunnelIdArg || await resolveActiveTunnel();
+      const tunnelId = resolveTunnelIdSelection(tunnelIdArg, opts.tunnel) || await resolveActiveTunnel();
       const socketPath = getSocketPath(tunnelId);
+      const readChannel = opts.channel || (opts.follow && !opts.all ? CHANNELS.CHAT : void 0);
       if (opts.follow) {
+        if (!opts.channel && !opts.all) {
+          console.error(
+            "Following chat channel by default. Use `--all` to include binary/file channels."
+          );
+        }
         let consecutiveFailures = 0;
         let warnedDisconnected = false;
         while (true) {
           try {
             const response = await ipcCall(socketPath, {
               method: "read",
-              params: { channel: opts.channel }
+              params: { channel: readChannel }
             });
             if (warnedDisconnected) {
               console.error("Daemon reconnected.");
@@ -356,10 +374,11 @@ function registerTunnelCommands(program2) {
                 console.log(JSON.stringify(m));
               }
             }
-          } catch {
+          } catch (error) {
             consecutiveFailures += 1;
             if (!warnedDisconnected) {
-              console.error("Daemon disconnected. Waiting for recovery...");
+              const detail = error instanceof Error ? ` ${error.message}` : "";
+              console.error(`Daemon disconnected. Waiting for recovery...${detail}`);
               warnedDisconnected = true;
             }
           }
@@ -369,7 +388,7 @@ function registerTunnelCommands(program2) {
       } else {
         const response = await ipcCall(socketPath, {
           method: "read",
-          params: { channel: opts.channel }
+          params: { channel: readChannel }
         });
         if (!response.ok) {
           console.error(`Failed: ${response.error}`);
@@ -379,8 +398,8 @@ function registerTunnelCommands(program2) {
       }
     }
   );
-  tunnel.command("channels").description("List active channels").argument("[tunnelId]", "Tunnel ID").action(async (tunnelIdArg) => {
-    const tunnelId = tunnelIdArg || await resolveActiveTunnel();
+  tunnel.command("channels").description("List active channels").argument("[tunnelId]", "Tunnel ID").option("-t, --tunnel <tunnelId>", "Tunnel ID (alternative to positional arg)").action(async (tunnelIdArg, opts) => {
+    const tunnelId = resolveTunnelIdSelection(tunnelIdArg, opts.tunnel) || await resolveActiveTunnel();
     const socketPath = getSocketPath(tunnelId);
     const response = await ipcCall(socketPath, { method: "channels", params: {} });
     if (response.channels) {
@@ -389,8 +408,8 @@ function registerTunnelCommands(program2) {
       }
     }
   });
-  tunnel.command("status").description("Check tunnel connection status").argument("[tunnelId]", "Tunnel ID").action(async (tunnelIdArg) => {
-    const tunnelId = tunnelIdArg || await resolveActiveTunnel();
+  tunnel.command("status").description("Check tunnel connection status").argument("[tunnelId]", "Tunnel ID").option("-t, --tunnel <tunnelId>", "Tunnel ID (alternative to positional arg)").action(async (tunnelIdArg, opts) => {
+    const tunnelId = resolveTunnelIdSelection(tunnelIdArg, opts.tunnel) || await resolveActiveTunnel();
     const socketPath = getSocketPath(tunnelId);
     const response = await ipcCall(socketPath, { method: "status", params: {} });
     console.log(`  Status: ${response.connected ? "connected" : "waiting"}`);
@@ -398,6 +417,13 @@ function registerTunnelCommands(program2) {
     const chNames = Array.isArray(response.channels) ? response.channels.map((c) => typeof c === "string" ? c : String(c)) : [];
     console.log(`  Channels: ${chNames.join(", ")}`);
     console.log(`  Buffered: ${response.bufferedMessages ?? 0} messages`);
+    if (typeof response.lastError === "string" && response.lastError.length > 0) {
+      console.log(`  Last error: ${response.lastError}`);
+    }
+    const logPath = tunnelLogPath(tunnelId);
+    if (fs2.existsSync(logPath)) {
+      console.log(`  Log: ${logPath}`);
+    }
   });
   tunnel.command("list").description("List active tunnels").action(async () => {
     const apiClient = createApiClient();
@@ -600,7 +626,7 @@ function readFile(filePath) {
     basename: path3.basename(resolved)
   };
 }
-program.name("pubblue").description("Publish static content and get shareable URLs").version("0.4.3");
+program.name("pubblue").description("Publish static content and get shareable URLs").version("0.4.4");
 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

@@ -0,0 +1,11 @@
+import {
+  getTunnelWriteReadinessError,
+  shouldRecoverForBrowserAnswerChange,
+  startDaemon
+} from "./chunk-AIEPM67G.js";
+import "./chunk-MW35LBNH.js";
+export {
+  getTunnelWriteReadinessError,
+  shouldRecoverForBrowserAnswerChange,
+  startDaemon
+};

package/dist/tunnel-daemon-entry.js

@@ -3,8 +3,8 @@ import {
 } from "./chunk-BV423NLA.js";
 import {
   startDaemon
-} from "./chunk-YHFY3TW5.js";
-import "./chunk-56IKFMJ2.js";
+} from "./chunk-AIEPM67G.js";
+import "./chunk-MW35LBNH.js";
 
 // src/tunnel-daemon-entry.ts
 var tunnelId = process.env.PUBBLUE_DAEMON_TUNNEL_ID;

package/package.json

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

package/dist/chunk-56IKFMJ2.js

@@ -1,40 +0,0 @@
-// src/lib/bridge-protocol.ts
-var CONTROL_CHANNEL = "_control";
-var CHANNELS = {
-  CHAT: "chat",
-  CANVAS: "canvas",
-  AUDIO: "audio",
-  MEDIA: "media",
-  FILE: "file"
-};
-var idCounter = 0;
-function generateMessageId() {
-  const ts = Date.now().toString(36);
-  const seq = (idCounter++).toString(36);
-  const rand = Math.random().toString(36).slice(2, 6);
-  return `${ts}-${seq}-${rand}`;
-}
-function encodeMessage(msg) {
-  return JSON.stringify(msg);
-}
-function decodeMessage(raw) {
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed.id === "string" && typeof parsed.type === "string") {
-      return parsed;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-var MAX_TUNNEL_EXPIRY_MS = 7 * 24 * 60 * 60 * 1e3;
-var DEFAULT_TUNNEL_EXPIRY_MS = 24 * 60 * 60 * 1e3;
-
-export {
-  CONTROL_CHANNEL,
-  CHANNELS,
-  generateMessageId,
-  encodeMessage,
-  decodeMessage
-};

package/dist/tunnel-daemon-QPXIGRW7.js

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