pubblue 0.7.0 → 0.7.2

package/dist/{chunk-5ODXW2EM.js → chunk-5LI2HLKX.js}

@@ -33,6 +33,59 @@ function toCliFailure(error) {
   };
 }
 
+// ../shared/protocol-runtime-core.ts
+function readRecord(input) {
+  return input && typeof input === "object" && !Array.isArray(input) ? input : null;
+}
+function readString(input) {
+  return typeof input === "string" ? input : void 0;
+}
+function readNonEmptyString(input) {
+  return typeof input === "string" && input.trim().length > 0 ? input : void 0;
+}
+function readFiniteNumber(input) {
+  return typeof input === "number" && Number.isFinite(input) ? input : void 0;
+}
+function readBoolean(input) {
+  return typeof input === "boolean" ? input : void 0;
+}
+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 entries = Object.entries(record);
+  const values = entries.filter((entry) => typeof entry[1] === "string");
+  if (values.length !== entries.length) return void 0;
+  return Object.fromEntries(values);
+}
+
+// ../shared/live-api-core.ts
+function parseLiveInfo(input) {
+  if (input === null || input === void 0) return null;
+  const record = readRecord(input);
+  if (!record) return null;
+  const slug = readNonEmptyString(record.slug);
+  const browserCandidates = readStringArray(record.browserCandidates);
+  const agentCandidates = readStringArray(record.agentCandidates);
+  const createdAt = readFiniteNumber(record.createdAt);
+  if (!slug || !browserCandidates || !agentCandidates || createdAt === void 0) {
+    return null;
+  }
+  return {
+    slug,
+    status: readString(record.status),
+    browserOffer: readString(record.browserOffer),
+    agentAnswer: readString(record.agentAnswer),
+    browserCandidates,
+    agentCandidates,
+    createdAt
+  };
+}
+
 // src/lib/api.ts
 var PubApiError = class extends Error {
   constructor(message, status, retryAfterSeconds) {
@@ -163,7 +216,7 @@ var PubApiClient = class {
     });
   }
   // -- Agent live management ------------------------------------------------
-  async getPendingLive(daemonSessionId) {
+  async getLive(daemonSessionId) {
     const params = new URLSearchParams();
     if (daemonSessionId) {
       params.set("daemonSessionId", daemonSessionId);
@@ -171,7 +224,11 @@ var PubApiClient = class {
     const query = params.toString();
     const path5 = query ? `/api/v1/agent/live?${query}` : "/api/v1/agent/live";
     const data = await this.request(path5);
-    return data.live;
+    const live = parseLiveInfo(data.live);
+    if (data.live !== null && data.live !== void 0 && live === null) {
+      throw new PubApiError("Invalid live snapshot response from server.", 502);
+    }
+    return live;
   }
   async signalAnswer(opts) {
     await this.request("/api/v1/agent/live/signal", {
@@ -198,20 +255,21 @@ var PubApiClient = class {
   async deleteBotToken() {
     await this.request("/api/v1/agent/telegram-bot", { method: "DELETE" });
   }
-  // -- Per-slug live info ---------------------------------------------------
-  async getLive(slug) {
-    const data = await this.request(
-      `/api/v1/pubs/${encodeURIComponent(slug)}/live`
-    );
-    return data.live;
-  }
 };
 
 // ../shared/bridge-protocol-core.ts
+var BRIDGE_MESSAGE_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "html",
+  "binary",
+  "stream-start",
+  "stream-data",
+  "stream-end",
+  "event"
+]);
 var CONTROL_CHANNEL = "_control";
 var CHANNELS = {
   CHAT: "chat",
-  CANVAS: "canvas",
   RENDER_ERROR: "render-error",
   AUDIO: "audio",
   MEDIA: "media",
@@ -228,13 +286,51 @@ function generateMessageId() {
 function encodeMessage(msg) {
   return JSON.stringify(msg);
 }
+function parseBridgeMessageMeta(input) {
+  if (input === void 0) return void 0;
+  const record = readRecord(input);
+  if (!record) return null;
+  const meta = { ...record };
+  const knownStringKeys = ["mime", "filename", "title"];
+  for (const key of knownStringKeys) {
+    if (record[key] === void 0) continue;
+    const value = readString(record[key]);
+    if (value === void 0) return null;
+    meta[key] = value;
+  }
+  const knownNumberKeys = ["sampleRate", "width", "height", "size"];
+  for (const key of knownNumberKeys) {
+    if (record[key] === void 0) continue;
+    const value = readFiniteNumber(record[key]);
+    if (value === void 0) return null;
+    meta[key] = value;
+  }
+  return meta;
+}
+function parseBridgeMessage(input) {
+  const record = readRecord(input);
+  if (!record) return null;
+  const id = readNonEmptyString(record.id);
+  const type = readString(record.type);
+  if (!id || !type || !BRIDGE_MESSAGE_TYPES.has(type)) {
+    return null;
+  }
+  const data = record.data === void 0 ? void 0 : readString(record.data);
+  if (record.data !== void 0 && data === void 0) {
+    return null;
+  }
+  const meta = parseBridgeMessageMeta(record.meta);
+  if (meta === null) return null;
+  return {
+    id,
+    type,
+    data,
+    meta
+  };
+}
 function decodeMessage(raw) {
   try {
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed.id === "string" && typeof parsed.type === "string") {
-      return parsed;
-    }
-    return null;
+    return parseBridgeMessage(JSON.parse(raw));
   } catch (_error) {
     return null;
   }
@@ -327,7 +423,6 @@ function buildSessionBriefing(slug, ctx, instructions) {
     "## Pub Context"
   ];
   if (ctx.title) lines.push(`- Title: ${ctx.title}`);
-  if (ctx.contentType) lines.push(`- Content type: ${ctx.contentType}`);
   if (ctx.isPublic !== void 0)
     lines.push(`- Visibility: ${ctx.isPublic ? "public" : "private"}`);
   if (ctx.canvasContentFilePath) {
@@ -861,7 +956,10 @@ async function runClaudeSdkBridgeStartupProbe(env = process.env) {
         try {
           fs2.appendFileSync(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `);
-        } catch {
+        } catch (error) {
+          if (process.env.PUBBLUE_DEBUG === "1") {
+            console.warn(`Warning: failed to append SDK probe log: ${errorMessage(error)}`);
+          }
         }
       };
       appendLog(`probe start socket=${socketPath}`);
@@ -903,6 +1001,7 @@ async function createClaudeSdkBridgeRunner(config, abortSignal) {
   if (!sdk) {
     throw new Error("Claude Agent SDK is not importable.");
   }
+  const loadedSdk = sdk;
   const { model, claudePath, allowedTools, sdkEnv } = buildSdkSessionOptions(env);
   const appendSystemPrompt = buildAppendSystemPrompt(config.instructions.systemPrompt, env);
   let sessionId;
@@ -923,7 +1022,7 @@ async function createClaudeSdkBridgeRunner(config, abortSignal) {
   }
   const canvasReminderEvery = resolveCanvasReminderEvery();
   function createSession() {
-    const session2 = sdk.unstable_v2_createSession({
+    const session2 = loadedSdk.unstable_v2_createSession({
       model,
       pathToClaudeCodeExecutable: claudePath,
       env: {
@@ -940,7 +1039,7 @@ async function createClaudeSdkBridgeRunner(config, abortSignal) {
     for await (const msg of session2.stream()) {
       if (stopped) break;
       if (msg.type === "assistant") {
-        debugLog(`sdk assistant message received`);
+        debugLog("sdk assistant message received");
       } else if (msg.type === "result") {
         if ("session_id" in msg && typeof msg.session_id === "string") {
           sessionId = msg.session_id;
@@ -971,7 +1070,8 @@ async function createClaudeSdkBridgeRunner(config, abortSignal) {
       sessionRecreations += 1;
       try {
         activeSession?.close();
-      } catch {
+      } catch (error2) {
+        debugLog(`failed to close previous SDK session: ${errorMessage(error2)}`, error2);
       }
       const newSession = createSession();
       await sendAndStream(newSession, sessionBriefing);
@@ -984,12 +1084,12 @@ async function createClaudeSdkBridgeRunner(config, abortSignal) {
   debugLog("session briefing delivered via SDK");
   const queue = createBridgeEntryQueue({
     onEntry: async (entry) => {
+      const includeCanvasReminder = shouldIncludeCanvasPolicyReminder(
+        forwardedMessageCount + 1,
+        canvasReminderEvery
+      );
       const chat = readTextChatMessage(entry);
       if (chat) {
-        const includeCanvasReminder = shouldIncludeCanvasPolicyReminder(
-          forwardedMessageCount + 1,
-          canvasReminderEvery
-        );
         const prompt = buildInboundPrompt(slug, chat, includeCanvasReminder, config.instructions);
         await deliverWithRecovery(prompt);
         forwardedMessageCount += 1;
@@ -1010,35 +1110,15 @@ async function createClaudeSdkBridgeRunner(config, abortSignal) {
           messageId: entry.msg.id,
           stage: "confirmed"
         });
-        return;
-      }
-      if (entry.msg.type === "binary" || entry.msg.type === "stream-start" || entry.msg.type === "stream-end") {
-        const streamId = typeof entry.msg.meta?.streamId === "string" ? entry.msg.meta.streamId : void 0;
-        if (entry.msg.type === "binary" && streamId) return;
-        const deliveryMessageId = entry.msg.type === "stream-end" && streamId ? streamId : entry.msg.id;
-        config.onDeliveryUpdate?.({
-          channel: entry.channel,
-          messageId: deliveryMessageId,
-          stage: "failed",
-          error: "Attachments are not supported in Claude SDK bridge mode."
-        });
-        if (entry.msg.type !== "stream-end") {
-          void sendMessage(CHANNELS.CHAT, {
-            id: generateMessageId(),
-            type: "text",
-            data: "Attachments are not supported in Claude SDK bridge mode."
-          });
-        }
       }
     },
     onError: (error, entry) => {
       const message = errorMessage(error);
       lastError = message;
       debugLog(`bridge entry processing failed: ${message}`, error);
-      const deliveryMessageId = entry.msg.type === "stream-end" && typeof entry.msg.meta?.streamId === "string" ? entry.msg.meta.streamId : entry.msg.id;
       config.onDeliveryUpdate?.({
         channel: entry.channel,
-        messageId: deliveryMessageId,
+        messageId: entry.msg.id,
         stage: "failed",
         error: message
       });
@@ -1049,18 +1129,13 @@ async function createClaudeSdkBridgeRunner(config, abortSignal) {
       });
     }
   });
-  debugLog(`claude-sdk bridge runner started (path=${claudePath})`);
   return {
     enqueue: (entries) => queue.enqueue(entries),
     async stop() {
       if (stopped) return;
       stopped = true;
-      try {
-        activeSession?.close();
-      } catch {
-      }
-      activeSession = null;
       await queue.stop();
+      activeSession?.close();
     },
     status() {
       return {
@@ -1824,19 +1899,12 @@ function sanitizeSlugForFilename(slug) {
   const sanitized = slug.trim().replace(/[^a-zA-Z0-9._-]/g, "-");
   return sanitized.length > 0 ? sanitized : "live";
 }
-function resolveSessionContentExtension(contentType) {
-  if (contentType === "html") return "html";
-  if (contentType === "markdown") return "md";
-  if (contentType === "text") return "txt";
-  return "txt";
-}
-function liveSessionContentPath(slug, contentType, rootDir) {
+function liveSessionContentPath(slug, rootDir) {
   const safeSlug = sanitizeSlugForFilename(slug);
-  const ext = resolveSessionContentExtension(contentType);
-  return path4.join(rootDir ?? liveInfoDir(), `${safeSlug}.session-content.${ext}`);
+  return path4.join(rootDir ?? liveInfoDir(), `${safeSlug}.session-content.html`);
 }
 function writeLiveSessionContentFile(params) {
-  const filePath = liveSessionContentPath(params.slug, params.contentType, params.rootDir);
+  const filePath = liveSessionContentPath(params.slug, params.rootDir);
   fs4.mkdirSync(path4.dirname(filePath), { recursive: true });
   fs4.writeFileSync(filePath, params.content, "utf-8");
   return filePath;
@@ -1878,10 +1946,152 @@ function readLogTail(logPath, maxChars = 4e3) {
   }
 }
 
+// src/lib/live-ipc-protocol.ts
+function parseBufferedBridgeMessage(input) {
+  const record = readRecord(input);
+  if (!record) return null;
+  const channel = readString(record.channel);
+  const msg = parseBridgeMessage(record.msg);
+  if (!channel || !msg) return null;
+  return {
+    channel,
+    msg,
+    timestamp: readFiniteNumber(record.timestamp)
+  };
+}
+function parseBridgeStatus(input) {
+  if (input === null) return null;
+  const record = readRecord(input);
+  if (!record) return null;
+  const running = readBoolean(record.running);
+  const forwardedMessages = readFiniteNumber(record.forwardedMessages);
+  if (running === void 0 || forwardedMessages === void 0) return null;
+  const sessionSourceRaw = record.sessionSource === void 0 ? void 0 : readString(record.sessionSource);
+  const sessionSource = sessionSourceRaw === void 0 || sessionSourceRaw === "env" || sessionSourceRaw === "thread-canonical" || sessionSourceRaw === "thread-legacy" || sessionSourceRaw === "main-fallback" ? sessionSourceRaw : null;
+  if (sessionSource === null) return null;
+  return {
+    running,
+    sessionId: readString(record.sessionId),
+    sessionKey: readString(record.sessionKey),
+    sessionSource,
+    lastError: readString(record.lastError),
+    forwardedMessages
+  };
+}
+function parseIpcRequest(input) {
+  const record = readRecord(input);
+  if (!record) return null;
+  const method = readString(record.method);
+  const params = readRecord(record.params);
+  if (!method || !params) return null;
+  if (method === "write") {
+    const msg = parseBridgeMessage(params.msg);
+    if (!msg) return null;
+    const channel = params.channel === void 0 ? void 0 : readString(params.channel);
+    const binaryBase64 = params.binaryBase64 === void 0 ? void 0 : readString(params.binaryBase64);
+    if (params.channel !== void 0 && channel === void 0) return null;
+    if (params.binaryBase64 !== void 0 && binaryBase64 === void 0) return null;
+    return {
+      method,
+      params: {
+        channel,
+        msg,
+        binaryBase64
+      }
+    };
+  }
+  if (method === "read") {
+    const channel = params.channel === void 0 ? void 0 : readString(params.channel);
+    if (params.channel !== void 0 && channel === void 0) return null;
+    return { method, params: { channel } };
+  }
+  if (method === "channels" || method === "status" || method === "active-slug" || method === "close") {
+    return { method, params: {} };
+  }
+  return null;
+}
+function parseIpcResponse(method, input) {
+  const record = readRecord(input);
+  if (!record) return null;
+  const ok = readBoolean(record.ok);
+  if (ok === void 0) return null;
+  const error = record.error === void 0 ? void 0 : readString(record.error);
+  if (record.error !== void 0 && error === void 0) return null;
+  if (!ok) return { ok, error };
+  if (method === "write") {
+    const delivered = record.delivered === void 0 ? void 0 : readBoolean(record.delivered);
+    if (record.delivered !== void 0 && delivered === void 0) return null;
+    return { ok, delivered, error };
+  }
+  if (method === "read") {
+    if (record.messages === void 0) return { ok, error };
+    if (!Array.isArray(record.messages)) return null;
+    const messages = record.messages.map((entry) => parseBufferedBridgeMessage(entry)).filter((entry) => entry !== null);
+    if (messages.length !== record.messages.length) return null;
+    return { ok, messages, error };
+  }
+  if (method === "channels") {
+    if (record.channels === void 0) return { ok, error };
+    if (!Array.isArray(record.channels)) return null;
+    const channels = record.channels.map((entry) => {
+      const channelRecord = readRecord(entry);
+      if (!channelRecord) return null;
+      const name = readString(channelRecord.name);
+      const direction = readString(channelRecord.direction);
+      if (!name || !direction) return null;
+      return { name, direction };
+    }).filter((entry) => entry !== null);
+    if (channels.length !== record.channels.length) return null;
+    return { ok, channels, error };
+  }
+  if (method === "status") {
+    const connected = readBoolean(record.connected);
+    const signalingConnected = record.signalingConnected === null ? null : record.signalingConnected === void 0 ? void 0 : readBoolean(record.signalingConnected);
+    const activeSlug = record.activeSlug === null ? null : record.activeSlug === void 0 ? void 0 : readString(record.activeSlug);
+    const uptime = readFiniteNumber(record.uptime);
+    const bufferedMessages = readFiniteNumber(record.bufferedMessages);
+    const lastError = record.lastError === null ? null : record.lastError === void 0 ? void 0 : readString(record.lastError);
+    const bridgeMode = record.bridgeMode === null ? null : record.bridgeMode === void 0 ? void 0 : readString(record.bridgeMode);
+    if (connected === void 0 || signalingConnected === void 0 || activeSlug === void 0 || uptime === void 0 || !Array.isArray(record.channels) || bufferedMessages === void 0 || lastError === void 0 || bridgeMode === void 0) {
+      return null;
+    }
+    const channels = record.channels.filter((entry) => typeof entry === "string");
+    if (channels.length !== record.channels.length) return null;
+    const bridge = record.bridge === void 0 ? null : parseBridgeStatus(record.bridge);
+    if (record.bridge !== void 0 && bridge === null && record.bridge !== null) return null;
+    return {
+      ok,
+      connected,
+      signalingConnected,
+      activeSlug,
+      uptime,
+      channels,
+      bufferedMessages,
+      lastError,
+      bridgeMode,
+      bridge,
+      error
+    };
+  }
+  if (method === "active-slug") {
+    const slug = record.slug === null ? null : record.slug === void 0 ? void 0 : readString(record.slug);
+    if (record.slug !== void 0 && slug === void 0) return null;
+    return { ok, slug, error };
+  }
+  return { ok, error };
+}
+
 export {
   failCli,
   errorMessage,
   toCliFailure,
+  readRecord,
+  readString,
+  readNonEmptyString,
+  readFiniteNumber,
+  readStringArray,
+  readStringRecord,
+  parseLiveInfo,
   PubApiError,
   PubApiClient,
   resolveOpenClawHome,
@@ -1902,6 +2112,8 @@ export {
   makeDeliveryReceiptMessage,
   parseAckMessage,
   shouldAcknowledgeMessage,
+  parseIpcRequest,
+  parseIpcResponse,
   buildSessionBriefing,
   isClaudeCodeAvailableInEnv,
   resolveClaudeCodePath,

package/dist/index.js

@@ -18,6 +18,7 @@ import {
   liveInfoDir,
   liveInfoPath,
   liveLogPath,
+  parseIpcResponse,
   readConfig,
   readLogTail,
   resolveOpenClawHome,
@@ -28,7 +29,7 @@ import {
   saveConfig,
   toCliFailure,
   writeLatestCliVersion
-} from "./chunk-5ODXW2EM.js";
+} from "./chunk-5LI2HLKX.js";
 
 // src/program.ts
 import { Command } from "commander";
@@ -63,10 +64,7 @@ function readFile(filePath) {
   if (!fs.existsSync(resolved)) {
     failCli(`File not found: ${resolved}`);
   }
-  return {
-    content: fs.readFileSync(resolved, "utf-8"),
-    basename: path.basename(resolved)
-  };
+  return fs.readFileSync(resolved, "utf-8");
 }
 
 // src/commands/configure/io.ts
@@ -430,7 +428,12 @@ async function ipcCall(socketPath, request) {
         const line = data.slice(0, newlineIdx);
         client.end();
         try {
-          finish(() => resolve3(JSON.parse(line)));
+          const parsed = parseIpcResponse(request.method, JSON.parse(line));
+          if (!parsed) {
+            finish(() => reject(new Error("Invalid response from daemon")));
+            return;
+          }
+          finish(() => resolve3(parsed));
         } catch {
           finish(() => reject(new Error("Invalid response from daemon")));
         }
@@ -1054,7 +1057,7 @@ async function runStartPreflight(opts) {
   if (runtimeConfig) {
     const client = new PubApiClient(runtimeConfig.baseUrl, runtimeConfig.apiKey);
     try {
-      await client.getPendingLive();
+      await client.getLive();
       passed.push({
         label: "api",
         detail: `authenticated and reachable at ${runtimeConfig.baseUrl}`
@@ -1097,7 +1100,7 @@ async function runStartPreflight(opts) {
 // package.json
 var package_default = {
   name: "pubblue",
-  version: "0.7.0",
+  version: "0.7.2",
   description: "CLI for publishing and visualizing AI-agent output via pub.blue",
   type: "module",
   bin: {
@@ -1449,7 +1452,6 @@ function registerDoctorCommand(program2) {
       for (const required of [
         CONTROL_CHANNEL,
         CHANNELS.CHAT,
-        CHANNELS.CANVAS,
         CHANNELS.RENDER_ERROR,
         CHANNELS.COMMAND
       ]) {
@@ -1458,16 +1460,20 @@ function registerDoctorCommand(program2) {
         }
       }
       console.log("Daemon/channel check: OK");
-      const live = await apiClient.getLive(slug).catch(
+      const live = await apiClient.getLive().catch(
         (error) => fail(`failed to fetch live info from API: ${formatApiError(error)}`)
       );
-      if (live.status !== "active") {
-        fail(`API reports live is not active (status: ${live.status})`);
+      const activeLive = live ?? fail("API reports no active live session.");
+      if (activeLive.slug !== slug) {
+        fail(`API reports active live for "${activeLive.slug}" instead of "${slug}".`);
+      }
+      if (activeLive.status !== "active") {
+        fail(`API reports live is not active (status: ${activeLive.status})`);
       }
-      if (typeof live.browserOffer !== "string" || live.browserOffer.length === 0) {
+      if (typeof activeLive.browserOffer !== "string" || activeLive.browserOffer.length === 0) {
         fail("browser offer was not published.");
       }
-      if (typeof live.agentAnswer !== "string" || live.agentAnswer.length === 0) {
+      if (typeof activeLive.agentAnswer !== "string" || activeLive.agentAnswer.length === 0) {
         fail("agent answer was not published.");
       }
       console.log("API/signaling check: OK");
@@ -1523,7 +1529,7 @@ function registerDoctorCommand(program2) {
         };
         const canvasResponse = await ipcCall(socketPath, {
           method: "write",
-          params: { channel: CHANNELS.CANVAS, msg: canvasMsg }
+          params: { channel: "canvas", msg: canvasMsg }
         });
         if (!canvasResponse.ok) {
           fail(`canvas ping failed: ${String(canvasResponse.error || "unknown write error")}`);
@@ -1537,29 +1543,19 @@ function registerDoctorCommand(program2) {
 
 // src/commands/pubs.ts
 function registerPubCommands(program2) {
-  program2.command("create").description("Create a new pub").argument("[file]", "Path to the file (reads stdin if omitted)").option("--slug <slug>", "Custom slug for the URL").option("--title <title>", "Title for the pub").option("--public", "Make the pub public").option("--private", "Make the pub private (default)").action(
+  program2.command("create").description("Create a new pub").argument("[file]", "Path to the file (reads stdin if omitted)").option("--slug <slug>", "Custom slug for the URL").option("--title <title>", "Title for the pub").action(
     async (fileArg, opts) => {
       const client = createClient();
       let content;
-      let filename;
       if (fileArg) {
-        const file = readFile(fileArg);
-        content = file.content;
-        filename = file.basename;
+        content = readFile(fileArg);
       } 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: resolvedVisibility ?? false
+        slug: opts.slug
       });
       console.log(`Created: ${result.url}`);
       const tmaUrl = getTelegramMiniAppUrl(result.slug);
@@ -1574,7 +1570,6 @@ function registerPubCommands(program2) {
       return;
     }
     console.log(`  Slug:    ${pub.slug}`);
-    if (pub.contentType) console.log(`  Type:    ${pub.contentType}`);
     if (pub.title) console.log(`  Title:   ${pub.title}`);
     console.log(`  Status:  ${formatVisibility(pub.isPublic)}`);
     console.log(`  Created: ${new Date(pub.createdAt).toLocaleDateString()}`);
@@ -1589,11 +1584,8 @@ function registerPubCommands(program2) {
     async (slug, opts) => {
       const client = createClient();
       let content;
-      let filename;
       if (opts.file) {
-        const file = readFile(opts.file);
-        content = file.content;
-        filename = file.basename;
+        content = readFile(opts.file);
       }
       const isPublic = resolveVisibilityFlags({
         public: opts.public,
@@ -1603,7 +1595,6 @@ function registerPubCommands(program2) {
       const result = await client.update({
         slug,
         content,
-        filename,
         title: opts.title,
         isPublic,
         newSlug: opts.slug
@@ -1622,10 +1613,9 @@ function registerPubCommands(program2) {
     }
     for (const pub of pubs) {
       const date = new Date(pub.createdAt).toLocaleDateString();
-      const contentLabel = pub.contentType ? `[${pub.contentType}]` : "[no content]";
       const sessionLabel = pub.live?.status === "active" ? " [live]" : "";
       console.log(
-        `  ${pub.slug}  ${contentLabel}  ${formatVisibility(pub.isPublic)}  ${date}${sessionLabel}`
+        `  ${pub.slug}  ${formatVisibility(pub.isPublic)}  ${date}${sessionLabel}`
       );
     }
   });

package/dist/live-daemon-entry.js

@@ -15,12 +15,20 @@ import {
   makeDeliveryReceiptMessage,
   makeEventMessage,
   parseAckMessage,
+  parseIpcRequest,
+  parseLiveInfo,
+  readFiniteNumber,
   readLatestCliVersion,
+  readNonEmptyString,
+  readRecord,
+  readString,
+  readStringArray,
+  readStringRecord,
   resolveClaudeCodePath,
   resolveOpenClawRuntime,
   shouldAcknowledgeMessage,
   writeLiveSessionContentFile
-} from "./chunk-5ODXW2EM.js";
+} from "./chunk-5LI2HLKX.js";
 
 // src/lib/live-daemon.ts
 import { randomUUID } from "crypto";
@@ -34,48 +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;
+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);
@@ -120,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)
   };
 }
@@ -141,12 +138,11 @@ function parseFunctionList(input) {
 function parseMetaRecord(msg) {
   return msg.type === "event" && msg.meta ? readRecord(msg.meta) : null;
 }
-function parseCommandInvokeMessage(msg) {
-  if (msg.type !== "event" || msg.data !== "command.invoke") return null;
-  const meta = parseMetaRecord(msg);
+function parseCommandInvokePayload(input) {
+  const meta = readRecord(input);
   if (!meta) return null;
-  const callId = readString(meta.callId);
-  const name = readString(meta.name);
+  const callId = readNonEmptyString(meta.callId);
+  const name = readNonEmptyString(meta.name);
   if (!callId || !name) return null;
   return {
     v: readFiniteNumber(meta.v) ?? COMMAND_PROTOCOL_VERSION,
@@ -156,19 +152,29 @@ function parseCommandInvokeMessage(msg) {
     timeoutMs: readFiniteNumber(meta.timeoutMs)
   };
 }
-function parseCommandCancelMessage(msg) {
-  if (msg.type !== "event" || msg.data !== "command.cancel") return null;
-  const meta = parseMetaRecord(msg);
+function parseCommandInvokeMessage(msg) {
+  if (msg.type !== "event" || msg.data !== "command.invoke") return null;
+  return parseCommandInvokePayload(parseMetaRecord(msg));
+}
+function parseCommandCancelPayload(input) {
+  const meta = readRecord(input);
   if (!meta) return null;
-  const callId = readString(meta.callId);
+  const callId = readNonEmptyString(meta.callId);
   if (!callId) return null;
   return {
     v: readFiniteNumber(meta.v) ?? COMMAND_PROTOCOL_VERSION,
     callId,
-    reason: readString(meta.reason)
+    reason: readNonEmptyString(meta.reason)
   };
 }
-var MANIFEST_SCRIPT_RE = /<script\s[^>]*type\s*=\s*["']application\/pubblue-command-manifest\+json["'][^>]*>([\s\S]*?)<\/script>/i;
+function parseCommandCancelMessage(msg) {
+  if (msg.type !== "event" || msg.data !== "command.cancel") 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;
@@ -422,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,
@@ -504,7 +514,7 @@ function createLiveCommandHandler(params) {
     });
   }
   function bindFunctions(functions) {
-    boundFunctions.clear();
+    clearBindings();
     for (const entry of functions) {
       const normalized = normalizeFunctionSpec(entry);
       if (!normalized.executor) {
@@ -518,8 +528,8 @@ function createLiveCommandHandler(params) {
   function bindFromHtml(html) {
     const manifest = extractManifestFromHtml(html);
     if (!manifest) {
-      boundFunctions.clear();
-      params.debugLog("commands no manifest found in HTML, cleared bindings");
+      clearBindings();
+      params.debugLog("commands no manifest found in HTML");
       return;
     }
     params.debugLog(`commands manifestId=${manifest.manifestId}`);
@@ -637,11 +647,15 @@ function createLiveCommandHandler(params) {
     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) => {
@@ -743,20 +757,22 @@ 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 === CHANNELS.CANVAS && msg.type === "html" && typeof msg.data === "string") {
+        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,
-              filename: "live-canvas.html"
+              content: msg.data
             });
             params.bindCanvasCommands(msg.data);
             return { ok: true, delivered: true };
@@ -862,8 +878,9 @@ function createDaemonIpcHandler(params) {
         params.shutdown();
         return { ok: true };
       }
-      default:
-        return { ok: false, error: `Unknown method: ${req.method}` };
+      default: {
+        return unreachableIpcRequest(req);
+      }
     }
   };
 }
@@ -879,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) })}
-`));
     });
   });
 }
@@ -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,32 +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") {
-    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
-  };
+  return live;
 }
 function createSignalingController(params) {
   const {
@@ -1059,7 +1065,8 @@ function createSignalingController(params) {
     getLastBrowserCandidateCount,
     setLastBrowserCandidateCount,
     onRecover,
-    onApplyBrowserCandidates
+    onApplyBrowserCandidates,
+    onClearLive
   } = params;
   let signalingClient = null;
   let signalingUnsubscribe = null;
@@ -1102,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);
     }
@@ -1202,7 +1213,6 @@ async function startDaemon(config) {
   let pendingInboundBinaryMeta = /* @__PURE__ */ new Map();
   let inboundStreams = /* @__PURE__ */ new Map();
   let seenInboundMessageKeys = /* @__PURE__ */ new Set();
-  let commandProcessingQueue = Promise.resolve();
   let heartbeatTimer = null;
   let localCandidateInterval = null;
   let localCandidateStopTimer = null;
@@ -1311,7 +1321,7 @@ 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);
@@ -1319,18 +1329,15 @@ async function startDaemon(config) {
   }
   function handleConnectionClosed(reason) {
     debugLog(`connection closed: ${reason}`);
-    const hadConnection = browserConnected || bridgePrimed;
-    browserConnected = false;
-    bridgePrimed = false;
-    bridgePriming = null;
-    if (bridgeAbort) {
-      bridgeAbort.abort();
-      bridgeAbort = null;
-    }
-    if (!hadConnection) return;
-    buffer.messages = [];
-    failPendingAcks();
-    stopPingPong();
+    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;
@@ -1421,9 +1428,7 @@ async function startDaemon(config) {
           queueAck(msg.id, name);
         }
         if (name === CHANNELS.COMMAND) {
-          commandProcessingQueue = commandProcessingQueue.then(() => commandHandler.onMessage(msg)).catch((error) => {
-            markError("command message processing failed", error);
-          });
+          void commandHandler.onMessage(msg);
           return;
         }
         appendBufferedMessage({ channel: name, msg, timestamp: Date.now() });
@@ -1556,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;
   }
@@ -1649,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();
@@ -1695,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 () => {
@@ -1713,10 +1727,8 @@ async function startDaemon(config) {
     if (recovering) return;
     recovering = true;
     try {
-      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;
@@ -1755,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;
@@ -1836,19 +1851,16 @@ async function startDaemon(config) {
   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);
-    }
+    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
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pubblue",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "CLI for publishing and visualizing AI-agent output via pub.blue",
   "type": "module",
   "bin": {