pubblue 0.4.1 → 0.4.3

package/dist/chunk-YHFY3TW5.js

@@ -0,0 +1,456 @@
+import {
+  CHANNELS,
+  CONTROL_CHANNEL,
+  decodeMessage,
+  encodeMessage
+} from "./chunk-56IKFMJ2.js";
+
+// src/lib/tunnel-daemon.ts
+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;
+}
+async function startDaemon(config) {
+  const { tunnelId, apiClient, socketPath, infoPath } = config;
+  const ndc = await import("node-datachannel");
+  const buffer = { messages: [] };
+  const startTime = Date.now();
+  let stopped = false;
+  let connected = false;
+  let recovering = false;
+  let remoteDescriptionApplied = false;
+  let lastBrowserCandidateCount = 0;
+  let lastSentCandidateCount = 0;
+  const pendingRemoteCandidates = [];
+  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 });
+    setupChannel(name, dc);
+    return dc;
+  }
+  async function waitForChannelOpen(dc, timeoutMs = 5e3) {
+    if (dc.isOpen()) return;
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const timeout = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        reject(new Error("DataChannel open timed out"));
+      }, timeoutMs);
+      dc.onOpen(() => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        resolve();
+      });
+    });
+  }
+  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);
+    });
+  }
+  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 {
+      }
+    }
+    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 {
+      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})`);
+    }
+  }
+  createPeer();
+  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);
+  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) {
+    const message = error instanceof Error ? error.message : String(error);
+    await cleanup();
+    throw new Error(`Failed to generate WebRTC offer: ${message}`);
+  }
+  async function cleanup() {
+    if (stopped) return;
+    stopped = true;
+    clearPollingTimer();
+    clearLocalCandidateTimers();
+    clearRecoveryTimer();
+    closeCurrentPeer();
+    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();
+  });
+  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;
+        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);
+          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));
+        }
+        return { ok: true };
+      }
+      case "read": {
+        const channel = req.params.channel;
+        let msgs;
+        if (channel) {
+          msgs = buffer.messages.filter((m) => m.channel === channel);
+          buffer.messages = buffer.messages.filter((m) => m.channel !== channel);
+        } else {
+          msgs = [...buffer.messages];
+          buffer.messages = [];
+        }
+        return { ok: true, messages: msgs };
+      }
+      case "channels": {
+        const chList = [...channels.keys()].map((name) => ({ name, direction: "bidi" }));
+        return { ok: true, channels: chList };
+      }
+      case "status": {
+        return {
+          ok: true,
+          connected,
+          uptime: Math.floor((Date.now() - startTime) / 1e3),
+          channels: [...channels.keys()],
+          bufferedMessages: buffer.messages.length
+        };
+      }
+      case "close": {
+        void shutdown();
+        return { ok: true };
+      }
+      default:
+        return { ok: false, error: `Unknown method: ${req.method}` };
+    }
+  }
+}
+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);
+    });
+    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

@@ -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-QBJSX4JM.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.1");
+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-QPXIGRW7.js

@@ -0,0 +1,9 @@
+import {
+  getTunnelWriteReadinessError,
+  startDaemon
+} from "./chunk-YHFY3TW5.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-77HFJKLW.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.1",
+  "version": "0.4.3",
   "description": "CLI tool for publishing static content via pub.blue",
   "type": "module",
   "bin": {

package/dist/chunk-77HFJKLW.js

@@ -1,342 +0,0 @@
-import {
-  CHANNELS,
-  CONTROL_CHANNEL,
-  decodeMessage,
-  encodeMessage
-} from "./chunk-56IKFMJ2.js";
-
-// src/lib/tunnel-daemon.ts
-import * as fs from "fs";
-import * as net from "net";
-import * as path from "path";
-var OFFER_TIMEOUT_MS = 1e4;
-async function startDaemon(config) {
-  const { tunnelId, apiClient, socketPath, infoPath } = config;
-  const ndc = await import("node-datachannel");
-  const buffer = { messages: [] };
-  const startTime = Date.now();
-  let connected = false;
-  let pollingInterval = null;
-  let lastBrowserCandidateCount = 0;
-  let remoteDescriptionApplied = false;
-  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();
-  function openDataChannel(name) {
-    const existing = channels.get(name);
-    if (existing) return existing;
-    const dc = peer.createDataChannel(name, { ordered: true });
-    setupChannel(name, dc);
-    return dc;
-  }
-  async function waitForChannelOpen(dc, timeoutMs = 5e3) {
-    if (dc.isOpen()) return;
-    await new Promise((resolve, reject) => {
-      let settled = false;
-      const timeout = setTimeout(() => {
-        if (settled) return;
-        settled = true;
-        reject(new Error("DataChannel open timed out"));
-      }, timeoutMs);
-      dc.onOpen(() => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timeout);
-        resolve();
-      });
-    });
-  }
-  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() });
-      }
-    });
-  }
-  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;
-      }
-    } else if (state === "disconnected" || state === "failed") {
-      connected = false;
-    }
-  });
-  peer.onDataChannel((dc) => {
-    setupChannel(dc.getLabel(), dc);
-  });
-  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) })}
-`));
-    });
-  });
-  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) {
-      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);
-  async function handleIpcRequest(req) {
-    switch (req.method) {
-      case "write": {
-        const channel = req.params.channel || CHANNELS.CHAT;
-        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;
-        }
-        try {
-          await waitForChannelOpen(targetDc);
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(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));
-        }
-        return { ok: true };
-      }
-      case "read": {
-        const channel = req.params.channel;
-        let msgs;
-        if (channel) {
-          msgs = buffer.messages.filter((m) => m.channel === channel);
-          buffer.messages = buffer.messages.filter((m) => m.channel !== channel);
-        } else {
-          msgs = [...buffer.messages];
-          buffer.messages = [];
-        }
-        return { ok: true, messages: msgs };
-      }
-      case "channels": {
-        const chList = [...channels.keys()].map((name) => ({
-          name,
-          direction: "bidi"
-        }));
-        return { ok: true, channels: chList };
-      }
-      case "status": {
-        return {
-          ok: true,
-          connected,
-          uptime: Math.floor((Date.now() - startTime) / 1e3),
-          channels: [...channels.keys()],
-          bufferedMessages: buffer.messages.length
-        };
-      }
-      case "close": {
-        void shutdown();
-        return { ok: true };
-      }
-      default:
-        return { ok: false, error: `Unknown method: ${req.method}` };
-    }
-  }
-}
-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);
-    });
-    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 {
-  startDaemon
-};

package/dist/tunnel-daemon-QBJSX4JM.js

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