pubblue 0.6.4 → 0.6.9

package/dist/index.js

@@ -2,102 +2,37 @@
 import {
   CHANNELS,
   CONTROL_CHANNEL,
+  DEFAULT_BASE_URL,
   PubApiClient,
-  TEXT_FILE_EXTENSIONS,
-  buildBridgeProcessEnv,
-  buildDaemonForkStdio,
-  ensureNodeDatachannelAvailable,
+  PubApiError,
   errorMessage,
   failCli,
-  formatApiError,
   generateMessageId,
-  getAgentSocketPath,
-  getFollowReadDelayMs,
-  getMimeType,
-  ipcCall,
-  isDaemonRunning,
+  getConfig,
+  getConfigDir,
+  getTelegramMiniAppUrl,
+  isClaudeCodeAvailableInEnv,
+  isOpenClawAvailable,
+  liveInfoDir,
   liveInfoPath,
   liveLogPath,
-  messageContainsPong,
-  parsePositiveIntegerOption,
+  readConfig,
   readLogTail,
-  resolveActiveSlug,
-  resolveBridgeMode,
-  stopOtherDaemons,
+  resolveOpenClawHome,
+  resolveOpenClawWorkspaceDir,
+  runClaudeCodeBridgeStartupProbe,
+  runOpenClawBridgeStartupProbe,
+  saveConfig,
   toCliFailure,
-  waitForDaemonReady,
   writeLatestCliVersion
-} from "./chunk-JXEXE632.js";
+} from "./chunk-JSX5KHV3.js";
 
 // src/program.ts
 import { Command } from "commander";
 
-// src/commands/configure.ts
-import { createInterface } from "readline/promises";
-
-// src/lib/config.ts
+// src/commands/shared.ts
 import * as fs from "fs";
-import * as os from "os";
 import * as path from "path";
-var DEFAULT_BASE_URL = "https://silent-guanaco-514.convex.site";
-function getConfigDir(homeDir) {
-  const home = homeDir || os.homedir();
-  return path.join(home, ".config", "pubblue");
-}
-function getConfigPath(homeDir) {
-  const dir = getConfigDir(homeDir);
-  fs.mkdirSync(dir, { recursive: true, mode: 448 });
-  try {
-    fs.chmodSync(dir, 448);
-  } catch {
-  }
-  return path.join(dir, "config.json");
-}
-function readConfig(homeDir) {
-  const configPath = getConfigPath(homeDir);
-  if (!fs.existsSync(configPath)) return null;
-  const raw = fs.readFileSync(configPath, "utf-8");
-  return JSON.parse(raw);
-}
-function saveConfig(config, homeDir) {
-  const configPath = getConfigPath(homeDir);
-  fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
-`, {
-    mode: 384
-  });
-  try {
-    fs.chmodSync(configPath, 384);
-  } catch {
-  }
-}
-function getConfig(homeDir) {
-  const envKey = process.env.PUBBLUE_API_KEY;
-  const envUrl = process.env.PUBBLUE_URL;
-  const baseUrl = envUrl || DEFAULT_BASE_URL;
-  const saved = readConfig(homeDir);
-  if (envKey) {
-    return { apiKey: envKey, baseUrl, bridge: saved?.bridge };
-  }
-  if (!saved) {
-    throw new Error(
-      "Not configured. Run `pubblue configure` or set PUBBLUE_API_KEY environment variable."
-    );
-  }
-  return {
-    apiKey: saved.apiKey,
-    baseUrl,
-    bridge: saved.bridge
-  };
-}
-function getTelegramMiniAppUrl(slug) {
-  const saved = readConfig();
-  if (!saved?.telegram?.botUsername) return null;
-  return `https://t.me/${saved.telegram.botUsername}?startapp=${slug}`;
-}
-
-// src/commands/shared.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
 function createClient(configOverride) {
   const config = configOverride || getConfig();
   return new PubApiClient(config.baseUrl, config.apiKey);
@@ -121,49 +56,48 @@ function resolveVisibilityFlags(opts) {
   return void 0;
 }
 function readFile(filePath) {
-  const resolved = path2.resolve(filePath);
-  if (!fs2.existsSync(resolved)) {
+  const resolved = path.resolve(filePath);
+  if (!fs.existsSync(resolved)) {
     failCli(`File not found: ${resolved}`);
   }
   return {
-    content: fs2.readFileSync(resolved, "utf-8"),
-    basename: path2.basename(resolved)
+    content: fs.readFileSync(resolved, "utf-8"),
+    basename: path.basename(resolved)
   };
 }
 
-// src/commands/configure.ts
-function readApiKeyFromPrompt() {
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return rl.question("Enter API key: ").then((answer) => answer.trim()).finally(() => {
-    rl.close();
-  });
-}
-async function resolveConfigureApiKey(opts) {
+// src/commands/configure/io.ts
+function resolveConfigureApiKey(opts) {
   if (opts.apiKey && opts.apiKeyStdin) {
     throw new Error("Use only one of --api-key or --api-key-stdin.");
   }
   if (opts.apiKey) {
-    return opts.apiKey.trim();
+    return Promise.resolve(opts.apiKey.trim());
   }
   if (opts.apiKeyStdin) {
     return readFromStdin();
   }
   const envKey = process.env.PUBBLUE_API_KEY?.trim();
-  if (envKey) return envKey;
-  if (!process.stdin.isTTY || !process.stdout.isTTY) {
-    throw new Error(
-      "No TTY available. Provide --api-key, --api-key-stdin, or PUBBLUE_API_KEY for configure."
-    );
-  }
-  return readApiKeyFromPrompt();
+  if (envKey) return Promise.resolve(envKey);
+  throw new Error(
+    "No API key provided. Use --api-key <KEY>, --api-key-stdin, or set PUBBLUE_API_KEY."
+  );
 }
 function collectValues(value, previous) {
   previous.push(value);
   return previous;
 }
+
+// src/lib/number.ts
+function parsePositiveInteger(raw, label) {
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${label} must be a positive integer. Received: ${raw}`);
+  }
+  return parsed;
+}
+
+// src/commands/configure/schema.ts
 function parseSetInput(raw) {
   const sepIndex = raw.indexOf("=");
   if (sepIndex <= 0 || sepIndex === raw.length - 1) {
@@ -182,119 +116,168 @@ function parseBooleanValue(raw, key) {
     return false;
   throw new Error(`Invalid boolean value for ${key}: ${raw}`);
 }
-function parsePositiveInteger(raw, key) {
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new Error(`${key} must be a positive integer. Received: ${raw}`);
+var CONFIG_KEY_REGISTRY = {
+  "openclaw.path": { target: "bridge", field: "openclawPath", type: "string" },
+  "openclaw.stateDir": { target: "bridge", field: "openclawStateDir", type: "string" },
+  "openclaw.workspace": { target: "bridge", field: "openclawWorkspace", type: "string" },
+  "openclaw.sessionId": { target: "bridge", field: "sessionId", type: "string" },
+  "openclaw.threadId": { target: "bridge", field: "threadId", type: "string" },
+  "openclaw.canvasReminderEvery": {
+    target: "bridge",
+    field: "canvasReminderEvery",
+    type: "integer"
+  },
+  "openclaw.deliver": { target: "bridge", field: "deliver", type: "boolean" },
+  "openclaw.deliverChannel": { target: "bridge", field: "deliverChannel", type: "string" },
+  "openclaw.replyTo": { target: "bridge", field: "replyTo", type: "string" },
+  "openclaw.deliverTimeoutMs": { target: "bridge", field: "deliverTimeoutMs", type: "integer" },
+  "openclaw.attachmentDir": { target: "bridge", field: "attachmentDir", type: "string" },
+  "openclaw.attachmentMaxBytes": { target: "bridge", field: "attachmentMaxBytes", type: "integer" },
+  "claude-code.path": { target: "bridge", field: "claudeCodePath", type: "string" },
+  "claude-code.model": { target: "bridge", field: "claudeCodeModel", type: "string" },
+  "claude-code.allowedTools": { target: "bridge", field: "claudeCodeAllowedTools", type: "string" },
+  "claude-code.appendSystemPrompt": {
+    target: "bridge",
+    field: "claudeCodeAppendSystemPrompt",
+    type: "string",
+    displayAs: "set-only"
+  },
+  "claude-code.maxTurns": { target: "bridge", field: "claudeCodeMaxTurns", type: "integer" },
+  "claude-code.cwd": { target: "bridge", field: "claudeCodeCwd", type: "string" },
+  "command.defaultTimeoutMs": {
+    target: "bridge",
+    field: "commandDefaultTimeoutMs",
+    type: "integer"
+  },
+  "command.maxOutputBytes": {
+    target: "bridge",
+    field: "commandMaxOutputBytes",
+    type: "integer"
+  },
+  "command.maxConcurrent": {
+    target: "bridge",
+    field: "commandMaxConcurrent",
+    type: "integer"
+  },
+  "telegram.botToken": {
+    target: "telegram",
+    field: "botToken",
+    type: "string",
+    cascadeUnset: ["botUsername", "hasMainWebApp"]
   }
-  return parsed;
+};
+var SUPPORTED_KEYS = Object.keys(CONFIG_KEY_REGISTRY);
+function coerceValue(raw, type, key) {
+  if (type === "integer") return parsePositiveInteger(raw, key);
+  if (type === "boolean") return parseBooleanValue(raw, key);
+  return raw;
 }
-var SUPPORTED_KEYS = [
-  "openclaw.path",
-  "openclaw.sessionId",
-  "openclaw.threadId",
-  "openclaw.canvasReminderEvery",
-  "openclaw.deliver",
-  "openclaw.deliverChannel",
-  "openclaw.replyTo",
-  "openclaw.deliverTimeoutMs",
-  "openclaw.attachmentDir",
-  "openclaw.attachmentMaxBytes",
-  "telegram.botToken"
-];
 function applyConfigSet(bridge, telegram, key, value) {
-  switch (key) {
-    case "openclaw.path":
-      bridge.openclawPath = value;
-      return;
-    case "openclaw.sessionId":
-      bridge.sessionId = value;
-      return;
-    case "openclaw.threadId":
-      bridge.threadId = value;
-      return;
-    case "openclaw.canvasReminderEvery":
-      bridge.canvasReminderEvery = parsePositiveInteger(value, key);
-      return;
-    case "openclaw.deliver":
-      bridge.deliver = parseBooleanValue(value, key);
-      return;
-    case "openclaw.deliverChannel":
-      bridge.deliverChannel = value;
-      return;
-    case "openclaw.replyTo":
-      bridge.replyTo = value;
-      return;
-    case "openclaw.deliverTimeoutMs":
-      bridge.deliverTimeoutMs = parsePositiveInteger(value, key);
-      return;
-    case "openclaw.attachmentDir":
-      bridge.attachmentDir = value;
-      return;
-    case "openclaw.attachmentMaxBytes":
-      bridge.attachmentMaxBytes = parsePositiveInteger(value, key);
-      return;
-    case "telegram.botToken":
-      telegram.botToken = value;
-      return;
-    default:
-      throw new Error(
-        [
-          `Unknown config key: ${key}`,
-          "Supported keys:",
-          ...SUPPORTED_KEYS.map((k) => `  ${k}`)
-        ].join("\n")
-      );
+  const def = CONFIG_KEY_REGISTRY[key];
+  if (!def) {
+    throw new Error(
+      [
+        `Unknown config key: ${key}`,
+        "Supported keys:",
+        ...SUPPORTED_KEYS.map((k) => `  ${k}`)
+      ].join("\n")
+    );
+  }
+  const coerced = coerceValue(value, def.type, key);
+  if (def.target === "bridge") {
+    Object.assign(bridge, { [def.field]: coerced });
+  } else {
+    Object.assign(telegram, { [def.field]: coerced });
   }
 }
 function applyConfigUnset(bridge, telegram, key) {
-  switch (key) {
-    case "openclaw.path":
-      delete bridge.openclawPath;
-      return;
-    case "openclaw.sessionId":
-      delete bridge.sessionId;
-      return;
-    case "openclaw.threadId":
-      delete bridge.threadId;
-      return;
-    case "openclaw.canvasReminderEvery":
-      delete bridge.canvasReminderEvery;
-      return;
-    case "openclaw.deliver":
-      delete bridge.deliver;
-      return;
-    case "openclaw.deliverChannel":
-      delete bridge.deliverChannel;
-      return;
-    case "openclaw.replyTo":
-      delete bridge.replyTo;
-      return;
-    case "openclaw.deliverTimeoutMs":
-      delete bridge.deliverTimeoutMs;
-      return;
-    case "openclaw.attachmentDir":
-      delete bridge.attachmentDir;
-      return;
-    case "openclaw.attachmentMaxBytes":
-      delete bridge.attachmentMaxBytes;
-      return;
-    case "telegram.botToken":
-      delete telegram.botToken;
-      delete telegram.botUsername;
-      delete telegram.hasMainWebApp;
-      return;
-    default:
-      throw new Error(`Unknown config key for --unset: ${key}`);
+  const def = CONFIG_KEY_REGISTRY[key];
+  if (!def) {
+    throw new Error(`Unknown config key for --unset: ${key}`);
+  }
+  if (def.target === "bridge") {
+    delete bridge[def.field];
+  } else {
+    delete telegram[def.field];
+    if (def.cascadeUnset) {
+      for (const cascadeField of def.cascadeUnset) {
+        delete telegram[cascadeField];
+      }
+    }
   }
 }
 function hasValues(obj) {
   return Object.values(obj).some((value) => value !== void 0);
 }
+
+// src/commands/configure/render.ts
 function maskSecret(value) {
   if (value.length <= 8) return "********";
   return `${value.slice(0, 4)}...${value.slice(-4)}`;
 }
+function formatFieldValue(value, def) {
+  if (def.displayAs === "set-only") return "(set)";
+  if (def.type === "boolean") return value ? "true" : "false";
+  return String(value);
+}
+function printBridgeStatus(bridge) {
+  if (!hasValues(bridge)) return;
+  console.log("");
+  console.log("Bridge:");
+  for (const [key, def] of Object.entries(CONFIG_KEY_REGISTRY)) {
+    if (def.target !== "bridge") continue;
+    const value = bridge[def.field];
+    if (value === void 0) continue;
+    console.log(`  ${key}: ${formatFieldValue(value, def)}`);
+  }
+}
+function printTelegramStatus(telegram) {
+  if (telegram?.botToken && telegram.botUsername) {
+    console.log(`  Telegram:  @${telegram.botUsername}`);
+    if (!telegram.hasMainWebApp) {
+      console.log(
+        "      Mini App not registered \u2014 deep links open in browser, not inside Telegram."
+      );
+      console.log(
+        `      Fix: @BotFather \u2192 /mybots \u2192 @${telegram.botUsername} \u2192 Bot Settings \u2192 Configure Mini App`
+      );
+      console.log("      Set URL to: https://pub.blue");
+    }
+  } else {
+    console.log("  Telegram:  not configured");
+  }
+}
+function printSetupInstructions(saved) {
+  const needsApiKey = !saved?.apiKey;
+  const needsTelegram = !saved?.telegram?.botUsername;
+  if (!needsApiKey && !needsTelegram) return;
+  console.log("");
+  if (needsApiKey) {
+    console.log("  pubblue configure --api-key <KEY>");
+    console.log("    Get your key at https://pub.blue/dashboard");
+    if (needsTelegram) console.log("");
+  }
+  if (needsTelegram) {
+    console.log("  pubblue configure --set telegram.botToken=<TOKEN>  (optional)");
+    console.log("    Prints a t.me/<bot> deep link when you create or update a pub.");
+    console.log("    Requires a Telegram bot with Mini App URL set to https://pub.blue");
+    console.log("    (@BotFather \u2192 /newbot \u2192 Bot Settings \u2192 Configure Mini App)");
+  }
+}
+function printConfigStatus(saved) {
+  console.log(`Config directory: ${getConfigDir()}`);
+  console.log("  API key:   %s", saved?.apiKey ? maskSecret(saved.apiKey) : "not set");
+  printTelegramStatus(saved?.telegram);
+  printBridgeStatus(saved?.bridge ?? {});
+  printSetupInstructions(saved);
+}
+function printMutationSummary(config) {
+  console.log("  API key:   %s", maskSecret(config.apiKey));
+  printTelegramStatus(config.telegram);
+  printBridgeStatus(config.bridge ?? {});
+}
+
+// src/commands/configure/telegram.ts
 async function telegramGetMe(token) {
   const resp = await fetch(`https://api.telegram.org/bot${token}/getMe`);
   const data = await resp.json();
@@ -317,142 +300,767 @@ async function telegramSetMenuButton(token, button) {
     throw new Error(data.description ?? "setChatMenuButton failed");
   }
 }
-function printConfigSummary(saved) {
-  if (!saved) {
-    console.log("Saved config: none");
-    return;
-  }
-  console.log("Saved config:");
-  console.log(`  apiKey: ${maskSecret(saved.apiKey)}`);
-  if (saved.bridge && hasValues(saved.bridge)) {
-    if (saved.bridge.openclawPath) console.log(`  openclaw.path: ${saved.bridge.openclawPath}`);
-    if (saved.bridge.sessionId) console.log(`  openclaw.sessionId: ${saved.bridge.sessionId}`);
-    if (saved.bridge.threadId) console.log(`  openclaw.threadId: ${saved.bridge.threadId}`);
-    if (saved.bridge.canvasReminderEvery !== void 0)
-      console.log(`  openclaw.canvasReminderEvery: ${saved.bridge.canvasReminderEvery}`);
-    if (saved.bridge.deliver !== void 0)
-      console.log(`  openclaw.deliver: ${saved.bridge.deliver ? "true" : "false"}`);
-    if (saved.bridge.deliverChannel)
-      console.log(`  openclaw.deliverChannel: ${saved.bridge.deliverChannel}`);
-    if (saved.bridge.replyTo) console.log(`  openclaw.replyTo: ${saved.bridge.replyTo}`);
-    if (saved.bridge.deliverTimeoutMs !== void 0)
-      console.log(`  openclaw.deliverTimeoutMs: ${saved.bridge.deliverTimeoutMs}`);
-    if (saved.bridge.attachmentDir)
-      console.log(`  openclaw.attachmentDir: ${saved.bridge.attachmentDir}`);
-    if (saved.bridge.attachmentMaxBytes !== void 0)
-      console.log(`  openclaw.attachmentMaxBytes: ${saved.bridge.attachmentMaxBytes}`);
-  } else {
-    console.log("  bridge: none");
-  }
-  if (saved.telegram?.botToken && saved.telegram.botUsername) {
-    console.log(`  telegram.botToken: ${maskSecret(saved.telegram.botToken)}`);
-    console.log(`  telegram.botUsername: @${saved.telegram.botUsername}`);
-    if (!saved.telegram.hasMainWebApp) {
-      console.log("    INFO: Register Mini App in @BotFather for deep links to open in Telegram");
-    }
-  } else if (saved.telegram?.botToken) {
-    console.log(`  telegram.botToken: ${maskSecret(saved.telegram.botToken)}`);
-    console.log("  telegram.botUsername: (not resolved)");
-  } else {
-    console.log("  telegram: not configured");
-    console.log("    INFO: Set telegram.botToken to enable Telegram Mini App links");
-    console.log("    Example: pubblue configure --set telegram.botToken=<BOT_TOKEN>");
-  }
-}
+
+// src/commands/configure/command.ts
 function registerConfigureCommand(program2) {
-  program2.command("configure").description("Configure the CLI with your API key").option("--api-key <key>", "Your API key (less secure: appears in shell history)").option("--api-key-stdin", "Read API key from stdin").option(
+  program2.command("configure").description("Show configuration status, or update settings with --api-key / --set / --unset").option("--api-key <key>", "Set API key (appears in shell history; prefer --api-key-stdin)").option("--api-key-stdin", "Read API key from stdin").option(
     "--set <key=value>",
     "Set config key (repeatable). Example: --set telegram.botToken=<token>",
     collectValues,
     []
-  ).option("--unset <key>", "Unset config key (repeatable)", collectValues, []).option("--show", "Show saved configuration").action(
-    async (opts) => {
-      const saved = readConfig();
-      const hasApiUpdate = Boolean(opts.apiKey || opts.apiKeyStdin);
-      const hasSet = opts.set.length > 0;
-      const hasUnset = opts.unset.length > 0;
-      const hasMutation = hasApiUpdate || hasSet || hasUnset;
-      if (!hasMutation && opts.show) {
-        printConfigSummary(saved);
-        return;
-      }
-      let apiKey = saved?.apiKey;
-      if (hasApiUpdate || !hasMutation) {
-        apiKey = await resolveConfigureApiKey(opts);
-      }
-      if (!apiKey) {
-        const envKey = process.env.PUBBLUE_API_KEY?.trim();
-        if (envKey) {
-          apiKey = envKey;
-        } else {
-          throw new Error(
-            "No API key available. Provide --api-key/--api-key-stdin (or run plain `pubblue configure` first)."
-          );
-        }
+  ).option("--unset <key>", "Unset config key (repeatable)", collectValues, []).action(async (opts) => {
+    const saved = readConfig();
+    const hasApiUpdate = Boolean(opts.apiKey || opts.apiKeyStdin);
+    const hasSet = opts.set.length > 0;
+    const hasUnset = opts.unset.length > 0;
+    const hasMutation = hasApiUpdate || hasSet || hasUnset;
+    if (!hasMutation) {
+      printConfigStatus(saved);
+      return;
+    }
+    let apiKey = saved?.apiKey;
+    if (hasApiUpdate) {
+      apiKey = await resolveConfigureApiKey(opts);
+    }
+    if (!apiKey) {
+      const envKey = process.env.PUBBLUE_API_KEY?.trim();
+      if (envKey) {
+        apiKey = envKey;
+      } else {
+        throw new Error("No API key configured. Set it first: pubblue configure --api-key <KEY>");
       }
-      const nextBridge = { ...saved?.bridge ?? {} };
-      const nextTelegram = { ...saved?.telegram ?? {} };
-      let telegramTokenChanged = false;
-      for (const entry of opts.set) {
-        const { key, value } = parseSetInput(entry);
-        applyConfigSet(nextBridge, nextTelegram, key, value);
-        if (key === "telegram.botToken") telegramTokenChanged = true;
-      }
-      for (const key of opts.unset) {
-        if (key.trim() === "telegram.botToken" && nextTelegram.botToken) {
-          try {
-            await telegramSetMenuButton(nextTelegram.botToken, { type: "default" });
-            console.log("Telegram menu button reset to default.");
-          } catch (error) {
-            console.error(
-              `Warning: failed to reset Telegram menu button: ${errorMessage(error)}`
-            );
-          }
+    }
+    const nextBridge = { ...saved?.bridge ?? {} };
+    const nextTelegram = { ...saved?.telegram ?? {} };
+    let telegramTokenChanged = false;
+    for (const entry of opts.set) {
+      const { key, value } = parseSetInput(entry);
+      applyConfigSet(nextBridge, nextTelegram, key, value);
+      if (key === "telegram.botToken") telegramTokenChanged = true;
+    }
+    for (const key of opts.unset) {
+      if (key.trim() === "telegram.botToken" && nextTelegram.botToken) {
+        try {
+          await telegramSetMenuButton(nextTelegram.botToken, { type: "default" });
+          console.log("Telegram menu button reset to default.");
+        } catch (error) {
+          console.error(`Warning: failed to reset Telegram menu button: ${errorMessage(error)}`);
         }
-        applyConfigUnset(nextBridge, nextTelegram, key.trim());
-      }
-      if (telegramTokenChanged && nextTelegram.botToken) {
-        console.log("Verifying Telegram bot token...");
-        const bot = await telegramGetMe(nextTelegram.botToken);
-        nextTelegram.botUsername = bot.username;
-        nextTelegram.hasMainWebApp = bot.hasMainWebApp;
-        console.log(`  Bot: @${bot.username}`);
-        await telegramSetMenuButton(nextTelegram.botToken, {
-          type: "web_app",
-          text: "Open",
-          web_app: { url: "https://pub.blue" }
-        });
-        console.log("  Menu button set to https://pub.blue");
-        if (!bot.hasMainWebApp) {
-          console.log("");
-          console.log("  INFO: For deep links to open inside Telegram, register the Mini App:");
-          console.log("    @BotFather \u2192 /mybots \u2192 your bot \u2192 Bot Settings \u2192 Configure Mini App");
-          console.log("    Set Web App URL to: https://pub.blue");
+        try {
+          const api = new PubApiClient(process.env.PUBBLUE_URL || DEFAULT_BASE_URL, apiKey);
+          await api.deleteBotToken();
+          console.log("Bot token removed from server.");
+        } catch (error) {
+          console.error(
+            `Warning: failed to remove bot token from server: ${errorMessage(error)}`
+          );
         }
       }
-      const nextConfig = {
-        apiKey,
-        bridge: hasValues(nextBridge) ? nextBridge : void 0,
-        telegram: hasValues(nextTelegram) ? nextTelegram : void 0
-      };
-      saveConfig(nextConfig);
-      console.log("Configuration saved.");
-      if (opts.show || hasSet || hasUnset) {
-        printConfigSummary(nextConfig);
+      applyConfigUnset(nextBridge, nextTelegram, key.trim());
+    }
+    if (telegramTokenChanged && nextTelegram.botToken) {
+      console.log("Verifying Telegram bot token...");
+      const bot = await telegramGetMe(nextTelegram.botToken);
+      nextTelegram.botUsername = bot.username;
+      nextTelegram.hasMainWebApp = bot.hasMainWebApp;
+      console.log(`  Bot: @${bot.username}`);
+      await telegramSetMenuButton(nextTelegram.botToken, {
+        type: "web_app",
+        text: "Open",
+        web_app: { url: "https://pub.blue" }
+      });
+      console.log("  Menu button set to https://pub.blue");
+      if (!bot.hasMainWebApp) {
+        console.log("");
+        console.log("  Mini App not registered \u2014 deep links will open in browser, not Telegram.");
+        console.log("    @BotFather \u2192 /mybots \u2192 your bot \u2192 Bot Settings \u2192 Configure Mini App");
+        console.log("    Set Web App URL to: https://pub.blue");
       }
+      const api = new PubApiClient(process.env.PUBBLUE_URL || DEFAULT_BASE_URL, apiKey);
+      await api.uploadBotToken({
+        botToken: nextTelegram.botToken,
+        botUsername: bot.username
+      });
+      console.log("  Bot token synced to server.");
     }
-  );
+    const nextConfig = {
+      apiKey,
+      bridge: hasValues(nextBridge) ? nextBridge : void 0,
+      telegram: hasValues(nextTelegram) ? nextTelegram : void 0
+    };
+    saveConfig(nextConfig);
+    console.log("Configuration saved.");
+    printMutationSummary(nextConfig);
+  });
 }
 
 // src/commands/live.ts
 import * as fs3 from "fs";
 import * as path3 from "path";
 
+// src/lib/live-ipc.ts
+import * as net from "net";
+function getAgentSocketPath() {
+  const override = process.env.PUBBLUE_AGENT_SOCKET?.trim();
+  if (override && override.length > 0) return override;
+  return "/tmp/pubblue-agent.sock";
+}
+async function ipcCall(socketPath, request) {
+  return new Promise((resolve3, reject) => {
+    let settled = false;
+    let timeoutId = null;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      fn();
+    };
+    const client = net.createConnection(socketPath, () => {
+      client.write(`${JSON.stringify(request)}
+`);
+    });
+    let data = "";
+    client.on("data", (chunk) => {
+      data += chunk.toString();
+      const newlineIdx = data.indexOf("\n");
+      if (newlineIdx !== -1) {
+        const line = data.slice(0, newlineIdx);
+        client.end();
+        try {
+          finish(() => resolve3(JSON.parse(line)));
+        } catch {
+          finish(() => reject(new Error("Invalid response from daemon")));
+        }
+      }
+    });
+    client.on("error", (err) => {
+      if (err.code === "ECONNREFUSED" || err.code === "ENOENT") {
+        finish(() => reject(new Error("Daemon not running.")));
+      } else {
+        finish(() => reject(err));
+      }
+    });
+    client.on("end", () => {
+      if (!data.includes("\n")) {
+        finish(() => reject(new Error("Daemon closed connection unexpectedly")));
+      }
+    });
+    timeoutId = setTimeout(() => {
+      client.destroy();
+      finish(() => reject(new Error("Daemon request timed out")));
+    }, 1e4);
+  });
+}
+
+// src/lib/live-runtime/bridge-runtime.ts
+function buildBridgeProcessEnv(bridgeConfig) {
+  const env = { ...process.env };
+  const setIfMissing = (key, value) => {
+    if (value === void 0) return;
+    const current = env[key];
+    if (typeof current === "string" && current.length > 0) return;
+    env[key] = String(value);
+  };
+  setIfMissing("OPENCLAW_HOME", resolveOpenClawHome(env));
+  if (bridgeConfig) {
+    setIfMissing("OPENCLAW_PATH", bridgeConfig.openclawPath);
+    setIfMissing("OPENCLAW_STATE_DIR", bridgeConfig.openclawStateDir);
+    setIfMissing("OPENCLAW_WORKSPACE", bridgeConfig.openclawWorkspace);
+    setIfMissing("OPENCLAW_SESSION_ID", bridgeConfig.sessionId);
+    setIfMissing("OPENCLAW_THREAD_ID", bridgeConfig.threadId);
+    setIfMissing("OPENCLAW_CANVAS_REMINDER_EVERY", bridgeConfig.canvasReminderEvery);
+    setIfMissing(
+      "OPENCLAW_DELIVER",
+      bridgeConfig.deliver === void 0 ? void 0 : bridgeConfig.deliver ? "1" : "0"
+    );
+    setIfMissing("OPENCLAW_DELIVER_CHANNEL", bridgeConfig.deliverChannel);
+    setIfMissing("OPENCLAW_REPLY_TO", bridgeConfig.replyTo);
+    setIfMissing("OPENCLAW_DELIVER_TIMEOUT_MS", bridgeConfig.deliverTimeoutMs);
+    setIfMissing("OPENCLAW_ATTACHMENT_DIR", bridgeConfig.attachmentDir);
+    setIfMissing("OPENCLAW_ATTACHMENT_MAX_BYTES", bridgeConfig.attachmentMaxBytes);
+    setIfMissing("CLAUDE_CODE_PATH", bridgeConfig.claudeCodePath);
+    setIfMissing("CLAUDE_CODE_MODEL", bridgeConfig.claudeCodeModel);
+    setIfMissing("CLAUDE_CODE_ALLOWED_TOOLS", bridgeConfig.claudeCodeAllowedTools);
+    setIfMissing("CLAUDE_CODE_APPEND_SYSTEM_PROMPT", bridgeConfig.claudeCodeAppendSystemPrompt);
+    setIfMissing("CLAUDE_CODE_MAX_TURNS", bridgeConfig.claudeCodeMaxTurns);
+    setIfMissing("CLAUDE_CODE_CWD", bridgeConfig.claudeCodeCwd);
+    setIfMissing("PUBBLUE_COMMAND_DEFAULT_TIMEOUT_MS", bridgeConfig.commandDefaultTimeoutMs);
+    setIfMissing("PUBBLUE_COMMAND_MAX_OUTPUT_BYTES", bridgeConfig.commandMaxOutputBytes);
+    setIfMissing("PUBBLUE_COMMAND_MAX_CONCURRENT", bridgeConfig.commandMaxConcurrent);
+  }
+  setIfMissing("OPENCLAW_WORKSPACE", resolveOpenClawWorkspaceDir(env));
+  setIfMissing("PUBBLUE_PROJECT_ROOT", process.cwd());
+  return env;
+}
+async function ensureNodeDatachannelAvailable() {
+  try {
+    await import("node-datachannel");
+  } catch (error) {
+    throw new Error(
+      [
+        "node-datachannel native module is not available.",
+        "Run `pnpm rebuild node-datachannel` in the cli package and retry.",
+        `Details: ${error instanceof Error ? error.message : String(error)}`
+      ].join("\n")
+    );
+  }
+}
+function parseBridgeMode(raw) {
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "openclaw" || normalized === "claude-code") {
+    return normalized;
+  }
+  throw new Error(`--bridge must be one of: openclaw, claude-code. Received: ${raw}`);
+}
+function describeConfiguredPath(key, env) {
+  const configured = env[key]?.trim();
+  return configured ? `${key}=${configured}` : `${key} not set`;
+}
+var BRIDGE_PROVIDERS = [
+  {
+    mode: "openclaw",
+    priority: 100,
+    detect(env) {
+      const available = isOpenClawAvailable(env);
+      if (available) {
+        return {
+          available: true,
+          detail: `OpenClaw runtime detected (${describeConfiguredPath("OPENCLAW_PATH", env)})`
+        };
+      }
+      return {
+        available: false,
+        detail: `OpenClaw runtime not detected (${describeConfiguredPath("OPENCLAW_PATH", env)})`
+      };
+    },
+    async startupProbe(env) {
+      const runtime = await runOpenClawBridgeStartupProbe(env);
+      return [
+        `OpenClaw executable: ${runtime.openclawPath}`,
+        `OpenClaw session: ${runtime.sessionId} (${runtime.sessionSource ?? "unknown"})`,
+        'OpenClaw communication via `pubblue write "pong"`: OK'
+      ];
+    }
+  },
+  {
+    mode: "claude-code",
+    priority: 50,
+    detect(env) {
+      const available = isClaudeCodeAvailableInEnv(env);
+      if (available) {
+        return {
+          available: true,
+          detail: `Claude Code runtime detected (${describeConfiguredPath("CLAUDE_CODE_PATH", env)})`
+        };
+      }
+      return {
+        available: false,
+        detail: `Claude Code runtime not detected (${describeConfiguredPath("CLAUDE_CODE_PATH", env)})`
+      };
+    },
+    async startupProbe(env) {
+      const runtime = await runClaudeCodeBridgeStartupProbe(env);
+      const cwd = runtime.cwd || env.PUBBLUE_PROJECT_ROOT || process.cwd();
+      return [
+        `Claude executable: ${runtime.claudePath}`,
+        `Claude cwd: ${cwd}`,
+        'Claude communication via `pubblue write "pong"`: OK'
+      ];
+    }
+  }
+].sort((a, b) => b.priority - a.priority);
+function getBridgeProvider(mode) {
+  const provider = BRIDGE_PROVIDERS.find((entry) => entry.mode === mode);
+  if (!provider) {
+    throw new Error(`Unsupported bridge provider: ${mode}`);
+  }
+  return provider;
+}
+function detectBridgeAvailability(env = process.env) {
+  return BRIDGE_PROVIDERS.map((provider) => {
+    const detection = provider.detect(env);
+    return {
+      mode: provider.mode,
+      available: detection.available,
+      detail: detection.detail
+    };
+  });
+}
+function resolveBridgeSelection(opts, env = process.env) {
+  if (opts.bridge) {
+    const mode = parseBridgeMode(opts.bridge);
+    const provider = getBridgeProvider(mode);
+    const detection = provider.detect(env);
+    if (!detection.available) {
+      throw new Error(`Requested bridge "${mode}" is unavailable: ${detection.detail}`);
+    }
+    return {
+      mode,
+      source: "explicit",
+      detail: detection.detail
+    };
+  }
+  const detections = BRIDGE_PROVIDERS.map((provider) => ({
+    provider,
+    detection: provider.detect(env)
+  }));
+  const selected = detections.find((entry) => entry.detection.available);
+  if (!selected) {
+    const details = detections.map(
+      (entry) => `- ${entry.provider.mode}: ${entry.detection.detail}`
+    );
+    throw new Error(
+      [
+        "No bridge detected.",
+        "Install/configure OpenClaw or Claude Code and retry.",
+        ...details
+      ].join("\n")
+    );
+  }
+  return {
+    mode: selected.provider.mode,
+    source: "auto",
+    detail: selected.detection.detail
+  };
+}
+async function runBridgeStartupPreflight(selection, env = process.env) {
+  const provider = getBridgeProvider(selection.mode);
+  return provider.startupProbe(env);
+}
+
+// src/lib/live-runtime/command-utils.ts
+function getFollowReadDelayMs(disconnected, consecutiveFailures) {
+  if (!disconnected) return 1e3;
+  return Math.min(5e3, 1e3 * 2 ** Math.min(consecutiveFailures, 3));
+}
+function messageContainsPong(payload) {
+  if (!payload || typeof payload !== "object") return false;
+  const message = payload.msg;
+  if (!message || typeof message !== "object") return false;
+  const type = message.type;
+  const data = message.data;
+  return type === "text" && typeof data === "string" && data.trim().toLowerCase() === "pong";
+}
+function formatApiError(error) {
+  if (error instanceof PubApiError) {
+    if (error.status === 429 && error.retryAfterSeconds !== void 0) {
+      return `Rate limit exceeded. Retry after ${error.retryAfterSeconds}s.`;
+    }
+    return `${error.message} (HTTP ${error.status})`;
+  }
+  return errorMessage(error);
+}
+
+// src/lib/live-runtime/daemon-process.ts
+import * as fs2 from "fs";
+function hasErrnoCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function removeStaleDaemonInfo(infoPath) {
+  try {
+    fs2.unlinkSync(infoPath);
+  } catch (error) {
+    if (hasErrnoCode(error, "ENOENT")) return;
+    throw new Error(`Failed to clean up stale daemon info: ${errorMessage(error)}`);
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (hasErrnoCode(error, "ESRCH")) return false;
+    if (hasErrnoCode(error, "EPERM")) return true;
+    throw new Error(`Failed to check process ${pid}: ${errorMessage(error)}`);
+  }
+}
+function readDaemonProcessInfo(slug) {
+  const infoPath = liveInfoPath(slug);
+  let raw;
+  try {
+    raw = fs2.readFileSync(infoPath, "utf-8");
+  } catch (error) {
+    if (hasErrnoCode(error, "ENOENT")) return null;
+    throw new Error(`Failed to read daemon info at ${infoPath}: ${errorMessage(error)}`);
+  }
+  let info;
+  try {
+    info = JSON.parse(raw);
+  } catch (error) {
+    removeStaleDaemonInfo(infoPath);
+    throw new Error(`Invalid daemon info JSON at ${infoPath}: ${errorMessage(error)}`);
+  }
+  if (!Number.isFinite(info.pid)) {
+    removeStaleDaemonInfo(infoPath);
+    return null;
+  }
+  try {
+    if (!isProcessAlive(info.pid)) {
+      removeStaleDaemonInfo(infoPath);
+      return null;
+    }
+    return info;
+  } catch (error) {
+    throw new Error(`Failed to inspect daemon process ${info.pid}: ${errorMessage(error)}`);
+  }
+}
+async function waitForProcessExit(pid, timeoutMs) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (!isProcessAlive(pid)) return true;
+    await new Promise((resolve3) => setTimeout(resolve3, 120));
+  }
+  return !isProcessAlive(pid);
+}
+async function stopDaemonForLive(info) {
+  const pid = info.pid;
+  if (!isProcessAlive(pid)) return null;
+  const socketPath = info.socketPath;
+  if (socketPath) {
+    try {
+      await ipcCall(socketPath, { method: "close", params: {} });
+    } catch (error) {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch (killError) {
+        return `daemon ${pid}: IPC close failed (${errorMessage(error)}); SIGTERM failed (${errorMessage(killError)})`;
+      }
+    }
+  } else {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch (error) {
+      return `daemon ${pid}: no socketPath and SIGTERM failed (${errorMessage(error)})`;
+    }
+  }
+  const stopped = await waitForProcessExit(pid, 8e3);
+  if (!stopped) return `daemon ${pid}: did not exit after stop request`;
+  return null;
+}
+function isDaemonRunning(slug) {
+  return readDaemonProcessInfo(slug) !== null;
+}
+async function stopOtherDaemons() {
+  const dir = liveInfoDir();
+  const entries = fs2.readdirSync(dir).filter((name) => name.endsWith(".json"));
+  const failures = [];
+  for (const entry of entries) {
+    const slug = entry.replace(/\.json$/, "");
+    const info = readDaemonProcessInfo(slug);
+    if (!info) continue;
+    const daemonError = await stopDaemonForLive(info);
+    if (daemonError) failures.push(`[${slug}] ${daemonError}`);
+  }
+  if (failures.length > 0) {
+    throw new Error(
+      [
+        "Critical: failed to stop previous live daemon processes.",
+        "Starting a new daemon now would leak resources and increase bandwidth usage.",
+        ...failures
+      ].join("\n")
+    );
+  }
+}
+function buildDaemonForkStdio(logFd) {
+  return ["ignore", logFd, logFd, "ipc"];
+}
+function waitForDaemonReady({
+  child,
+  infoPath,
+  socketPath,
+  timeoutMs
+}) {
+  return new Promise((resolve3) => {
+    let settled = false;
+    let pollInFlight = false;
+    let lastIpcError = null;
+    const done = (result) => {
+      if (settled) return;
+      settled = true;
+      clearInterval(poll);
+      clearTimeout(timeout);
+      child.off("exit", onExit);
+      resolve3(result);
+    };
+    const onExit = (code, signal) => {
+      const suffix = signal ? ` (signal ${signal})` : "";
+      done({ ok: false, reason: `daemon exited with code ${code ?? 0}${suffix}` });
+    };
+    child.on("exit", onExit);
+    const poll = setInterval(() => {
+      if (pollInFlight || !fs2.existsSync(infoPath)) return;
+      pollInFlight = true;
+      void ipcCall(socketPath, { method: "status", params: {} }).then((status) => {
+        if (status.ok) done({ ok: true });
+      }).catch((error) => {
+        lastIpcError = errorMessage(error);
+      }).finally(() => {
+        pollInFlight = false;
+      });
+    }, 120);
+    const timeout = setTimeout(() => {
+      const reason = lastIpcError ? `timed out after ${timeoutMs}ms waiting for daemon readiness (last IPC error: ${lastIpcError})` : `timed out after ${timeoutMs}ms waiting for daemon readiness`;
+      done({ ok: false, reason });
+    }, timeoutMs);
+  });
+}
+async function resolveActiveSlug() {
+  const socketPath = getAgentSocketPath();
+  const response = await ipcCall(socketPath, { method: "active-slug", params: {} });
+  if (response.ok && typeof response.slug === "string" && response.slug.length > 0) {
+    return response.slug;
+  }
+  throw new Error("Daemon is running but no live is active. Wait for browser to initiate live.");
+}
+
+// src/lib/live-runtime/file-payload.ts
+import * as path2 from "path";
+var TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".txt",
+  ".md",
+  ".markdown",
+  ".json",
+  ".csv",
+  ".xml",
+  ".yaml",
+  ".yml",
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".ts",
+  ".tsx",
+  ".jsx",
+  ".css",
+  ".scss",
+  ".sass",
+  ".less",
+  ".log"
+]);
+var MIME_BY_EXT = {
+  ".html": "text/html; charset=utf-8",
+  ".htm": "text/html; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".md": "text/markdown; charset=utf-8",
+  ".markdown": "text/markdown; charset=utf-8",
+  ".json": "application/json",
+  ".csv": "text/csv; charset=utf-8",
+  ".xml": "application/xml",
+  ".yaml": "application/x-yaml",
+  ".yml": "application/x-yaml",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".cjs": "text/javascript; charset=utf-8",
+  ".ts": "text/typescript; charset=utf-8",
+  ".tsx": "text/typescript; charset=utf-8",
+  ".jsx": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".scss": "text/x-scss; charset=utf-8",
+  ".sass": "text/x-sass; charset=utf-8",
+  ".less": "text/x-less; charset=utf-8",
+  ".log": "text/plain; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".zip": "application/zip",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".mp4": "video/mp4"
+};
+function getMimeType(filePath) {
+  const ext = path2.extname(filePath).toLowerCase();
+  return MIME_BY_EXT[ext] || "application/octet-stream";
+}
+
+// src/lib/live-runtime/start-preflight.ts
+var BRIDGE_CONFIG_FIELDS = [
+  { field: "openclawPath", label: "openclaw.path" },
+  { field: "openclawStateDir", label: "openclaw.stateDir" },
+  { field: "openclawWorkspace", label: "openclaw.workspace" },
+  { field: "sessionId", label: "openclaw.sessionId" },
+  { field: "threadId", label: "openclaw.threadId" },
+  { field: "canvasReminderEvery", label: "openclaw.canvasReminderEvery" },
+  { field: "deliver", label: "openclaw.deliver" },
+  { field: "deliverChannel", label: "openclaw.deliverChannel" },
+  { field: "replyTo", label: "openclaw.replyTo" },
+  { field: "deliverTimeoutMs", label: "openclaw.deliverTimeoutMs" },
+  { field: "attachmentDir", label: "openclaw.attachmentDir" },
+  { field: "attachmentMaxBytes", label: "openclaw.attachmentMaxBytes" },
+  { field: "claudeCodePath", label: "claude-code.path" },
+  { field: "claudeCodeModel", label: "claude-code.model" },
+  { field: "claudeCodeAllowedTools", label: "claude-code.allowedTools" },
+  { field: "claudeCodeAppendSystemPrompt", label: "claude-code.appendSystemPrompt" },
+  { field: "claudeCodeMaxTurns", label: "claude-code.maxTurns" },
+  { field: "claudeCodeCwd", label: "claude-code.cwd" },
+  { field: "commandDefaultTimeoutMs", label: "command.defaultTimeoutMs" },
+  { field: "commandMaxOutputBytes", label: "command.maxOutputBytes" },
+  { field: "commandMaxConcurrent", label: "command.maxConcurrent" }
+];
+var BRIDGE_ENV_OVERRIDE_KEYS = [
+  "OPENCLAW_PATH",
+  "OPENCLAW_STATE_DIR",
+  "OPENCLAW_WORKSPACE",
+  "OPENCLAW_SESSION_ID",
+  "OPENCLAW_THREAD_ID",
+  "OPENCLAW_CANVAS_REMINDER_EVERY",
+  "OPENCLAW_DELIVER",
+  "OPENCLAW_DELIVER_CHANNEL",
+  "OPENCLAW_REPLY_TO",
+  "OPENCLAW_DELIVER_TIMEOUT_MS",
+  "OPENCLAW_ATTACHMENT_DIR",
+  "OPENCLAW_ATTACHMENT_MAX_BYTES",
+  "CLAUDE_CODE_PATH",
+  "CLAUDE_CODE_MODEL",
+  "CLAUDE_CODE_ALLOWED_TOOLS",
+  "CLAUDE_CODE_APPEND_SYSTEM_PROMPT",
+  "CLAUDE_CODE_MAX_TURNS",
+  "CLAUDE_CODE_CWD",
+  "PUBBLUE_COMMAND_DEFAULT_TIMEOUT_MS",
+  "PUBBLUE_COMMAND_MAX_OUTPUT_BYTES",
+  "PUBBLUE_COMMAND_MAX_CONCURRENT"
+];
+function listSavedBridgeConfigKeys(bridgeConfig) {
+  if (!bridgeConfig) return [];
+  return BRIDGE_CONFIG_FIELDS.filter(({ field }) => bridgeConfig[field] !== void 0).map(
+    ({ label }) => label
+  );
+}
+function listBridgeEnvOverrides(env = process.env) {
+  return BRIDGE_ENV_OVERRIDE_KEYS.filter((key) => {
+    const value = env[key];
+    return typeof value === "string" && value.trim().length > 0;
+  });
+}
+function formatBridgeAvailability(entries) {
+  return entries.map(
+    (entry) => `${entry.mode}=${entry.available ? "available" : "unavailable"} (${entry.detail})`
+  ).join(" | ");
+}
+function formatPreflightError(params) {
+  const { failures, passed, skipped } = params;
+  const lines = [
+    "Start preflight failed. Critical checks did not pass:",
+    ...failures.map((entry) => `- [${entry.label}] ${entry.detail}`)
+  ];
+  if (passed.length > 0) {
+    lines.push("", "Passed checks:");
+    lines.push(...passed.map((entry) => `- [${entry.label}] ${entry.detail}`));
+  }
+  if (skipped.length > 0) {
+    lines.push("", "Skipped checks:");
+    lines.push(...skipped.map((entry) => `- [${entry.label}] ${entry.detail}`));
+  }
+  lines.push("", "Debug tips:");
+  lines.push("- Run `pubblue configure` to inspect saved CLI configuration.");
+  lines.push("- Use `pubblue start --bridge openclaw|claude-code` to force a bridge mode.");
+  return lines.join("\n");
+}
+async function runStartPreflight(opts) {
+  const passed = [];
+  const failures = [];
+  const skipped = [];
+  let runtimeConfig = null;
+  let bridgeSelection = null;
+  let bridgeProcessEnv = buildBridgeProcessEnv();
+  try {
+    await ensureNodeDatachannelAvailable();
+    passed.push({ label: "node-datachannel", detail: "native module loaded" });
+  } catch (error) {
+    failures.push({ label: "node-datachannel", detail: errorMessage(error) });
+  }
+  try {
+    runtimeConfig = getConfig();
+    const source = process.env.PUBBLUE_API_KEY?.trim() ? "PUBBLUE_API_KEY env" : "saved config";
+    passed.push({ label: "config", detail: `API key configured (${source})` });
+    bridgeProcessEnv = buildBridgeProcessEnv(runtimeConfig.bridge);
+    const savedBridgeConfig = listSavedBridgeConfigKeys(runtimeConfig.bridge);
+    const envOverrides = listBridgeEnvOverrides();
+    passed.push({
+      label: "bridge.config",
+      detail: `saved: ${savedBridgeConfig.join(", ") || "(none)"} | env overrides: ${envOverrides.join(", ") || "(none)"}`
+    });
+  } catch (error) {
+    failures.push({ label: "config", detail: errorMessage(error) });
+    bridgeProcessEnv = buildBridgeProcessEnv();
+  }
+  const bridgeAvailability = detectBridgeAvailability(bridgeProcessEnv);
+  passed.push({
+    label: "bridge.available",
+    detail: formatBridgeAvailability(bridgeAvailability)
+  });
+  try {
+    bridgeSelection = resolveBridgeSelection(opts, bridgeProcessEnv);
+    passed.push({
+      label: "bridge.resolve",
+      detail: `${bridgeSelection.mode} (${bridgeSelection.source}, ${bridgeSelection.detail})`
+    });
+  } catch (error) {
+    failures.push({ label: "bridge.resolve", detail: errorMessage(error) });
+  }
+  if (bridgeSelection) {
+    try {
+      const details = await runBridgeStartupPreflight(bridgeSelection, bridgeProcessEnv);
+      passed.push({ label: "bridge.preflight", detail: details.join(" | ") });
+    } catch (error) {
+      failures.push({ label: `bridge.${bridgeSelection.mode}`, detail: errorMessage(error) });
+    }
+  } else {
+    skipped.push({
+      label: "bridge.preflight",
+      detail: "skipped because bridge mode could not be resolved"
+    });
+  }
+  if (runtimeConfig) {
+    const client = new PubApiClient(runtimeConfig.baseUrl, runtimeConfig.apiKey);
+    try {
+      await client.getPendingLive();
+      passed.push({
+        label: "api",
+        detail: `authenticated and reachable at ${runtimeConfig.baseUrl}`
+      });
+    } catch (error) {
+      failures.push({ label: "api", detail: formatApiError(error) });
+    }
+  } else {
+    skipped.push({
+      label: "api",
+      detail: "skipped because configuration is unavailable"
+    });
+  }
+  try {
+    await stopOtherDaemons();
+    passed.push({
+      label: "daemon.cleanup",
+      detail: "no stale daemon conflicts detected"
+    });
+  } catch (error) {
+    failures.push({ label: "daemon.cleanup", detail: errorMessage(error) });
+  }
+  if (failures.length > 0) {
+    throw new Error(formatPreflightError({ failures, passed, skipped }));
+  }
+  if (!runtimeConfig || !bridgeSelection) {
+    throw new Error(
+      "Start preflight failed: internal error while resolving runtime configuration."
+    );
+  }
+  return {
+    runtimeConfig,
+    bridgeMode: bridgeSelection.mode,
+    bridgeProcessEnv,
+    bridgeSelection,
+    passedChecks: passed.map((entry) => `[${entry.label}] ${entry.detail}`)
+  };
+}
+
 // package.json
 var package_default = {
   name: "pubblue",
-  version: "0.6.4",
-  description: "CLI tool for publishing content and running interactive sessions via pub.blue",
+  version: "0.6.9",
+  description: "CLI for publishing and visualizing AI-agent output via pub.blue",
   type: "module",
   bin: {
     pubblue: "./dist/index.js"
@@ -466,6 +1074,7 @@ var package_default = {
   },
   dependencies: {
     commander: "^13.0.0",
+    convex: "^1.19.0",
     "node-datachannel": "^0.32.0"
   },
   devDependencies: {
@@ -510,36 +1119,34 @@ function registerLiveCommands(program2) {
   registerChannelsCommand(program2);
   registerDoctorCommand(program2);
 }
+function printLocalRuntimeSummary() {
+  const saved = readConfig();
+  const hasEnvApiKey = typeof process.env.PUBBLUE_API_KEY === "string" && process.env.PUBBLUE_API_KEY.trim().length > 0;
+  const apiSource = hasEnvApiKey ? "PUBBLUE_API_KEY env" : saved?.apiKey ? "saved config" : "not configured";
+  const baseUrl = process.env.PUBBLUE_URL?.trim() || DEFAULT_BASE_URL;
+  console.log("Local runtime configuration:");
+  console.log(`  API key source: ${apiSource}`);
+  console.log(`  Base URL: ${baseUrl}`);
+  const availability = detectBridgeAvailability();
+  console.log("Bridge runtime availability:");
+  for (const bridge of availability) {
+    console.log(
+      `  ${bridge.mode}: ${bridge.available ? "available" : "unavailable"} (${bridge.detail})`
+    );
+  }
+}
 function registerStartCommand(program2) {
-  program2.command("start").description("Start the agent daemon (registers presence, awaits live requests)").requiredOption("--agent-name <name>", "Agent display name shown to the browser user").option("--bridge <mode>", "Bridge mode: openclaw|none").option("--foreground", "Run in foreground (don't fork)").action(async (opts) => {
-    await ensureNodeDatachannelAvailable();
+  program2.command("start").description("Start the agent daemon (registers presence, awaits live requests)").requiredOption("--agent-name <name>", "Agent display name shown to the browser user").option("--bridge <mode>", "Bridge mode: openclaw|claude-code").action(async (opts) => {
     writeLatestCliVersion(CLI_VERSION);
-    const runtimeConfig = getConfig();
-    const apiClient = createClient(runtimeConfig);
-    const bridgeMode = resolveBridgeMode(opts);
-    const bridgeProcessEnv = buildBridgeProcessEnv(runtimeConfig.bridge);
+    const preflight = await runStartPreflight({ bridge: opts.bridge });
+    const { runtimeConfig, bridgeMode, bridgeProcessEnv } = preflight;
+    console.log("Preflight checks passed:");
+    for (const line of preflight.passedChecks) {
+      console.log(`  ${line}`);
+    }
     const socketPath = getAgentSocketPath();
     const infoPath = liveInfoPath("agent");
     const logPath = liveLogPath("agent");
-    await stopOtherDaemons();
-    if (opts.foreground) {
-      const { startDaemon } = await import("./live-daemon-EEIBVVBU.js");
-      console.log("Agent daemon starting in foreground...");
-      console.log("Press Ctrl+C to stop.");
-      try {
-        await startDaemon({
-          cliVersion: CLI_VERSION,
-          apiClient,
-          socketPath,
-          infoPath,
-          bridgeMode,
-          agentName: opts.agentName
-        });
-      } catch (error) {
-        failCli(`Daemon failed: ${errorMessage(error)}`);
-      }
-      return;
-    }
     const { fork } = await import("child_process");
     const daemonScript = path3.join(import.meta.dirname, "live-daemon-entry.js");
     const daemonLogFd = fs3.openSync(logPath, "a");
@@ -574,7 +1181,12 @@ function registerStartCommand(program2) {
         `Daemon failed to start: ${ready.reason ?? "unknown reason"}`,
         `Daemon log: ${logPath}`
       ];
-      const tail = readLogTail(logPath);
+      let tail = null;
+      try {
+        tail = readLogTail(logPath);
+      } catch (error) {
+        lines.push(`Failed to read daemon log tail: ${errorMessage(error)}`);
+      }
       if (tail) {
         lines.push("---- daemon log tail ----");
         lines.push(tail.trimEnd());
@@ -603,17 +1215,25 @@ function registerStatusCommand(program2) {
     let response;
     try {
       response = await ipcCall(socketPath, { method: "status", params: {} });
-    } catch {
+    } catch (error) {
+      if (errorMessage(error) !== "Daemon not running.") {
+        failCli(`Failed to fetch daemon status: ${errorMessage(error)}`);
+      }
       console.log("Agent daemon is not running.");
+      printLocalRuntimeSummary();
       return;
     }
-    const activeSlug = response.activeSlug;
+    if (!response.ok) {
+      failCli(`Failed to fetch daemon status: ${response.error || "unknown error"}`);
+    }
     console.log(`  Daemon: running`);
-    console.log(`  Active slug: ${activeSlug || "(none)"}`);
+    console.log(`  Active slug: ${response.activeSlug || "(none)"}`);
     console.log(`  Status: ${response.connected ? "connected" : "waiting"}`);
+    if (typeof response.signalingConnected === "boolean") {
+      console.log(`  Signaling: ${response.signalingConnected ? "connected" : "reconnecting"}`);
+    }
     console.log(`  Uptime: ${response.uptime}s`);
-    const chNames = Array.isArray(response.channels) ? response.channels.map((c) => typeof c === "string" ? c : String(c)) : [];
-    console.log(`  Channels: ${chNames.join(", ") || "(none)"}`);
+    console.log(`  Channels: ${response.channels.join(", ") || "(none)"}`);
     console.log(`  Buffered: ${response.bufferedMessages ?? 0} messages`);
     if (typeof response.lastError === "string" && response.lastError.length > 0) {
       console.log(`  Last error: ${response.lastError}`);
@@ -624,7 +1244,8 @@ function registerStatusCommand(program2) {
     }
     const bridge = response.bridge;
     if (bridge) {
-      console.log(`  Bridge: openclaw (${bridge.running ? "running" : "stopped"})`);
+      const bridgeLabel = response.bridgeMode ?? "unknown";
+      console.log(`  Bridge: ${bridgeLabel} (${bridge.running ? "running" : "stopped"})`);
       if (bridge.sessionId) {
         console.log(`  Bridge session: ${bridge.sessionId}`);
       }
@@ -764,10 +1385,12 @@ function registerChannelsCommand(program2) {
 function registerDoctorCommand(program2) {
   program2.command("doctor").description("Run end-to-end live checks (daemon, channels, chat/canvas ping)").option("--timeout <seconds>", "Timeout for pong wait and repeated reads", "30").option("--wait-pong", "Wait for user to reply with exact text 'pong' on chat channel").option("--skip-chat", "Skip chat ping check").option("--skip-canvas", "Skip canvas ping check").action(
     async (opts) => {
-      const timeoutSeconds = parsePositiveIntegerOption(opts.timeout, "--timeout");
+      const timeoutSeconds = parsePositiveInteger(opts.timeout, "--timeout");
       const timeoutMs = timeoutSeconds * 1e3;
       const socketPath = getAgentSocketPath();
-      const slug = await resolveActiveSlug();
+      const slug = await resolveActiveSlug().catch(
+        (error) => failCli(`No active daemon. Run \`pubblue start\` first. (${errorMessage(error)})`)
+      );
       const apiClient = createClient();
       const fail = (message) => failCli(`Doctor failed: ${message}`);
       console.log(`Doctor: ${slug}`);
@@ -782,7 +1405,13 @@ function registerDoctorCommand(program2) {
         fail("daemon is running but browser is not connected.");
       }
       const channelNames = Array.isArray(statusResponse.channels) ? statusResponse.channels.map((entry) => String(entry)) : [];
-      for (const required of [CONTROL_CHANNEL, CHANNELS.CHAT, CHANNELS.CANVAS]) {
+      for (const required of [
+        CONTROL_CHANNEL,
+        CHANNELS.CHAT,
+        CHANNELS.CANVAS,
+        CHANNELS.RENDER_ERROR,
+        CHANNELS.COMMAND
+      ]) {
         if (!channelNames.includes(required)) {
           fail(`required channel is missing: ${required}`);
         }