pubblue 0.4.2 → 0.4.4

package/dist/chunk-AIEPM67G.js

@@ -0,0 +1,659 @@
+import {
+  CHANNELS,
+  CONTROL_CHANNEL,
+  decodeMessage,
+  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");
+  const buffer = { messages: [] };
+  const startTime = Date.now();
+  let stopped = false;
+  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();
+  let pollingTimer = null;
+  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);
+      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.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;
+      }
+      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 }
+      };
+      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);
+    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 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;
+    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((error) => {
+        debugLog("failed to publish local ICE candidates", error);
+      });
+    }, 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;
+        flushQueuedAcks();
+        void replayStickyOutboundMessages();
+        return;
+      }
+      if (state === "disconnected" || state === "failed" || state === "closed") {
+        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() {
+    failPendingAcks();
+    for (const dc of channels.values()) {
+      try {
+        dc.close();
+      } catch (error) {
+        debugLog("failed to close data channel cleanly", error);
+      }
+    }
+    channels.clear();
+    pendingInboundBinaryMeta.clear();
+    if (peer) {
+      try {
+        peer.close();
+      } catch (error) {
+        debugLog("failed to close peer connection cleanly", error);
+      }
+      peer = null;
+    }
+  }
+  function scheduleNextPoll(delayMs) {
+    if (stopped) return;
+    clearPollingTimer();
+    pollingTimer = setTimeout(() => {
+      void runPollingLoop();
+    }, delayMs);
+  }
+  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 (error) {
+            debugLog("failed to apply queued remote ICE candidate", error);
+          }
+        }
+      } catch (error) {
+        markError("failed to apply browser answer", error);
+      }
+    }
+    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 (error) {
+          debugLog("failed to parse/apply browser ICE candidate", error);
+        }
+      }
+    }
+  }
+  async function runPollingLoop() {
+    if (stopped) return;
+    try {
+      await pollSignalingOnce();
+    } catch (error) {
+      markError("signaling poll failed", error);
+    }
+    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, force = false) {
+    if (stopped || recovering || recoveryTimer) return;
+    recoveryTimer = setTimeout(() => {
+      recoveryTimer = null;
+      if (stopped || !force && connected) return;
+      void recoverPeer().catch((error) => {
+        markError("peer recovery failed", error);
+        if (!stopped) scheduleRecovery(delayMs, force);
+      });
+    }, 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 (error) {
+        debugLog("failed to remove stale daemon socket", error);
+      }
+    } 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);
+    markError("initial negotiation failed", 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 (error) {
+      debugLog("failed to remove daemon socket during cleanup", error);
+    }
+    try {
+      fs.unlinkSync(infoPath);
+    } catch (error) {
+      debugLog("failed to remove daemon info file during cleanup", error);
+    }
+    await apiClient.close(tunnelId).catch((error) => {
+      markError("failed to close tunnel on API during cleanup", error);
+    });
+  }
+  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;
+        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}` };
+        }
+        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}` };
+        }
+        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;
+        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,
+          lastError
+        };
+      }
+      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,
+  shouldRecoverForBrowserAnswerChange,
+  startDaemon
+};