pubblue 0.6.1 → 0.6.8

package/dist/live-daemon-entry.js

@@ -0,0 +1,778 @@
+import {
+  CHANNELS,
+  CONTROL_CHANNEL,
+  PubApiClient,
+  PubApiError,
+  createClaudeCodeBridgeRunner,
+  createOpenClawBridgeRunner,
+  decodeMessage,
+  encodeMessage,
+  errorMessage,
+  latestCliVersionPath,
+  makeAckMessage,
+  parseAckMessage,
+  readLatestCliVersion,
+  shouldAcknowledgeMessage
+} from "./chunk-AZQD654L.js";
+
+// src/lib/live-daemon.ts
+import * as fs from "fs";
+import * as net from "net";
+import * as path from "path";
+
+// ../shared/ack-routing-core.ts
+function resolveAckChannel(input) {
+  if (input.messageChannelOpen) return input.messageChannel;
+  if (input.controlChannelOpen) return CONTROL_CHANNEL;
+  return null;
+}
+
+// src/lib/live-daemon-answer.ts
+function createAnswer(peer, browserOffer, 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 }));
+    };
+    const offer = JSON.parse(browserOffer);
+    peer.setRemoteDescription(offer.sdp, offer.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);
+  });
+}
+
+// src/lib/live-daemon-shared.ts
+function buildBridgeInstructions(mode) {
+  if (mode === "claude-code") {
+    return {
+      replyHint: 'Reply by running: pubblue write "<your reply>"',
+      canvasHint: "Canvas update: pubblue write -c canvas -f /path/to/file.html",
+      systemPrompt: [
+        "You are in a live P2P session with a user.",
+        "The canvas is an iframe visible to the user alongside the chat.",
+        "Always `use pubblue write` for all communication with the user."
+      ].join("\n")
+    };
+  }
+  return {
+    replyHint: 'Reply by running: write "<your reply>"',
+    canvasHint: "Canvas update: write -c canvas -f /path/to/file.html",
+    systemPrompt: null
+  };
+}
+var OFFER_TIMEOUT_MS = 1e4;
+var SIGNAL_POLL_WAITING_MS = 5e3;
+var SIGNAL_POLL_CONNECTED_MS = 15e3;
+var LOCAL_CANDIDATE_FLUSH_MS = 2e3;
+var WRITE_ACK_TIMEOUT_MS = 5e3;
+var NOT_CONNECTED_WRITE_ERROR = "No browser connected. Ask the user to open the pub URL first, then retry.";
+function getLiveWriteReadinessError(isConnected) {
+  return isConnected ? null : NOT_CONNECTED_WRITE_ERROR;
+}
+function shouldRecoverForBrowserOfferChange(params) {
+  const { incomingBrowserOffer, lastAppliedBrowserOffer } = params;
+  if (!incomingBrowserOffer) return false;
+  if (!lastAppliedBrowserOffer) return false;
+  return incomingBrowserOffer !== lastAppliedBrowserOffer;
+}
+var MAX_CANVAS_PERSIST_SIZE = 100 * 1024;
+function getStickyCanvasHtml(stickyOutbound, canvasChannel) {
+  const msg = stickyOutbound.get(canvasChannel);
+  if (!msg) return null;
+  if (msg.type !== "html") return null;
+  const html = msg.data;
+  if (!html) return null;
+  if (new TextEncoder().encode(html).byteLength > MAX_CANVAS_PERSIST_SIZE) return null;
+  return html;
+}
+function getSignalPollDelayMs(params) {
+  const baseDelay = params.hasActiveConnection ? SIGNAL_POLL_CONNECTED_MS : SIGNAL_POLL_WAITING_MS;
+  if (params.retryAfterSeconds === void 0) return baseDelay;
+  if (!Number.isFinite(params.retryAfterSeconds) || params.retryAfterSeconds <= 0) {
+    return baseDelay;
+  }
+  return Math.max(baseDelay, Math.ceil(params.retryAfterSeconds * 1e3));
+}
+
+// src/lib/live-daemon.ts
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var HEALTH_CHECK_INTERVAL_MS = 60 * 60 * 1e3;
+var PERSIST_TIMEOUT_MS = 3e3;
+async function startDaemon(config) {
+  const { apiClient: apiClient2, socketPath: socketPath2, infoPath: infoPath2, cliVersion: cliVersion2, agentName: agentName2 } = config;
+  const ndc = await import("node-datachannel");
+  const buffer = { messages: [] };
+  const startTime = Date.now();
+  let stopped = false;
+  let connected = false;
+  let recovering = false;
+  let activeSlug = null;
+  let lastAppliedBrowserOffer = null;
+  let lastBrowserCandidateCount = 0;
+  let lastSentCandidateCount = 0;
+  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 heartbeatTimer = null;
+  let localCandidateInterval = null;
+  let localCandidateStopTimer = null;
+  let healthCheckTimer = null;
+  let lastError = null;
+  const debugEnabled = process.env.PUBBLUE_LIVE_DEBUG === "1";
+  const versionFilePath = latestCliVersionPath();
+  let bridgeRunner = null;
+  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-agent] ${message}${detail}`);
+  }
+  function markError(message, error) {
+    lastError = error === void 0 ? message : `${message}: ${errorMessage(error)}`;
+    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 clearHealthCheckTimer() {
+    if (healthCheckTimer) {
+      clearInterval(healthCheckTimer);
+      healthCheckTimer = null;
+    }
+  }
+  function clearHeartbeatTimer() {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+  }
+  function runHealthCheck() {
+    if (stopped) return;
+    if (cliVersion2) {
+      const latest = readLatestCliVersion(versionFilePath);
+      if (latest && latest !== cliVersion2) {
+        markError(`detected CLI upgrade (${cliVersion2} \u2192 ${latest}); shutting down`);
+        void shutdown();
+      }
+    }
+  }
+  function startHealthCheckTimer() {
+    clearHealthCheckTimer();
+    healthCheckTimer = setInterval(runHealthCheck, HEALTH_CHECK_INTERVAL_MS);
+    runHealthCheck();
+  }
+  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() });
+        bridgeRunner?.enqueue([{ channel: name, msg }]);
+        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() });
+      bridgeRunner?.enqueue([{ channel: name, msg: binMsg }]);
+    });
+  }
+  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) {
+    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,
+      meta: msg.meta ? { ...msg.meta } : void 0
+    });
+  }
+  async function replayStickyOutboundMessages() {
+    if (!connected || recovering || stopped) return;
+    for (const [channel, msg] of stickyOutboundByChannel) {
+      try {
+        let targetDc = channels.get(channel);
+        if (!targetDc) targetDc = openDataChannel(channel);
+        await waitForChannelOpen(targetDc, 3e3);
+        targetDc.sendMessage(encodeMessage(msg));
+      } catch (error) {
+        debugLog(`sticky outbound replay failed for channel ${channel}`, error);
+      }
+    }
+  }
+  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") {
+        const wasConnected = connected;
+        connected = false;
+        if (wasConnected) void persistCanvasContent();
+      }
+    });
+    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);
+  }
+  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 resetNegotiationState() {
+    connected = false;
+    failPendingAcks();
+    lastAppliedBrowserOffer = null;
+    lastBrowserCandidateCount = 0;
+    lastSentCandidateCount = 0;
+    localCandidates.length = 0;
+    clearLocalCandidateTimers();
+  }
+  function startLocalCandidateFlush(slug) {
+    clearLocalCandidateTimers();
+    localCandidateInterval = setInterval(async () => {
+      if (localCandidates.length <= lastSentCandidateCount) return;
+      const newOnes = localCandidates.slice(lastSentCandidateCount);
+      lastSentCandidateCount = localCandidates.length;
+      await apiClient2.signalAnswer({ slug, candidates: newOnes }).catch((error) => {
+        debugLog("failed to publish local ICE candidates", error);
+      });
+    }, LOCAL_CANDIDATE_FLUSH_MS);
+    localCandidateStopTimer = setTimeout(() => {
+      clearLocalCandidateTimers();
+    }, 3e4);
+  }
+  async function handleIncomingLive(slug, browserOffer) {
+    if (recovering) return;
+    recovering = true;
+    try {
+      await persistCanvasContent();
+      await stopBridge();
+      closeCurrentPeer();
+      createPeer();
+      resetNegotiationState();
+      if (!peer) throw new Error("PeerConnection not initialized");
+      const answer = await createAnswer(peer, browserOffer, OFFER_TIMEOUT_MS);
+      lastAppliedBrowserOffer = browserOffer;
+      activeSlug = slug;
+      await apiClient2.signalAnswer({ slug, answer, agentName: agentName2 });
+      startLocalCandidateFlush(slug);
+      void startBridge();
+    } catch (error) {
+      markError("failed to handle incoming live request", error);
+    } finally {
+      recovering = false;
+    }
+  }
+  function scheduleNextPoll(delayMs) {
+    if (stopped) return;
+    clearPollingTimer();
+    pollingTimer = setTimeout(() => {
+      void runPollingLoop();
+    }, delayMs);
+  }
+  async function pollSignalingOnce() {
+    const live = await apiClient2.getPendingLive();
+    if (!live) {
+      return;
+    }
+    if (live.browserOffer && !live.agentAnswer) {
+      if (shouldRecoverForBrowserOfferChange({
+        incomingBrowserOffer: live.browserOffer,
+        lastAppliedBrowserOffer
+      }) || !lastAppliedBrowserOffer) {
+        await handleIncomingLive(live.slug, live.browserOffer);
+        return;
+      }
+    }
+    if (live.browserOffer && live.agentAnswer && live.slug === activeSlug) {
+      if (live.browserCandidates.length > lastBrowserCandidateCount) {
+        const newCandidates = live.browserCandidates.slice(lastBrowserCandidateCount);
+        lastBrowserCandidateCount = live.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 (!peer) continue;
+            peer.addRemoteCandidate(parsed.candidate, sdpMid);
+          } catch (error) {
+            debugLog("failed to parse/apply browser ICE candidate", error);
+          }
+        }
+      }
+    }
+  }
+  async function runPollingLoop() {
+    if (stopped) return;
+    let retryAfterSeconds;
+    try {
+      await pollSignalingOnce();
+    } catch (error) {
+      if (error instanceof PubApiError && error.status === 429) {
+        retryAfterSeconds = error.retryAfterSeconds;
+      }
+      markError("signaling poll failed", error);
+    }
+    const baseDelay = getSignalPollDelayMs({
+      hasActiveConnection: connected,
+      retryAfterSeconds
+    });
+    scheduleNextPoll(baseDelay);
+  }
+  if (fs.existsSync(socketPath2)) {
+    let stale = true;
+    try {
+      const raw = fs.readFileSync(infoPath2, "utf-8");
+      const info = JSON.parse(raw);
+      process.kill(info.pid, 0);
+      stale = false;
+    } catch (error) {
+      debugLog("stale socket check failed (assuming stale)", error);
+    }
+    if (stale) {
+      try {
+        fs.unlinkSync(socketPath2);
+      } catch (error) {
+        debugLog("failed to remove stale daemon socket", error);
+      }
+    } else {
+      throw new Error(`Daemon already running (socket: ${socketPath2})`);
+    }
+  }
+  await apiClient2.goOnline();
+  heartbeatTimer = setInterval(async () => {
+    if (stopped) return;
+    try {
+      await apiClient2.heartbeat();
+    } catch (error) {
+      markError("heartbeat failed", error);
+    }
+  }, HEARTBEAT_INTERVAL_MS);
+  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: errorMessage(err) })}
+`));
+    });
+  });
+  ipcServer.listen(socketPath2);
+  const infoDir = path.dirname(infoPath2);
+  if (!fs.existsSync(infoDir)) fs.mkdirSync(infoDir, { recursive: true });
+  fs.writeFileSync(
+    infoPath2,
+    JSON.stringify({ pid: process.pid, socketPath: socketPath2, startedAt: startTime, cliVersion: cliVersion2 })
+  );
+  startHealthCheckTimer();
+  scheduleNextPoll(0);
+  function sendOnChannel(channel, msg) {
+    if (stopped || !connected) return;
+    let targetDc = channels.get(channel);
+    if (!targetDc) {
+      try {
+        targetDc = openDataChannel(channel);
+      } catch (error) {
+        debugLog(`bridge sendOnChannel: failed to open channel ${channel}`, error);
+        return;
+      }
+    }
+    try {
+      if (targetDc.isOpen()) {
+        targetDc.sendMessage(encodeMessage(msg));
+      }
+    } catch (error) {
+      debugLog(`bridge sendOnChannel failed for ${channel}`, error);
+    }
+  }
+  async function startBridge() {
+    if (stopped || !activeSlug) return;
+    if (!config.bridgeMode) return;
+    await stopBridge();
+    const instructions = buildBridgeInstructions(config.bridgeMode);
+    const bridgeConfig = { slug: activeSlug, sendMessage: sendOnChannel, debugLog, instructions };
+    try {
+      bridgeRunner = config.bridgeMode === "claude-code" ? await createClaudeCodeBridgeRunner(bridgeConfig) : await createOpenClawBridgeRunner(bridgeConfig);
+    } catch (error) {
+      markError("bridge runner failed to start", error);
+    }
+  }
+  async function stopBridge() {
+    if (bridgeRunner) {
+      await bridgeRunner.stop();
+      bridgeRunner = null;
+    }
+  }
+  async function persistCanvasContent() {
+    if (!activeSlug) return;
+    const html = getStickyCanvasHtml(stickyOutboundByChannel, CHANNELS.CANVAS);
+    if (!html) return;
+    try {
+      const timeout = new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("persist timeout")), PERSIST_TIMEOUT_MS)
+      );
+      await Promise.race([
+        apiClient2.update({ slug: activeSlug, content: html, filename: "canvas.html" }),
+        timeout
+      ]);
+    } catch (error) {
+      debugLog("failed to persist canvas content", error);
+    }
+  }
+  async function cleanup() {
+    if (stopped) return;
+    stopped = true;
+    clearPollingTimer();
+    clearLocalCandidateTimers();
+    clearHealthCheckTimer();
+    clearHeartbeatTimer();
+    try {
+      await apiClient2.goOffline();
+    } catch (error) {
+      debugLog("failed to go offline", error);
+    }
+    await persistCanvasContent();
+    await stopBridge();
+    closeCurrentPeer();
+    ipcServer.close();
+    try {
+      fs.unlinkSync(socketPath2);
+    } catch (error) {
+      debugLog("failed to remove daemon socket during cleanup", error);
+    }
+    try {
+      fs.unlinkSync(infoPath2);
+    } catch (error) {
+      debugLog("failed to remove daemon info file 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 = getLiveWriteReadinessError(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) {
+          markError(`channel "${channel}" failed to open`, error);
+          return { ok: false, error: `Channel "${channel}" not open: ${errorMessage(error)}` };
+        }
+        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);
+          markError(`failed to send message on channel "${channel}"`, error);
+          return {
+            ok: false,
+            error: `Failed to send on channel "${channel}": ${errorMessage(error)}`
+          };
+        }
+        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);
+        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,
+          activeSlug,
+          uptime: Math.floor((Date.now() - startTime) / 1e3),
+          channels: [...channels.keys()],
+          bufferedMessages: buffer.messages.length,
+          lastError,
+          bridgeMode: config.bridgeMode ?? null,
+          bridge: bridgeRunner?.status() ?? null
+        };
+      }
+      case "active-slug": {
+        return { ok: true, slug: activeSlug };
+      }
+      case "close": {
+        void shutdown();
+        return { ok: true };
+      }
+      default:
+        return { ok: false, error: `Unknown method: ${req.method}` };
+    }
+  }
+}
+
+// src/live-daemon-entry.ts
+var baseUrl = process.env.PUBBLUE_DAEMON_BASE_URL;
+var apiKey = process.env.PUBBLUE_DAEMON_API_KEY;
+var socketPath = process.env.PUBBLUE_DAEMON_SOCKET;
+var infoPath = process.env.PUBBLUE_DAEMON_INFO;
+var cliVersion = process.env.PUBBLUE_CLI_VERSION;
+var agentName = process.env.PUBBLUE_DAEMON_AGENT_NAME;
+var bridgeModeRaw = process.env.PUBBLUE_DAEMON_BRIDGE_MODE;
+if (!bridgeModeRaw) {
+  console.error("Missing PUBBLUE_DAEMON_BRIDGE_MODE env var.");
+  process.exit(1);
+}
+var bridgeMode = bridgeModeRaw;
+if (!baseUrl || !apiKey || !socketPath || !infoPath) {
+  console.error("Missing required env vars for daemon.");
+  process.exit(1);
+}
+var apiClient = new PubApiClient(baseUrl, apiKey);
+void startDaemon({ apiClient, socketPath, infoPath, cliVersion, bridgeMode, agentName }).catch(
+  (error) => {
+    console.error(`Daemon failed to start: ${errorMessage(error)}`);
+    process.exit(1);
+  }
+);