pubblue 0.6.9 → 0.7.2

package/dist/{chunk-JSX5KHV3.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) {
@@ -56,8 +109,8 @@ var PubApiClient = class {
   getApiKey() {
     return this.apiKey;
   }
-  async request(path4, options = {}) {
-    const url = new URL(path4, this.baseUrl);
+  async request(path5, options = {}) {
+    const url = new URL(path5, this.baseUrl);
     const res = await fetch(url, {
       ...options,
       headers: {
@@ -163,15 +216,19 @@ var PubApiClient = class {
     });
   }
   // -- Agent live management ------------------------------------------------
-  async getPendingLive(daemonSessionId) {
+  async getLive(daemonSessionId) {
     const params = new URLSearchParams();
     if (daemonSessionId) {
       params.set("daemonSessionId", daemonSessionId);
     }
     const query = params.toString();
-    const path4 = query ? `/api/v1/agent/live?${query}` : "/api/v1/agent/live";
-    const data = await this.request(path4);
-    return data.live;
+    const path5 = query ? `/api/v1/agent/live?${query}` : "/api/v1/agent/live";
+    const data = await this.request(path5);
+    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", {
@@ -185,8 +242,8 @@ var PubApiClient = class {
       params.set("daemonSessionId", daemonSessionId);
     }
     const query = params.toString();
-    const path4 = query ? `/api/v1/agent/live?${query}` : "/api/v1/agent/live";
-    await this.request(path4, { method: "DELETE" });
+    const path5 = query ? `/api/v1/agent/live?${query}` : "/api/v1/agent/live";
+    await this.request(path5, { method: "DELETE" });
   }
   // -- Telegram bot token ---------------------------------------------------
   async uploadBotToken(opts) {
@@ -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) {
@@ -809,25 +904,269 @@ async function createClaudeCodeBridgeRunner(config, abortSignal) {
   };
 }
 
+// src/lib/live-bridge-claude-sdk.ts
+import * as fs2 from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
+async function tryImportSdk() {
+  try {
+    return await import("./sdk-IV5ZYS3G.js");
+  } catch {
+    return null;
+  }
+}
+function isClaudeSdkAvailableInEnv(env) {
+  return isClaudeCodeAvailableInEnv(env);
+}
+async function isClaudeSdkImportable() {
+  return await tryImportSdk() !== null;
+}
+function buildSdkSessionOptions(env = process.env) {
+  const model = env.CLAUDE_CODE_MODEL?.trim() || "claude-sonnet-4-6";
+  const claudePath = resolveClaudeCodePath(env);
+  const allowedToolsRaw = env.CLAUDE_CODE_ALLOWED_TOOLS?.trim();
+  const allowedTools = allowedToolsRaw ? allowedToolsRaw.split(",").map((t) => t.trim()).filter(Boolean) : void 0;
+  const sdkEnv = { ...env };
+  delete sdkEnv.CLAUDECODE;
+  return { model, claudePath, allowedTools, sdkEnv };
+}
+function buildAppendSystemPrompt(bridgeSystemPrompt, env = process.env) {
+  const userSystemPrompt = env.CLAUDE_CODE_APPEND_SYSTEM_PROMPT?.trim();
+  const effective = [bridgeSystemPrompt, userSystemPrompt].filter(Boolean).join("\n\n");
+  return effective.length > 0 ? effective : void 0;
+}
+async function runClaudeSdkBridgeStartupProbe(env = process.env) {
+  const { model, claudePath, allowedTools } = buildSdkSessionOptions(env);
+  const cwd = env.CLAUDE_CODE_CWD?.trim() || env.PUBBLUE_PROJECT_ROOT || void 0;
+  const sdk = await tryImportSdk();
+  if (!sdk) {
+    throw new Error(
+      "Claude Agent SDK (@anthropic-ai/claude-agent-sdk) is not importable. Install it and retry."
+    );
+  }
+  await runAgentWritePongProbe({
+    label: "Claude SDK",
+    baseEnv: env,
+    execute: async (probeEnv) => {
+      const probeEnvClean = { ...probeEnv };
+      delete probeEnvClean.CLAUDECODE;
+      const socketPath = probeEnv.PUBBLUE_AGENT_SOCKET ?? "";
+      const logPath = path2.join(os2.tmpdir(), "pubblue-sdk-probe.log");
+      const appendLog = (line) => {
+        try {
+          fs2.appendFileSync(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`);
+        } catch (error) {
+          if (process.env.PUBBLUE_DEBUG === "1") {
+            console.warn(`Warning: failed to append SDK probe log: ${errorMessage(error)}`);
+          }
+        }
+      };
+      appendLog(`probe start socket=${socketPath}`);
+      const prompt = [
+        "This is a startup connectivity probe.",
+        "Run this exact shell command now:",
+        `PUBBLUE_AGENT_SOCKET=${socketPath} pubblue write "pong"`,
+        "Do not explain. Just execute it."
+      ].join("\n");
+      const q = sdk.query({
+        prompt,
+        options: {
+          model,
+          pathToClaudeCodeExecutable: claudePath,
+          env: probeEnvClean,
+          allowedTools,
+          cwd: os2.tmpdir(),
+          maxTurns: 2,
+          persistSession: false,
+          canUseTool: async (toolName, input) => {
+            appendLog(`canUseTool: tool=${toolName}`);
+            return { behavior: "allow", updatedInput: input };
+          }
+        }
+      });
+      for await (const msg of q) {
+        appendLog(`msg: type=${msg.type} ${JSON.stringify(msg).slice(0, 300)}`);
+      }
+      appendLog("probe stream completed");
+    }
+  });
+  return { claudePath, cwd };
+}
+var MAX_SESSION_RECREATIONS = 2;
+async function createClaudeSdkBridgeRunner(config, abortSignal) {
+  const { slug, sendMessage, debugLog, sessionBriefing } = config;
+  const env = process.env;
+  const sdk = await tryImportSdk();
+  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;
+  let forwardedMessageCount = 0;
+  let lastError;
+  let stopped = abortSignal?.aborted ?? false;
+  let sessionRecreations = 0;
+  let activeSession = null;
+  if (abortSignal) {
+    abortSignal.addEventListener(
+      "abort",
+      () => {
+        stopped = true;
+        activeSession?.close();
+      },
+      { once: true }
+    );
+  }
+  const canvasReminderEvery = resolveCanvasReminderEvery();
+  function createSession() {
+    const session2 = loadedSdk.unstable_v2_createSession({
+      model,
+      pathToClaudeCodeExecutable: claudePath,
+      env: {
+        ...sdkEnv,
+        ...appendSystemPrompt ? { CLAUDE_CODE_APPEND_SYSTEM_PROMPT: appendSystemPrompt } : {}
+      },
+      allowedTools,
+      canUseTool: async (_tool, input) => ({ behavior: "allow", updatedInput: input })
+    });
+    activeSession = session2;
+    return session2;
+  }
+  async function consumeStream(session2) {
+    for await (const msg of session2.stream()) {
+      if (stopped) break;
+      if (msg.type === "assistant") {
+        debugLog("sdk assistant message received");
+      } else if (msg.type === "result") {
+        if ("session_id" in msg && typeof msg.session_id === "string") {
+          sessionId = msg.session_id;
+          debugLog(`captured session_id: ${sessionId}`);
+        }
+        if (msg.subtype !== "success") {
+          throw new Error(`Claude SDK result error: ${msg.subtype}`);
+        }
+      }
+    }
+  }
+  async function sendAndStream(session2, prompt) {
+    await session2.send(prompt);
+    await consumeStream(session2);
+  }
+  async function deliverWithRecovery(prompt) {
+    if (stopped) return;
+    try {
+      if (!activeSession) throw new Error("session not initialized");
+      await sendAndStream(activeSession, prompt);
+    } catch (error) {
+      const msg = errorMessage(error);
+      debugLog(`session error: ${msg}`, error);
+      if (stopped || sessionRecreations >= MAX_SESSION_RECREATIONS) {
+        throw error;
+      }
+      debugLog(`recreating session (attempt ${sessionRecreations + 1}/${MAX_SESSION_RECREATIONS})`);
+      sessionRecreations += 1;
+      try {
+        activeSession?.close();
+      } catch (error2) {
+        debugLog(`failed to close previous SDK session: ${errorMessage(error2)}`, error2);
+      }
+      const newSession = createSession();
+      await sendAndStream(newSession, sessionBriefing);
+      debugLog("session briefing re-delivered after recovery");
+      await sendAndStream(newSession, prompt);
+    }
+  }
+  const session = createSession();
+  await sendAndStream(session, sessionBriefing);
+  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 prompt = buildInboundPrompt(slug, chat, includeCanvasReminder, config.instructions);
+        await deliverWithRecovery(prompt);
+        forwardedMessageCount += 1;
+        config.onDeliveryUpdate?.({
+          channel: entry.channel,
+          messageId: entry.msg.id,
+          stage: "confirmed"
+        });
+        return;
+      }
+      const renderError = readRenderErrorMessage(entry);
+      if (renderError) {
+        const prompt = buildRenderErrorPrompt(slug, renderError, config.instructions);
+        await deliverWithRecovery(prompt);
+        forwardedMessageCount += 1;
+        config.onDeliveryUpdate?.({
+          channel: entry.channel,
+          messageId: entry.msg.id,
+          stage: "confirmed"
+        });
+      }
+    },
+    onError: (error, entry) => {
+      const message = errorMessage(error);
+      lastError = message;
+      debugLog(`bridge entry processing failed: ${message}`, error);
+      config.onDeliveryUpdate?.({
+        channel: entry.channel,
+        messageId: entry.msg.id,
+        stage: "failed",
+        error: message
+      });
+      void sendMessage(CHANNELS.CHAT, {
+        id: generateMessageId(),
+        type: "text",
+        data: `Bridge error: ${message}`
+      });
+    }
+  });
+  return {
+    enqueue: (entries) => queue.enqueue(entries),
+    async stop() {
+      if (stopped) return;
+      stopped = true;
+      await queue.stop();
+      activeSession?.close();
+    },
+    status() {
+      return {
+        running: !stopped,
+        sessionId,
+        lastError,
+        forwardedMessages: forwardedMessageCount
+      };
+    }
+  };
+}
+
 // src/lib/live-bridge-openclaw.ts
 import { execFile } from "child_process";
 import { existsSync as existsSync5 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { promisify } from "util";
 
 // src/lib/live-bridge-openclaw-attachments.ts
 import { createHash } from "crypto";
 import { mkdirSync, renameSync, unlinkSync as unlinkSync2, writeFileSync } from "fs";
-import { basename, extname, join as join4 } from "path";
+import { basename, extname, join as join5 } from "path";
 
 // src/lib/live-bridge-openclaw-session.ts
 import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // src/lib/openclaw-paths.ts
 import { existsSync as existsSync3, readFileSync } from "fs";
 import { homedir } from "os";
-import { dirname, isAbsolute, join as join2, resolve } from "path";
+import { dirname, isAbsolute, join as join3, resolve } from "path";
 function trimToUndefined(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : void 0;
@@ -846,7 +1185,7 @@ function resolveBaseHome(env) {
 function expandHomePrefix(input, home) {
   if (input === "~") return home;
   if (input.startsWith("~/") || input.startsWith("~\\")) {
-    return join2(home, input.slice(2));
+    return join3(home, input.slice(2));
   }
   return input;
 }
@@ -864,12 +1203,12 @@ function resolveOpenClawHome(env = process.env) {
 function resolveOpenClawStateDir(env = process.env) {
   const configured = trimToUndefined(env.OPENCLAW_STATE_DIR);
   if (configured) return resolvePathFromInput(configured, env);
-  return join2(resolveOpenClawHome(env), ".openclaw");
+  return join3(resolveOpenClawHome(env), ".openclaw");
 }
 function resolveOpenClawConfigPath(env = process.env) {
   const configured = trimToUndefined(env.OPENCLAW_CONFIG_PATH);
   if (configured) return resolvePathFromInput(configured, env);
-  return join2(resolveOpenClawStateDir(env), "openclaw.json");
+  return join3(resolveOpenClawStateDir(env), "openclaw.json");
 }
 function readWorkspaceFromOpenClawConfig(configPath) {
   if (!existsSync3(configPath)) return null;
@@ -899,13 +1238,13 @@ function resolveOpenClawWorkspaceDir(env = process.env) {
   const configPath = resolveOpenClawConfigPath(env);
   const fromConfig = readWorkspaceFromOpenClawConfig(configPath);
   if (fromConfig) return resolveWorkspacePath(fromConfig, configPath, env);
-  return join2(resolveOpenClawStateDir(env), "workspace");
+  return join3(resolveOpenClawStateDir(env), "workspace");
 }
 
 // src/lib/live-bridge-openclaw-session.ts
 var OPENCLAW_MAIN_SESSION_KEY = "agent:main:main";
 function resolveOpenClawSessionsPath(env = process.env) {
-  return join3(resolveOpenClawStateDir(env), "agents", "main", "sessions", "sessions.json");
+  return join4(resolveOpenClawStateDir(env), "agents", "main", "sessions", "sessions.json");
 }
 function buildThreadCandidateKeys(threadId) {
   const trimmed = threadId?.trim();
@@ -981,7 +1320,7 @@ var DEFAULT_ATTACHMENT_MAX_BYTES = 5 * 1024 * 1024;
 function resolveAttachmentRootDir() {
   const configured = process.env.OPENCLAW_ATTACHMENT_DIR?.trim();
   if (configured) return configured;
-  return join4(resolveOpenClawStateDir(), "pubblue-inbox");
+  return join5(resolveOpenClawStateDir(), "pubblue-inbox");
 }
 function resolveAttachmentMaxBytes() {
   const raw = Number.parseInt(process.env.OPENCLAW_ATTACHMENT_MAX_BYTES ?? "", 10);
@@ -1022,12 +1361,12 @@ function resolveAttachmentFilename(params) {
 }
 function ensureDirectoryWritable(dirPath) {
   mkdirSync(dirPath, { recursive: true });
-  const probe = join4(dirPath, `.bridge-writecheck-${process.pid}-${Date.now()}`);
+  const probe = join5(dirPath, `.bridge-writecheck-${process.pid}-${Date.now()}`);
   writeFileSync(probe, "ok\n", { mode: 384 });
   unlinkSync2(probe);
 }
 function stageAttachment(params) {
-  const slugDir = join4(params.attachmentRoot, sanitizeFilename(params.slug));
+  const slugDir = join5(params.attachmentRoot, sanitizeFilename(params.slug));
   ensureDirectoryWritable(slugDir);
   const mime = (params.mime || "application/octet-stream").trim();
   const resolvedName = resolveAttachmentFilename({
@@ -1037,7 +1376,7 @@ function stageAttachment(params) {
     mime
   });
   const collisionSafeName = `${Date.now()}-${sanitizeFilename(params.messageId)}-${resolvedName}`;
-  const targetPath = join4(slugDir, collisionSafeName);
+  const targetPath = join5(slugDir, collisionSafeName);
   const tempPath = `${targetPath}.tmp-${process.pid}`;
   writeFileSync(tempPath, params.bytes, { mode: 384 });
   renameSync(tempPath, targetPath);
@@ -1219,9 +1558,9 @@ function getOpenClawDiscoveryPaths(env = process.env) {
   return [
     .../* @__PURE__ */ new Set([
       "/app/dist/index.js",
-      join5(home, "openclaw", "dist", "index.js"),
-      join5(stateDir, "openclaw"),
-      join5(home, ".openclaw", "openclaw"),
+      join6(home, "openclaw", "dist", "index.js"),
+      join6(stateDir, "openclaw"),
+      join6(home, ".openclaw", "openclaw"),
       "/usr/local/bin/openclaw",
       "/opt/homebrew/bin/openclaw"
     ])
@@ -1258,7 +1597,7 @@ function resolveOpenClawPath(env = process.env) {
       "OpenClaw executable was not found.",
       "Configure it with: pubblue configure --set openclaw.path=/absolute/path/to/openclaw",
       "Or set OPENCLAW_PATH in environment.",
-      "Checked: " + discoveryPaths.join(", ")
+      `Checked: ${discoveryPaths.join(", ")}`
     ].join(" ")
   );
 }
@@ -1486,35 +1825,35 @@ async function createOpenClawBridgeRunner(config) {
 }
 
 // src/lib/live-runtime/daemon-files.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 
 // src/lib/config.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 var DEFAULT_BASE_URL = "https://silent-guanaco-514.convex.site";
 function getConfigDir(homeDir) {
   const explicit = process.env.PUBBLUE_CONFIG_DIR?.trim();
   if (explicit) return explicit;
   if (homeDir) {
-    return path2.join(path2.resolve(homeDir), ".openclaw", "pubblue");
+    return path3.join(path3.resolve(homeDir), ".openclaw", "pubblue");
   }
-  return path2.join(resolveOpenClawStateDir(), "pubblue");
+  return path3.join(resolveOpenClawStateDir(), "pubblue");
 }
 function getConfigPath(homeDir) {
   const dir = getConfigDir(homeDir);
-  fs2.mkdirSync(dir, { recursive: true, mode: 448 });
-  return path2.join(dir, "config.json");
+  fs3.mkdirSync(dir, { recursive: true, mode: 448 });
+  return path3.join(dir, "config.json");
 }
 function readConfig(homeDir) {
   const configPath = getConfigPath(homeDir);
-  if (!fs2.existsSync(configPath)) return null;
-  const raw = fs2.readFileSync(configPath, "utf-8");
+  if (!fs3.existsSync(configPath)) return null;
+  const raw = fs3.readFileSync(configPath, "utf-8");
   return JSON.parse(raw);
 }
 function saveConfig(config, homeDir) {
   const configPath = getConfigPath(homeDir);
-  fs2.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+  fs3.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
 `, {
     mode: 384
   });
@@ -1546,39 +1885,32 @@ function getTelegramMiniAppUrl(slug) {
 
 // src/lib/live-runtime/daemon-files.ts
 function liveInfoDir() {
-  const dir = path3.join(getConfigDir(), "lives");
-  fs3.mkdirSync(dir, { recursive: true });
+  const dir = path4.join(getConfigDir(), "lives");
+  fs4.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function liveInfoPath(slug) {
-  return path3.join(liveInfoDir(), `${slug}.json`);
+  return path4.join(liveInfoDir(), `${slug}.json`);
 }
 function liveLogPath(slug) {
-  return path3.join(liveInfoDir(), `${slug}.log`);
+  return path4.join(liveInfoDir(), `${slug}.log`);
 }
 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 path3.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);
-  fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
-  fs3.writeFileSync(filePath, params.content, "utf-8");
+  const filePath = liveSessionContentPath(params.slug, params.rootDir);
+  fs4.mkdirSync(path4.dirname(filePath), { recursive: true });
+  fs4.writeFileSync(filePath, params.content, "utf-8");
   return filePath;
 }
 function latestCliVersionPath() {
-  return path3.join(liveInfoDir(), "cli-version.txt");
+  return path4.join(liveInfoDir(), "cli-version.txt");
 }
 function isMissingPathError(error) {
   if (typeof error !== "object" || error === null || !("code" in error)) return false;
@@ -1588,7 +1920,7 @@ function isMissingPathError(error) {
 function readLatestCliVersion(versionPath) {
   const resolved = versionPath || latestCliVersionPath();
   try {
-    const value = fs3.readFileSync(resolved, "utf-8").trim();
+    const value = fs4.readFileSync(resolved, "utf-8").trim();
     return value.length === 0 ? null : value;
   } catch (error) {
     if (isMissingPathError(error)) return null;
@@ -1599,13 +1931,13 @@ function writeLatestCliVersion(version, versionPath) {
   const trimmed = version.trim();
   if (trimmed.length === 0) return;
   const resolved = versionPath || latestCliVersionPath();
-  const dir = path3.dirname(resolved);
-  fs3.mkdirSync(dir, { recursive: true });
-  fs3.writeFileSync(resolved, trimmed, "utf-8");
+  const dir = path4.dirname(resolved);
+  fs4.mkdirSync(dir, { recursive: true });
+  fs4.writeFileSync(resolved, trimmed, "utf-8");
 }
 function readLogTail(logPath, maxChars = 4e3) {
   try {
-    const content = fs3.readFileSync(logPath, "utf-8");
+    const content = fs4.readFileSync(logPath, "utf-8");
     if (content.length <= maxChars) return content;
     return content.slice(-maxChars);
   } catch (error) {
@@ -1614,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,
@@ -1638,12 +2112,18 @@ export {
   makeDeliveryReceiptMessage,
   parseAckMessage,
   shouldAcknowledgeMessage,
+  parseIpcRequest,
+  parseIpcResponse,
   buildSessionBriefing,
   isClaudeCodeAvailableInEnv,
   resolveClaudeCodePath,
   buildClaudeArgs,
   runClaudeCodeBridgeStartupProbe,
   createClaudeCodeBridgeRunner,
+  isClaudeSdkAvailableInEnv,
+  isClaudeSdkImportable,
+  runClaudeSdkBridgeStartupProbe,
+  createClaudeSdkBridgeRunner,
   isOpenClawAvailable,
   resolveOpenClawRuntime,
   runOpenClawBridgeStartupProbe,