pubblue 0.4.2 → 0.4.3

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

@@ -10,6 +10,9 @@ import * as fs from "fs";
 import * as net from "net";
 import * as path from "path";
 var OFFER_TIMEOUT_MS = 1e4;
+var SIGNAL_POLL_WAITING_MS = 500;
+var SIGNAL_POLL_CONNECTED_MS = 2e3;
+var RECOVERY_DELAY_MS = 1e3;
 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;
@@ -19,17 +22,74 @@ async function startDaemon(config) {
   const ndc = await import("node-datachannel");
   const buffer = { messages: [] };
   const startTime = Date.now();
+  let stopped = false;
   let connected = false;
-  let pollingInterval = null;
-  let lastBrowserCandidateCount = 0;
+  let recovering = false;
   let remoteDescriptionApplied = false;
+  let lastBrowserCandidateCount = 0;
+  let lastSentCandidateCount = 0;
   const pendingRemoteCandidates = [];
-  const peer = new ndc.PeerConnection("agent", {
-    iceServers: ["stun:stun.l.google.com:19302", "stun:stun1.l.google.com:19302"]
-  });
-  const channels = /* @__PURE__ */ new Map();
-  const pendingInboundBinaryMeta = /* @__PURE__ */ new Map();
+  const localCandidates = [];
+  let peer = null;
+  let channels = /* @__PURE__ */ new Map();
+  let pendingInboundBinaryMeta = /* @__PURE__ */ new Map();
+  let pollingTimer = null;
+  let localCandidateInterval = null;
+  let localCandidateStopTimer = null;
+  let recoveryTimer = null;
+  function clearPollingTimer() {
+    if (pollingTimer) {
+      clearTimeout(pollingTimer);
+      pollingTimer = null;
+    }
+  }
+  function clearLocalCandidateTimers() {
+    if (localCandidateInterval) {
+      clearInterval(localCandidateInterval);
+      localCandidateInterval = null;
+    }
+    if (localCandidateStopTimer) {
+      clearTimeout(localCandidateStopTimer);
+      localCandidateStopTimer = null;
+    }
+  }
+  function clearRecoveryTimer() {
+    if (recoveryTimer) {
+      clearTimeout(recoveryTimer);
+      recoveryTimer = null;
+    }
+  }
+  function setupChannel(name, dc) {
+    channels.set(name, dc);
+    dc.onMessage((data) => {
+      if (typeof data === "string") {
+        const msg = decodeMessage(data);
+        if (!msg) return;
+        if (msg.type === "binary" && !msg.data) {
+          pendingInboundBinaryMeta.set(name, msg);
+          return;
+        }
+        buffer.messages.push({ channel: name, msg, timestamp: Date.now() });
+        return;
+      }
+      const pendingMeta = pendingInboundBinaryMeta.get(name);
+      if (pendingMeta) pendingInboundBinaryMeta.delete(name);
+      const binMsg = pendingMeta ? {
+        id: pendingMeta.id,
+        type: "binary",
+        data: data.toString("base64"),
+        meta: { ...pendingMeta.meta, size: data.length }
+      } : {
+        id: `bin-${Date.now()}`,
+        type: "binary",
+        data: data.toString("base64"),
+        meta: { size: data.length }
+      };
+      buffer.messages.push({ channel: name, msg: binMsg, timestamp: Date.now() });
+    });
+  }
   function openDataChannel(name) {
+    if (!peer) throw new Error("PeerConnection not initialized");
     const existing = channels.get(name);
     if (existing) return existing;
     const dc = peer.createDataChannel(name, { ordered: true });
@@ -53,57 +113,159 @@ async function startDaemon(config) {
       });
     });
   }
-  function setupChannel(name, dc) {
-    channels.set(name, dc);
-    dc.onMessage((data) => {
-      if (typeof data === "string") {
-        const msg = decodeMessage(data);
-        if (msg) {
-          if (msg.type === "binary" && !msg.data) {
-            pendingInboundBinaryMeta.set(name, msg);
-            return;
-          }
-          buffer.messages.push({ channel: name, msg, timestamp: Date.now() });
-        }
-      } else {
-        const pendingMeta = pendingInboundBinaryMeta.get(name);
-        if (pendingMeta) pendingInboundBinaryMeta.delete(name);
-        const binMsg = pendingMeta ? {
-          id: pendingMeta.id,
-          type: "binary",
-          data: data.toString("base64"),
-          meta: { ...pendingMeta.meta, size: data.length }
-        } : {
-          id: `bin-${Date.now()}`,
-          type: "binary",
-          data: data.toString("base64"),
-          meta: { size: data.length }
-        };
-        buffer.messages.push({ channel: name, msg: binMsg, timestamp: Date.now() });
+  function resetNegotiationState() {
+    connected = false;
+    remoteDescriptionApplied = false;
+    lastBrowserCandidateCount = 0;
+    lastSentCandidateCount = 0;
+    pendingRemoteCandidates.length = 0;
+    localCandidates.length = 0;
+    clearLocalCandidateTimers();
+  }
+  function startLocalCandidateFlush() {
+    clearLocalCandidateTimers();
+    localCandidateInterval = setInterval(async () => {
+      if (localCandidates.length <= lastSentCandidateCount) return;
+      const newOnes = localCandidates.slice(lastSentCandidateCount);
+      lastSentCandidateCount = localCandidates.length;
+      await apiClient.signal(tunnelId, { candidates: newOnes }).catch(() => {
+      });
+    }, 500);
+    localCandidateStopTimer = setTimeout(() => {
+      clearLocalCandidateTimers();
+    }, 3e4);
+  }
+  function attachPeerHandlers(currentPeer) {
+    currentPeer.onLocalCandidate((candidate, mid) => {
+      if (stopped || currentPeer !== peer) return;
+      localCandidates.push(JSON.stringify({ candidate, sdpMid: mid }));
+    });
+    currentPeer.onStateChange((state) => {
+      if (stopped || currentPeer !== peer) return;
+      if (state === "connected") {
+        connected = true;
+        return;
       }
+      if (state === "disconnected" || state === "failed") {
+        connected = false;
+        scheduleRecovery();
+      }
+    });
+    currentPeer.onDataChannel((dc) => {
+      if (stopped || currentPeer !== peer) return;
+      setupChannel(dc.getLabel(), dc);
     });
   }
-  openDataChannel(CONTROL_CHANNEL);
-  openDataChannel(CHANNELS.CHAT);
-  openDataChannel(CHANNELS.CANVAS);
-  const localCandidates = [];
-  peer.onLocalCandidate((candidate, mid) => {
-    localCandidates.push(JSON.stringify({ candidate, sdpMid: mid }));
-  });
-  peer.onStateChange((state) => {
-    if (state === "connected") {
-      connected = true;
-      if (pollingInterval) {
-        clearInterval(pollingInterval);
-        pollingInterval = null;
+  function createPeer() {
+    const nextPeer = new ndc.PeerConnection("agent", {
+      iceServers: ["stun:stun.l.google.com:19302", "stun:stun1.l.google.com:19302"]
+    });
+    peer = nextPeer;
+    channels = /* @__PURE__ */ new Map();
+    pendingInboundBinaryMeta = /* @__PURE__ */ new Map();
+    attachPeerHandlers(nextPeer);
+    openDataChannel(CONTROL_CHANNEL);
+    openDataChannel(CHANNELS.CHAT);
+    openDataChannel(CHANNELS.CANVAS);
+  }
+  function closeCurrentPeer() {
+    for (const dc of channels.values()) {
+      try {
+        dc.close();
+      } catch {
       }
-    } else if (state === "disconnected" || state === "failed") {
-      connected = false;
     }
-  });
-  peer.onDataChannel((dc) => {
-    setupChannel(dc.getLabel(), dc);
-  });
+    channels.clear();
+    pendingInboundBinaryMeta.clear();
+    if (peer) {
+      try {
+        peer.close();
+      } catch {
+      }
+      peer = null;
+    }
+  }
+  function scheduleNextPoll(delayMs) {
+    if (stopped) return;
+    clearPollingTimer();
+    pollingTimer = setTimeout(() => {
+      void runPollingLoop();
+    }, delayMs);
+  }
+  async function pollSignalingOnce() {
+    const tunnel = await apiClient.get(tunnelId);
+    if (tunnel.browserAnswer && !remoteDescriptionApplied) {
+      if (!peer) return;
+      try {
+        const answer = JSON.parse(tunnel.browserAnswer);
+        peer.setRemoteDescription(answer.sdp, answer.type);
+        remoteDescriptionApplied = true;
+        while (pendingRemoteCandidates.length > 0) {
+          const next = pendingRemoteCandidates.shift();
+          if (!next) break;
+          try {
+            peer.addRemoteCandidate(next.candidate, next.sdpMid);
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    if (tunnel.browserCandidates.length > lastBrowserCandidateCount) {
+      const newCandidates = tunnel.browserCandidates.slice(lastBrowserCandidateCount);
+      lastBrowserCandidateCount = tunnel.browserCandidates.length;
+      for (const c of newCandidates) {
+        try {
+          const parsed = JSON.parse(c);
+          if (typeof parsed.candidate !== "string") continue;
+          const sdpMid = typeof parsed.sdpMid === "string" ? parsed.sdpMid : "0";
+          if (!remoteDescriptionApplied) {
+            pendingRemoteCandidates.push({ candidate: parsed.candidate, sdpMid });
+            continue;
+          }
+          if (!peer) continue;
+          peer.addRemoteCandidate(parsed.candidate, sdpMid);
+        } catch {
+        }
+      }
+    }
+  }
+  async function runPollingLoop() {
+    if (stopped) return;
+    try {
+      await pollSignalingOnce();
+    } catch {
+    }
+    scheduleNextPoll(remoteDescriptionApplied ? SIGNAL_POLL_CONNECTED_MS : SIGNAL_POLL_WAITING_MS);
+  }
+  async function runNegotiationCycle() {
+    if (!peer) throw new Error("PeerConnection not initialized");
+    resetNegotiationState();
+    const offer = await generateOffer(peer, OFFER_TIMEOUT_MS);
+    await apiClient.signal(tunnelId, { offer });
+    startLocalCandidateFlush();
+  }
+  async function recoverPeer() {
+    if (stopped || recovering) return;
+    recovering = true;
+    try {
+      closeCurrentPeer();
+      createPeer();
+      await runNegotiationCycle();
+    } finally {
+      recovering = false;
+    }
+  }
+  function scheduleRecovery(delayMs = RECOVERY_DELAY_MS) {
+    if (stopped || recovering || recoveryTimer) return;
+    recoveryTimer = setTimeout(() => {
+      recoveryTimer = null;
+      if (stopped || connected) return;
+      void recoverPeer().catch(() => {
+        if (!stopped) scheduleRecovery(delayMs);
+      });
+    }, delayMs);
+  }
   if (fs.existsSync(socketPath)) {
     let stale = true;
     try {
@@ -123,6 +285,7 @@ async function startDaemon(config) {
       throw new Error(`Daemon already running (socket: ${socketPath})`);
     }
   }
+  createPeer();
   const ipcServer = net.createServer((conn) => {
     let data = "";
     conn.on("data", (chunk) => {
@@ -151,10 +314,21 @@ async function startDaemon(config) {
     infoPath,
     JSON.stringify({ pid: process.pid, tunnelId, socketPath, startedAt: startTime })
   );
+  scheduleNextPoll(0);
+  try {
+    await runNegotiationCycle();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await cleanup();
+    throw new Error(`Failed to generate WebRTC offer: ${message}`);
+  }
   async function cleanup() {
-    if (pollingInterval) clearInterval(pollingInterval);
-    for (const dc of channels.values()) dc.close();
-    peer.close();
+    if (stopped) return;
+    stopped = true;
+    clearPollingTimer();
+    clearLocalCandidateTimers();
+    clearRecoveryTimer();
+    closeCurrentPeer();
     ipcServer.close();
     try {
       fs.unlinkSync(socketPath);
@@ -171,72 +345,12 @@ async function startDaemon(config) {
     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) {
-      await apiClient.signal(tunnelId, { candidates: localCandidates }).catch(() => {
-      });
-    }
-  }, 1e3);
-  let lastSentCandidateCount = 0;
-  const candidateInterval = setInterval(async () => {
-    if (localCandidates.length > lastSentCandidateCount) {
-      const newOnes = localCandidates.slice(lastSentCandidateCount);
-      lastSentCandidateCount = localCandidates.length;
-      await apiClient.signal(tunnelId, { candidates: newOnes }).catch(() => {
-      });
-    }
-  }, 500);
-  setTimeout(() => clearInterval(candidateInterval), 3e4);
-  pollingInterval = setInterval(async () => {
-    try {
-      const tunnel = await apiClient.get(tunnelId);
-      if (tunnel.browserAnswer && !remoteDescriptionApplied) {
-        try {
-          const answer = JSON.parse(tunnel.browserAnswer);
-          peer.setRemoteDescription(answer.sdp, answer.type);
-          remoteDescriptionApplied = true;
-          while (pendingRemoteCandidates.length > 0) {
-            const next = pendingRemoteCandidates.shift();
-            if (!next) break;
-            try {
-              peer.addRemoteCandidate(next.candidate, next.sdpMid);
-            } catch {
-            }
-          }
-        } catch {
-        }
-      }
-      if (tunnel.browserCandidates.length > lastBrowserCandidateCount) {
-        const newCandidates = tunnel.browserCandidates.slice(lastBrowserCandidateCount);
-        lastBrowserCandidateCount = tunnel.browserCandidates.length;
-        for (const c of newCandidates) {
-          try {
-            const parsed = JSON.parse(c);
-            if (typeof parsed.candidate !== "string") continue;
-            const sdpMid = typeof parsed.sdpMid === "string" ? parsed.sdpMid : "0";
-            if (!remoteDescriptionApplied) {
-              pendingRemoteCandidates.push({ candidate: parsed.candidate, sdpMid });
-              continue;
-            }
-            peer.addRemoteCandidate(parsed.candidate, sdpMid);
-          } catch {
-          }
-        }
-      }
-    } catch {
-    }
-  }, 500);
+  process.on("SIGTERM", () => {
+    void shutdown();
+  });
+  process.on("SIGINT", () => {
+    void shutdown();
+  });
   async function handleIpcRequest(req) {
     switch (req.method) {
       case "write": {
@@ -245,12 +359,8 @@ 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 dc = channels.get(channel);
-        let targetDc = dc;
-        if (!targetDc) {
-          const newDc = openDataChannel(channel);
-          targetDc = newDc;
-        }
+        let targetDc = channels.get(channel);
+        if (!targetDc) targetDc = openDataChannel(channel);
         try {
           await waitForChannelOpen(targetDc);
         } catch (error) {
@@ -287,10 +397,7 @@ async function startDaemon(config) {
         return { ok: true, messages: msgs };
       }
       case "channels": {
-        const chList = [...channels.keys()].map((name) => ({
-          name,
-          direction: "bidi"
-        }));
+        const chList = [...channels.keys()].map((name) => ({ name, direction: "bidi" }));
         return { ok: true, channels: chList };
       }
       case "status": {

package/dist/index.js

@@ -215,19 +215,22 @@ function isDaemonRunning(tunnelId) {
     return false;
   }
 }
+function getFollowReadDelayMs(disconnected, consecutiveFailures) {
+  if (!disconnected) return 1e3;
+  return Math.min(5e3, 1e3 * 2 ** Math.min(consecutiveFailures, 3));
+}
 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-QPXIGRW7.js");
       console.log(`Tunnel started: ${result.url}`);
       console.log(`Tunnel ID: ${result.tunnelId}`);
       console.log(`Expires: ${new Date(result.expiresAt).toISOString()}`);
@@ -335,21 +338,33 @@ function registerTunnelCommands(program2) {
       const tunnelId = tunnelIdArg || await resolveActiveTunnel();
       const socketPath = getSocketPath(tunnelId);
       if (opts.follow) {
+        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: opts.channel }
+            });
+            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 {
+            consecutiveFailures += 1;
+            if (!warnedDisconnected) {
+              console.error("Daemon disconnected. Waiting for recovery...");
+              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, {
@@ -395,9 +410,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 +581,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 +600,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.3");
 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 +612,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 +624,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 +659,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 +669,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-K7Z7FUFN.js → tunnel-daemon-QPXIGRW7.js}

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

package/dist/tunnel-daemon-entry.js

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

package/package.json

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