pubblue 0.6.9 → 0.7.2

package/dist/live-daemon-entry.js

@@ -5,6 +5,7 @@ import {
   buildClaudeArgs,
   buildSessionBriefing,
   createClaudeCodeBridgeRunner,
+  createClaudeSdkBridgeRunner,
   createOpenClawBridgeRunner,
   decodeMessage,
   encodeMessage,
@@ -14,12 +15,20 @@ import {
   makeDeliveryReceiptMessage,
   makeEventMessage,
   parseAckMessage,
+  parseIpcRequest,
+  parseLiveInfo,
+  readFiniteNumber,
   readLatestCliVersion,
+  readNonEmptyString,
+  readRecord,
+  readString,
+  readStringArray,
+  readStringRecord,
   resolveClaudeCodePath,
   resolveOpenClawRuntime,
   shouldAcknowledgeMessage,
   writeLiveSessionContentFile
-} from "./chunk-JSX5KHV3.js";
+} from "./chunk-5LI2HLKX.js";
 
 // src/lib/live-daemon.ts
 import { randomUUID } from "crypto";
@@ -33,51 +42,37 @@ function resolveAckChannel(input) {
   return null;
 }
 
+// ../shared/webrtc-transport-core.ts
+var WEBRTC_STUN_URLS = [
+  "stun:stun.l.google.com:19302",
+  "stun:stun1.l.google.com:19302"
+];
+var WEBRTC_ICE_SERVER_CONFIG = [
+  { urls: WEBRTC_STUN_URLS[0] },
+  { urls: WEBRTC_STUN_URLS[1] }
+];
+var ORDERED_DATA_CHANNEL_OPTIONS = {
+  ordered: true
+};
+
 // src/lib/live-command-handler.ts
 import { spawn } from "child_process";
 
 // ../shared/command-protocol-core.ts
 var COMMAND_PROTOCOL_VERSION = 1;
 var COMMAND_MANIFEST_MAX_FUNCTIONS = 64;
-function makeCommandBindResultMessage(payload) {
-  return makeEventMessage("command.bind.result", payload);
-}
+var COMMAND_MANIFEST_MIME = "application/pubblue-command-manifest+json";
 function makeCommandResultMessage(payload) {
   return makeEventMessage("command.result", payload);
 }
-function readRecord(input) {
-  return input && typeof input === "object" && !Array.isArray(input) ? input : null;
-}
-function readString(input) {
-  return typeof input === "string" && input.trim().length > 0 ? input : void 0;
-}
 function readReturnType(input) {
   if (input === "void" || input === "text" || input === "json") return input;
   return void 0;
 }
-function readFiniteNumber(input) {
-  if (typeof input !== "number" || !Number.isFinite(input)) return void 0;
-  return input;
-}
-function readStringArray(input) {
-  if (!Array.isArray(input)) return void 0;
-  const values = input.filter((entry) => typeof entry === "string");
-  return values.length === input.length ? values : void 0;
-}
-function readStringRecord(input) {
-  const record = readRecord(input);
-  if (!record) return void 0;
-  const values = Object.entries(record).filter((entry) => {
-    const [_key, value] = entry;
-    return typeof value === "string";
-  });
-  if (values.length !== Object.keys(record).length) return void 0;
-  return Object.fromEntries(values);
-}
 function parseExecutor(input) {
   const record = readRecord(input);
   if (!record) return void 0;
-  const kind = readString(record.kind);
+  const kind = readNonEmptyString(record.kind);
   if (!kind) return void 0;
   if (kind === "exec") {
     const command = readString(record.command);
@@ -122,13 +117,13 @@ function parseExecutor(input) {
 function parseFunctionSpec(input, fallbackName) {
   const record = readRecord(input);
   if (!record) return null;
-  const name = readString(record.name) ?? fallbackName;
+  const name = readNonEmptyString(record.name) ?? fallbackName;
   if (!name) return null;
   return {
     name,
     returns: readReturnType(record.returns),
     timeoutMs: readFiniteNumber(record.timeoutMs),
-    description: readString(record.description),
+    description: readNonEmptyString(record.description),
     executor: parseExecutor(record.executor)
   };
 }
@@ -143,43 +138,62 @@ function parseFunctionList(input) {
 function parseMetaRecord(msg) {
   return msg.type === "event" && msg.meta ? readRecord(msg.meta) : null;
 }
-function parseCommandBindMessage(msg) {
-  if (msg.type !== "event" || msg.data !== "command.bind") return null;
-  const meta = parseMetaRecord(msg);
+function parseCommandInvokePayload(input) {
+  const meta = readRecord(input);
   if (!meta) return null;
-  const manifestId = readString(meta.manifestId);
-  if (!manifestId) return null;
+  const callId = readNonEmptyString(meta.callId);
+  const name = readNonEmptyString(meta.name);
+  if (!callId || !name) return null;
   return {
     v: readFiniteNumber(meta.v) ?? COMMAND_PROTOCOL_VERSION,
-    manifestId,
-    functions: parseFunctionList(meta.functions)
+    callId,
+    name,
+    args: readRecord(meta.args) ?? void 0,
+    timeoutMs: readFiniteNumber(meta.timeoutMs)
   };
 }
 function parseCommandInvokeMessage(msg) {
   if (msg.type !== "event" || msg.data !== "command.invoke") return null;
-  const meta = parseMetaRecord(msg);
+  return parseCommandInvokePayload(parseMetaRecord(msg));
+}
+function parseCommandCancelPayload(input) {
+  const meta = readRecord(input);
   if (!meta) return null;
-  const callId = readString(meta.callId);
-  const name = readString(meta.name);
-  if (!callId || !name) return null;
+  const callId = readNonEmptyString(meta.callId);
+  if (!callId) return null;
   return {
     v: readFiniteNumber(meta.v) ?? COMMAND_PROTOCOL_VERSION,
     callId,
-    name,
-    args: readRecord(meta.args) ?? void 0,
-    timeoutMs: readFiniteNumber(meta.timeoutMs)
+    reason: readNonEmptyString(meta.reason)
   };
 }
 function parseCommandCancelMessage(msg) {
   if (msg.type !== "event" || msg.data !== "command.cancel") return null;
-  const meta = parseMetaRecord(msg);
-  if (!meta) return null;
-  const callId = readString(meta.callId);
-  if (!callId) return null;
+  return parseCommandCancelPayload(parseMetaRecord(msg));
+}
+var MANIFEST_SCRIPT_RE = new RegExp(
+  `<script\\s[^>]*type\\s*=\\s*["']${COMMAND_MANIFEST_MIME.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["'][^>]*>([\\s\\S]*?)<\\/script>`,
+  "i"
+);
+function extractManifestFromHtml(html) {
+  const match = MANIFEST_SCRIPT_RE.exec(html);
+  if (!match?.[1]) return null;
+  const raw = match[1].trim();
+  if (raw.length === 0) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const record = parsed;
+  const manifestId = typeof record.manifestId === "string" && record.manifestId.length > 0 ? record.manifestId : `manifest-${Date.now().toString(36)}`;
+  const functions = parseFunctionList(record.functions);
   return {
-    v: readFiniteNumber(meta.v) ?? COMMAND_PROTOCOL_VERSION,
-    callId,
-    reason: readString(meta.reason)
+    v: typeof record.version === "number" ? record.version : 1,
+    manifestId,
+    functions
   };
 }
 
@@ -414,6 +428,10 @@ function createLiveCommandHandler(params) {
   const boundFunctions = /* @__PURE__ */ new Map();
   const running = /* @__PURE__ */ new Map();
   const recentResults = /* @__PURE__ */ new Map();
+  function clearBindings() {
+    boundFunctions.clear();
+    params.debugLog("commands cleared bindings");
+  }
   function buildCancelledResult(callId, startedAt) {
     return {
       v: COMMAND_PROTOCOL_VERSION,
@@ -433,9 +451,6 @@ function createLiveCommandHandler(params) {
     });
     await params.sendCommandMessage(makeCommandResultMessage(payload));
   }
-  async function sendBindResult(payload) {
-    await params.sendCommandMessage(makeCommandBindResultMessage(payload));
-  }
   async function executeFunction(spec, args, abortSignal) {
     const executor = spec.executor;
     if (!executor) {
@@ -498,39 +513,27 @@ function createLiveCommandHandler(params) {
       signal: abortSignal
     });
   }
-  async function handleBind(message) {
-    params.debugLog(
-      `command:bind manifestId=${message.manifestId} functions=[${message.functions.map((f) => f.name).join(", ")}]`
-    );
-    const accepted = [];
-    const rejected = [];
-    boundFunctions.clear();
-    for (const entry of message.functions) {
+  function bindFunctions(functions) {
+    clearBindings();
+    for (const entry of functions) {
       const normalized = normalizeFunctionSpec(entry);
       if (!normalized.executor) {
-        params.debugLog(`command:bind rejected "${normalized.name}" \u2014 missing executor`);
-        rejected.push({
-          name: normalized.name,
-          code: "INVALID_FUNCTION",
-          message: `Function "${normalized.name}" is missing executor definition.`
-        });
+        params.debugLog(`commands skipped "${normalized.name}" \u2014 missing executor`);
         continue;
       }
       boundFunctions.set(normalized.name, normalized);
-      accepted.push({
-        name: normalized.name,
-        returns: normalized.returns ?? "void"
-      });
     }
-    params.debugLog(
-      `command:bind result accepted=[${accepted.map((a) => a.name).join(", ")}] rejected=[${rejected.map((r) => r.name).join(", ")}]`
-    );
-    await sendBindResult({
-      v: COMMAND_PROTOCOL_VERSION,
-      manifestId: message.manifestId,
-      accepted,
-      rejected
-    });
+    params.debugLog(`commands bound=[${[...boundFunctions.keys()].join(", ")}]`);
+  }
+  function bindFromHtml(html) {
+    const manifest = extractManifestFromHtml(html);
+    if (!manifest) {
+      clearBindings();
+      params.debugLog("commands no manifest found in HTML");
+      return;
+    }
+    params.debugLog(`commands manifestId=${manifest.manifestId}`);
+    bindFunctions(manifest.functions);
   }
   async function handleInvoke(message) {
     if (!message) return;
@@ -552,7 +555,7 @@ function createLiveCommandHandler(params) {
     }
     const spec = getSpec(message.name);
     if (!spec) {
-      params.debugLog(`command:invoke COMMAND_NOT_FOUND "${message.name}"`);
+      params.debugLog(`commands invoke COMMAND_NOT_FOUND "${message.name}"`);
       await sendResult({
         v: COMMAND_PROTOCOL_VERSION,
         callId: message.callId,
@@ -566,7 +569,7 @@ function createLiveCommandHandler(params) {
       return;
     }
     params.debugLog(
-      `command:invoke "${message.name}" callId=${message.callId} args=${JSON.stringify(message.args ?? {}).slice(0, 200)}`
+      `commands invoke "${message.name}" callId=${message.callId} args=${JSON.stringify(message.args ?? {}).slice(0, 200)}`
     );
     const abort = new AbortController();
     const startedAt = Date.now();
@@ -576,14 +579,14 @@ function createLiveCommandHandler(params) {
       const active = running.get(message.callId);
       if (abort.signal.aborted || active?.cancelled) {
         params.debugLog(
-          `command:invoke "${message.name}" cancelled after ${Date.now() - startedAt}ms`
+          `commands invoke "${message.name}" cancelled after ${Date.now() - startedAt}ms`
         );
         await sendResult(buildCancelledResult(message.callId, startedAt));
         return;
       }
       const durationMs = Date.now() - startedAt;
       params.debugLog(
-        `command:invoke "${message.name}" ok=${true} duration=${durationMs}ms value=${JSON.stringify(value).slice(0, 200)}`
+        `commands invoke "${message.name}" ok=${true} duration=${durationMs}ms value=${JSON.stringify(value).slice(0, 200)}`
       );
       await sendResult({
         v: COMMAND_PROTOCOL_VERSION,
@@ -600,7 +603,7 @@ function createLiveCommandHandler(params) {
       }
       const durationMs = Date.now() - startedAt;
       params.debugLog(
-        `command:invoke "${message.name}" FAILED duration=${durationMs}ms error=${detail.slice(0, 300)}`
+        `commands invoke "${message.name}" FAILED duration=${durationMs}ms error=${detail.slice(0, 300)}`
       );
       await sendResult({
         v: COMMAND_PROTOCOL_VERSION,
@@ -623,18 +626,13 @@ function createLiveCommandHandler(params) {
   async function handleBridgeMessage(message) {
     if (message.type !== "event") return;
     params.debugLog(
-      `command:message type=${message.type} data=${typeof message.data === "string" ? message.data.slice(0, 120) : "?"}`
+      `commands message type=${message.type} data=${typeof message.data === "string" ? message.data.slice(0, 120) : "?"}`
     );
     for (const [callId, result] of recentResults) {
       if (result.expiresAt <= Date.now()) {
         recentResults.delete(callId);
       }
     }
-    const bind = parseCommandBindMessage(message);
-    if (bind) {
-      await handleBind(bind);
-      return;
-    }
     const invoke = parseCommandInvokeMessage(message);
     if (invoke) {
       await handleInvoke(invoke);
@@ -646,11 +644,18 @@ function createLiveCommandHandler(params) {
     }
   }
   return {
+    bindFromHtml(html) {
+      bindFromHtml(html);
+    },
+    clearBindings() {
+      clearBindings();
+    },
     stop() {
       for (const [callId, active] of running) {
         active.abort.abort();
         running.delete(callId);
       }
+      clearBindings();
     },
     async onMessage(message) {
       await handleBridgeMessage(message).catch((error) => {
@@ -752,14 +757,33 @@ function createAnswer(peer, browserOffer, timeoutMs) {
 }
 
 // src/lib/live-daemon-ipc-handler.ts
+function unreachableIpcRequest(request) {
+  throw new Error(`Unsupported IPC request: ${JSON.stringify(request)}`);
+}
 function createDaemonIpcHandler(params) {
   return async function handleIpcRequest(req) {
     switch (req.method) {
       case "write": {
         const channel = req.params.channel || "chat";
+        const msg = req.params.msg;
+        if (channel === "canvas" && msg.type === "html" && typeof msg.data === "string") {
+          const slug = params.getActiveSlug();
+          if (!slug) return { ok: false, error: "No active live session." };
+          try {
+            await params.apiClient.update({
+              slug,
+              content: msg.data
+            });
+            params.bindCanvasCommands(msg.data);
+            return { ok: true, delivered: true };
+          } catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            params.markError(`failed to persist canvas HTML for "${slug}"`, error);
+            return { ok: false, error: `Canvas update failed: ${errMsg}` };
+          }
+        }
         const readinessError = params.getWriteReadinessError();
         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;
         const maxAttempts = Math.max(1, params.writeAckMaxAttempts);
@@ -809,7 +833,6 @@ function createDaemonIpcHandler(params) {
               continue;
             }
           }
-          params.trackOutboundMessage(channel, msg);
           return { ok: true, delivered: true };
         }
         return {
@@ -855,8 +878,9 @@ function createDaemonIpcHandler(params) {
         params.shutdown();
         return { ok: true };
       }
-      default:
-        return { ok: false, error: `Unknown method: ${req.method}` };
+      default: {
+        return unreachableIpcRequest(req);
+      }
     }
   };
 }
@@ -872,17 +896,22 @@ function createDaemonIpcServer(handler) {
       if (newlineIdx === -1) return;
       const line = data.slice(0, newlineIdx);
       data = data.slice(newlineIdx + 1);
-      let request;
       try {
-        request = JSON.parse(line);
+        const request = parseIpcRequest(JSON.parse(line));
+        if (!request) {
+          conn.write(`${JSON.stringify({ ok: false, error: "Invalid request" })}
+`);
+          return;
+        }
+        handler(request).then((response) => conn.write(`${JSON.stringify(response)}
+`)).catch(
+          (err) => conn.write(`${JSON.stringify({ ok: false, error: errorMessage(err) })}
+`)
+        );
       } catch {
         conn.write(`${JSON.stringify({ ok: false, error: "Invalid JSON" })}
 `);
-        return;
       }
-      handler(request).then((response) => conn.write(`${JSON.stringify(response)}
-`)).catch((err) => conn.write(`${JSON.stringify({ ok: false, error: errorMessage(err) })}
-`));
     });
   });
 }
@@ -937,7 +966,7 @@ var CANVAS_COMMAND_PROTOCOL_GUIDE_MARKDOWN = [
 
 // src/lib/live-daemon-shared.ts
 function buildBridgeInstructions(mode) {
-  if (mode === "claude-code") {
+  if (mode === "claude-code" || mode === "claude-sdk") {
     return {
       replyHint: 'Reply command: pubblue write "<your reply>"',
       canvasHint: "Canvas command: pubblue write -c canvas -f /path/to/file.html",
@@ -974,13 +1003,6 @@ function shouldRecoverForBrowserOfferChange(params) {
   if (!lastAppliedBrowserOffer) return false;
   return incomingBrowserOffer !== lastAppliedBrowserOffer;
 }
-function readCanvasHtmlFromOutbound(params) {
-  if (params.channel !== CHANNELS.CANVAS) return null;
-  if (params.msg.type !== "html") return null;
-  if (typeof params.msg.data !== "string") return null;
-  if (params.msg.data.length === 0) return null;
-  return params.msg.data;
-}
 
 // src/lib/live-daemon-signaling.ts
 import { ConvexClient } from "convex/browser";
@@ -990,6 +1012,9 @@ import { makeFunctionReference } from "convex/server";
 function decideSignalingUpdate(params) {
   const { live, activeSlug, lastAppliedBrowserOffer, lastBrowserCandidateCount } = params;
   if (!live) {
+    if (activeSlug !== null || lastAppliedBrowserOffer !== null || lastBrowserCandidateCount > 0) {
+      return { type: "clear-live", nextBrowserCandidateCount: 0 };
+    }
     return { type: "noop", nextBrowserCandidateCount: lastBrowserCandidateCount };
   }
   if (live.browserOffer && !live.agentAnswer) {
@@ -1020,33 +1045,13 @@ function decideSignalingUpdate(params) {
 }
 
 // src/lib/live-daemon-signaling.ts
-var LIVE_SIGNAL_QUERY = makeFunctionReference("pubs:getLiveForAgentByApiKey");
+var LIVE_SIGNAL_QUERY = makeFunctionReference("pubs:getLive");
 function parseLiveSnapshot(result) {
-  if (result === null || result === void 0) return null;
-  if (typeof result !== "object") {
+  const live = parseLiveInfo(result);
+  if (result !== null && result !== void 0 && live === null) {
     throw new Error("Invalid signaling snapshot: expected object or null");
   }
-  const live = result;
-  if (typeof live.slug !== "string") throw new Error("Invalid signaling snapshot: missing slug");
-  if (!Array.isArray(live.browserCandidates)) {
-    throw new Error("Invalid signaling snapshot: missing browserCandidates");
-  }
-  if (!Array.isArray(live.agentCandidates)) {
-    throw new Error("Invalid signaling snapshot: missing agentCandidates");
-  }
-  if (typeof live.createdAt !== "number" || typeof live.expiresAt !== "number") {
-    throw new Error("Invalid signaling snapshot: missing timestamps");
-  }
-  return {
-    slug: live.slug,
-    status: live.status,
-    browserOffer: live.browserOffer,
-    agentAnswer: live.agentAnswer,
-    browserCandidates: live.browserCandidates,
-    agentCandidates: live.agentCandidates,
-    createdAt: live.createdAt,
-    expiresAt: live.expiresAt
-  };
+  return live;
 }
 function createSignalingController(params) {
   const {
@@ -1060,7 +1065,8 @@ function createSignalingController(params) {
     getLastBrowserCandidateCount,
     setLastBrowserCandidateCount,
     onRecover,
-    onApplyBrowserCandidates
+    onApplyBrowserCandidates,
+    onClearLive
   } = params;
   let signalingClient = null;
   let signalingUnsubscribe = null;
@@ -1103,6 +1109,10 @@ function createSignalingController(params) {
       await onRecover(decision.slug, decision.browserOffer);
       return;
     }
+    if (decision.type === "clear-live") {
+      await onClearLive();
+      return;
+    }
     if (decision.type === "apply-browser-candidates") {
       await onApplyBrowserCandidates(decision.candidatePayloads);
     }
@@ -1203,9 +1213,6 @@ async function startDaemon(config) {
   let pendingInboundBinaryMeta = /* @__PURE__ */ new Map();
   let inboundStreams = /* @__PURE__ */ new Map();
   let seenInboundMessageKeys = /* @__PURE__ */ new Set();
-  let lastCanvasSnapshot = null;
-  let lastPersistedCanvasSnapshot = null;
-  let persistCanvasQueue = Promise.resolve();
   let heartbeatTimer = null;
   let localCandidateInterval = null;
   let localCandidateStopTimer = null;
@@ -1222,14 +1229,10 @@ async function startDaemon(config) {
     markError,
     sendCommandMessage: async (msg) => {
       if (!isLiveConnected()) return false;
-      const sent = await sendOutboundMessageWithAck(CHANNELS.COMMAND, msg, {
+      return sendOutboundMessageWithAck(CHANNELS.COMMAND, msg, {
         context: 'command outbound on "command"',
         maxAttempts: OUTBOUND_SEND_MAX_ATTEMPTS
       });
-      if (sent) {
-        trackOutboundMessage(CHANNELS.COMMAND, msg);
-      }
-      return sent;
     }
   });
   function debugLog(message, error) {
@@ -1318,64 +1321,23 @@ async function startDaemon(config) {
     runHealthCheck();
   }
   function appendBufferedMessage(entry) {
-    if (entry.channel === CHANNELS.CANVAS || entry.channel === CHANNELS.COMMAND) return;
+    if (entry.channel === CHANNELS.COMMAND) return;
     buffer.messages.push(entry);
     if (buffer.messages.length > MAX_BUFFERED_MESSAGES) {
       buffer.messages.splice(0, buffer.messages.length - MAX_BUFFERED_MESSAGES);
     }
   }
-  function getActiveCanvasSnapshot() {
-    if (!activeSlug || !lastCanvasSnapshot) return null;
-    if (lastCanvasSnapshot.slug !== activeSlug) return null;
-    return lastCanvasSnapshot;
-  }
-  function isSameCanvasSnapshot(a, b) {
-    if (!a || !b) return false;
-    return a.slug === b.slug && a.html === b.html;
-  }
-  function queuePersistCanvasSnapshot(snapshot, reason) {
-    if (!snapshot) return Promise.resolve();
-    if (isSameCanvasSnapshot(lastPersistedCanvasSnapshot, snapshot)) return Promise.resolve();
-    persistCanvasQueue = persistCanvasQueue.then(async () => {
-      if (isSameCanvasSnapshot(lastPersistedCanvasSnapshot, snapshot)) return;
-      try {
-        await apiClient2.update({
-          slug: snapshot.slug,
-          content: snapshot.html,
-          filename: "live-canvas.html"
-        });
-        lastPersistedCanvasSnapshot = snapshot;
-        debugLog(`persisted latest canvas for "${snapshot.slug}" (${reason})`);
-      } catch (error) {
-        markError(`failed to persist latest canvas for "${snapshot.slug}" (${reason})`, error);
-        if (!debugEnabled) {
-          console.error(
-            `[pubblue-agent] failed to persist latest canvas for "${snapshot.slug}" (${reason}): ${errorMessage(error)}`
-          );
-        }
-      }
-    });
-    return persistCanvasQueue;
-  }
-  function trackOutboundMessage(channel, msg) {
-    const html = readCanvasHtmlFromOutbound({ channel, msg });
-    if (!html || !activeSlug) return;
-    lastCanvasSnapshot = { slug: activeSlug, html };
-  }
   function handleConnectionClosed(reason) {
-    void queuePersistCanvasSnapshot(getActiveCanvasSnapshot(), reason);
-    const hadConnection = browserConnected || bridgePrimed;
-    browserConnected = false;
-    bridgePrimed = false;
-    bridgePriming = null;
-    if (bridgeAbort) {
-      bridgeAbort.abort();
-      bridgeAbort = null;
-    }
-    if (!hadConnection) return;
-    buffer.messages = [];
-    failPendingAcks();
-    stopPingPong();
+    debugLog(`connection closed: ${reason}`);
+    const hadSession = browserConnected || bridgePrimed || activeSlug !== null;
+    if (!hadSession) return;
+    activeSlug = null;
+    commandHandler.stop();
+    resetNegotiationState();
+    closeCurrentPeer();
+    void stopBridge().catch((error) => {
+      markError("failed to stop bridge after connection closed", error);
+    });
   }
   function emitDeliveryStatus(params) {
     if (!params.messageId || params.channel === CONTROL_CHANNEL) return;
@@ -1599,7 +1561,7 @@ async function startDaemon(config) {
     if (!peer) throw new Error("PeerConnection not initialized");
     const existing = channels.get(name);
     if (existing) return existing;
-    const dc = peer.createDataChannel(name, { ordered: true });
+    const dc = peer.createDataChannel(name, ORDERED_DATA_CHANNEL_OPTIONS);
     setupChannel(name, dc);
     return dc;
   }
@@ -1692,7 +1654,7 @@ async function startDaemon(config) {
   }
   function createPeer() {
     const nextPeer = new ndc.PeerConnection("agent", {
-      iceServers: ["stun:stun.l.google.com:19302", "stun:stun1.l.google.com:19302"]
+      iceServers: [...WEBRTC_STUN_URLS]
     });
     peer = nextPeer;
     channels = /* @__PURE__ */ new Map();
@@ -1738,6 +1700,15 @@ async function startDaemon(config) {
     inboundStreams.clear();
     seenInboundMessageKeys.clear();
   }
+  async function clearActiveLiveSession(reason) {
+    const slug = activeSlug;
+    debugLog(`clearing active live session: ${reason}${slug ? ` (${slug})` : ""}`);
+    activeSlug = null;
+    await stopBridge();
+    commandHandler.stop();
+    closeCurrentPeer();
+    resetNegotiationState();
+  }
   function startLocalCandidateFlush(slug) {
     clearLocalCandidateTimers();
     localCandidateInterval = setInterval(async () => {
@@ -1756,14 +1727,8 @@ async function startDaemon(config) {
     if (recovering) return;
     recovering = true;
     try {
-      const previousCanvasSnapshot = getActiveCanvasSnapshot();
-      if (previousCanvasSnapshot && previousCanvasSnapshot.slug !== slug) {
-        void queuePersistCanvasSnapshot(previousCanvasSnapshot, `session-switch:${slug}`);
-      }
-      await stopBridge();
-      closeCurrentPeer();
+      await clearActiveLiveSession("incoming-live-recovery");
       createPeer();
-      resetNegotiationState();
       if (!peer) throw new Error("PeerConnection not initialized");
       const answer = await createAnswer(peer, browserOffer, OFFER_TIMEOUT_MS);
       lastAppliedBrowserOffer = browserOffer;
@@ -1802,7 +1767,10 @@ async function startDaemon(config) {
       lastBrowserCandidateCount = count;
     },
     onRecover: handleIncomingLive,
-    onApplyBrowserCandidates: applyBrowserCandidates
+    onApplyBrowserCandidates: applyBrowserCandidates,
+    onClearLive: async () => {
+      await clearActiveLiveSession("signaling-cleared");
+    }
   });
   if (fs.existsSync(socketPath2)) {
     let stale = true;
@@ -1834,6 +1802,8 @@ async function startDaemon(config) {
     }
   }, HEARTBEAT_INTERVAL_MS);
   const handleIpcRequest = createDaemonIpcHandler({
+    apiClient: apiClient2,
+    bindCanvasCommands: (html) => commandHandler.bindFromHtml(html),
     getConnected: () => isLiveConnected(),
     getSignalingConnected: () => {
       const state = signaling.status();
@@ -1854,7 +1824,6 @@ async function startDaemon(config) {
     waitForChannelOpen,
     waitForDeliveryAck,
     settlePendingAck,
-    trackOutboundMessage,
     markError,
     shutdown: () => {
       void shutdown();
@@ -1874,28 +1843,24 @@ async function startDaemon(config) {
   signaling.start();
   async function sendOnChannel(channel, msg) {
     if (stopped || !isLiveConnected()) return false;
-    const sent = await sendOutboundMessageWithAck(channel, msg, {
+    return sendOutboundMessageWithAck(channel, msg, {
       context: `bridge outbound on "${channel}"`,
       maxAttempts: OUTBOUND_SEND_MAX_ATTEMPTS
     });
-    if (sent) {
-      trackOutboundMessage(channel, msg);
-    }
-    return sent;
   }
   async function buildInitialSessionBriefing(params) {
     const pub = await apiClient2.get(params.slug);
     const content = typeof pub.content === "string" ? pub.content : "";
+    if (content.length > 0) commandHandler.bindFromHtml(content);
+    else commandHandler.clearBindings();
     const canvasContentFilePath = content.length > 0 ? writeLiveSessionContentFile({
       slug: params.slug,
-      contentType: pub.contentType,
       content
     }) : void 0;
     return buildSessionBriefing(
       params.slug,
       {
         title: pub.title,
-        contentType: pub.contentType,
         isPublic: pub.isPublic,
         canvasContentFilePath
       },
@@ -1928,7 +1893,7 @@ async function startDaemon(config) {
       debugLog,
       instructions
     };
-    const runner = config.bridgeMode === "claude-code" ? await createClaudeCodeBridgeRunner(bridgeConfig, abort.signal) : await createOpenClawBridgeRunner(bridgeConfig);
+    const runner = config.bridgeMode === "claude-sdk" ? await createClaudeSdkBridgeRunner(bridgeConfig, abort.signal) : config.bridgeMode === "claude-code" ? await createClaudeCodeBridgeRunner(bridgeConfig, abort.signal) : await createOpenClawBridgeRunner(bridgeConfig);
     if (stopped || activeSlug !== slug || abort.signal.aborted) {
       await runner.stop();
       return;
@@ -1974,7 +1939,6 @@ async function startDaemon(config) {
     clearHeartbeatTimer();
     stopPingPong();
     await signaling.stop();
-    await queuePersistCanvasSnapshot(getActiveCanvasSnapshot(), "daemon-shutdown");
     try {
       await apiClient2.goOffline({ daemonSessionId });
     } catch (error) {