pubblue 0.4.2 → 0.4.4

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);
@@ -215,19 +219,25 @@ function isDaemonRunning(tunnelId) {
     return false;
   }
 }
+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("--title <title>", "Tunnel title").option("--expires <duration>", "Auto-close after duration (e.g. 4h, 1d)", "24h").option("--foreground", "Run in foreground (don't fork)").action(async (opts) => {
+  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) => {
     await ensureNodeDatachannelAvailable();
     const apiClient = createApiClient();
     const result = await apiClient.create({
-      title: opts.title,
       expiresIn: opts.expires
     });
     const socketPath = getSocketPath(result.tunnelId);
     const infoPath = tunnelInfoPath(result.tunnelId);
     if (opts.foreground) {
-      const { startDaemon } = await import("./tunnel-daemon-K7Z7FUFN.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()}`);
@@ -247,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,
@@ -259,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);
@@ -270,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(
@@ -330,31 +345,50 @@ 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) {
-          const response = await ipcCall(socketPath, {
-            method: "read",
-            params: { channel: opts.channel }
-          }).catch(() => null);
-          if (!response) {
-            console.error("Daemon disconnected.");
-            process.exit(1);
-          }
-          if (response.messages && response.messages.length > 0) {
-            for (const m of response.messages) {
-              console.log(JSON.stringify(m));
+          try {
+            const response = await ipcCall(socketPath, {
+              method: "read",
+              params: { channel: readChannel }
+            });
+            if (warnedDisconnected) {
+              console.error("Daemon reconnected.");
+              warnedDisconnected = false;
+            }
+            consecutiveFailures = 0;
+            if (response.messages && response.messages.length > 0) {
+              for (const m of response.messages) {
+                console.log(JSON.stringify(m));
+              }
+            }
+          } catch (error) {
+            consecutiveFailures += 1;
+            if (!warnedDisconnected) {
+              const detail = error instanceof Error ? ` ${error.message}` : "";
+              console.error(`Daemon disconnected. Waiting for recovery...${detail}`);
+              warnedDisconnected = true;
             }
           }
-          await new Promise((r) => setTimeout(r, 1e3));
+          const delayMs = getFollowReadDelayMs(warnedDisconnected, consecutiveFailures);
+          await new Promise((r) => setTimeout(r, delayMs));
         }
       } else {
         const response = await ipcCall(socketPath, {
           method: "read",
-          params: { channel: opts.channel }
+          params: { channel: readChannel }
         });
         if (!response.ok) {
           console.error(`Failed: ${response.error}`);
@@ -364,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) {
@@ -374,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"}`);
@@ -383,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();
@@ -395,9 +436,7 @@ function registerTunnelCommands(program2) {
       const age = Math.floor((Date.now() - t.createdAt) / 6e4);
       const running = isDaemonRunning(t.tunnelId) ? "running" : "no daemon";
       const conn = t.hasConnection ? "connected" : "waiting";
-      console.log(
-        `  ${t.tunnelId}  ${t.title || "(untitled)"}  ${conn}  ${running}  ${age}m ago`
-      );
+      console.log(`  ${t.tunnelId}  ${conn}  ${running}  ${age}m ago`);
     }
   });
   tunnel.command("close").description("Close a tunnel and stop its daemon").argument("<tunnelId>", "Tunnel ID").action(async (tunnelId) => {
@@ -568,6 +607,14 @@ async function resolveConfigureApiKey(opts) {
   }
   return readApiKeyFromPrompt();
 }
+function resolveVisibilityFlags(opts) {
+  if (opts.public && opts.private) {
+    throw new Error(`Use only one of --public or --private for ${opts.commandName}.`);
+  }
+  if (opts.public) return true;
+  if (opts.private) return false;
+  return void 0;
+}
 function readFile(filePath) {
   const resolved = path3.resolve(filePath);
   if (!fs3.existsSync(resolved)) {
@@ -579,7 +626,7 @@ function readFile(filePath) {
     basename: path3.basename(resolved)
   };
 }
-program.name("pubblue").description("Publish static content and get shareable URLs").version("0.4.2");
+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);
@@ -591,7 +638,7 @@ program.command("configure").description("Configure the CLI with your API key").
     process.exit(1);
   }
 });
-program.command("create").description("Create a new publication").argument("[file]", "Path to the file (reads stdin if omitted)").option("--slug <slug>", "Custom slug for the URL").option("--title <title>", "Title for the publication").option("--private", "Make the publication private (default)").option("--expires <duration>", "Auto-delete after duration (e.g. 1h, 24h, 7d)").action(
+program.command("create").description("Create a new publication").argument("[file]", "Path to the file (reads stdin if omitted)").option("--slug <slug>", "Custom slug for the URL").option("--title <title>", "Title for the publication").option("--public", "Make the publication public").option("--private", "Make the publication private (default)").option("--expires <duration>", "Auto-delete after duration (e.g. 1h, 24h, 7d)").action(
   async (fileArg, opts) => {
     const client = createClient();
     let content;
@@ -603,12 +650,17 @@ program.command("create").description("Create a new publication").argument("[fil
     } else {
       content = await readFromStdin();
     }
+    const resolvedVisibility = resolveVisibilityFlags({
+      public: opts.public,
+      private: opts.private,
+      commandName: "create"
+    });
     const result = await client.create({
       content,
       filename,
       title: opts.title,
       slug: opts.slug,
-      isPublic: false,
+      isPublic: resolvedVisibility ?? false,
       expiresIn: opts.expires
     });
     console.log(`Created: ${result.url}`);
@@ -633,7 +685,7 @@ program.command("get").description("Get details of a publication").argument("<sl
   console.log(`  Updated: ${new Date(pub.updatedAt).toLocaleDateString()}`);
   console.log(`  Size:    ${pub.content.length} bytes`);
 });
-program.command("update").description("Update a publication's content and/or metadata").argument("<slug>", "Slug of the publication to update").option("--file <file>", "New content from file").option("--title <title>", "New title").option("--private", "Make the publication private").option("--slug <newSlug>", "Rename the slug").action(
+program.command("update").description("Update a publication's content and/or metadata").argument("<slug>", "Slug of the publication to update").option("--file <file>", "New content from file").option("--title <title>", "New title").option("--public", "Make the publication public").option("--private", "Make the publication private").option("--slug <newSlug>", "Rename the slug").action(
   async (slug, opts) => {
     const client = createClient();
     let content;
@@ -643,8 +695,11 @@ program.command("update").description("Update a publication's content and/or met
       content = file.content;
       filename = file.basename;
     }
-    let isPublic;
-    if (opts.private) isPublic = false;
+    const isPublic = resolveVisibilityFlags({
+      public: opts.public,
+      private: opts.private,
+      commandName: "update"
+    });
     const result = await client.update({
       slug,
       content,

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-3RFMAQOM.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.2",
+  "version": "0.4.4",
   "description": "CLI tool for publishing static content via pub.blue",
   "type": "module",
   "bin": {