pubblue 0.5.0 → 0.6.1

package/dist/index.js

@@ -1,54 +1,37 @@
 #!/usr/bin/env node
 import {
+  CHANNELS,
+  CONTROL_CHANNEL,
   PubApiClient,
-  PubApiError,
   TEXT_FILE_EXTENSIONS,
-  bridgeInfoPath,
-  bridgeLogPath,
   buildBridgeProcessEnv,
   buildDaemonForkStdio,
-  cleanupLiveOnStartFailure,
   createApiClient,
-  ensureBridgeReady,
   ensureNodeDatachannelAvailable,
   failCli,
   formatApiError,
+  generateMessageId,
+  getAgentSocketPath,
   getConfig,
   getFollowReadDelayMs,
   getMimeType,
-  getPublicUrl,
   getTelegramMiniAppUrl,
-  isBridgeRunning,
+  ipcCall,
   isDaemonRunning,
   liveInfoPath,
   liveLogPath,
   loadConfig,
   messageContainsPong,
-  parseBridgeMode,
   parsePositiveIntegerOption,
-  pickReusableLive,
-  readBridgeProcessInfo,
-  readDaemonProcessInfo,
   readLogTail,
   resolveActiveSlug,
-  resolveSlugSelection,
+  resolveBridgeMode,
   saveConfig,
-  shouldRestartDaemonForCliUpgrade,
-  stopBridge,
   stopOtherDaemons,
   toCliFailure,
-  waitForAgentOffer,
   waitForDaemonReady,
-  waitForProcessExit,
   writeLatestCliVersion
-} from "./chunk-YI45G6AG.js";
-import {
-  CHANNELS,
-  CONTROL_CHANNEL,
-  generateMessageId,
-  getSocketPath,
-  ipcCall
-} from "./chunk-PFZT7M3E.js";
+} from "./chunk-BBJOOZHS.js";
 
 // src/program.ts
 import { Command } from "commander";
@@ -143,11 +126,6 @@ function parseBooleanValue(raw, key) {
     return false;
   throw new Error(`Invalid boolean value for ${key}: ${raw}`);
 }
-function parseBridgeModeValue(raw) {
-  const normalized = raw.trim().toLowerCase();
-  if (normalized === "openclaw" || normalized === "none") return normalized;
-  throw new Error(`Invalid bridge mode: ${raw}. Use openclaw or none.`);
-}
 function parsePositiveInteger(raw, key) {
   const parsed = Number.parseInt(raw, 10);
   if (!Number.isFinite(parsed) || parsed <= 0) {
@@ -156,7 +134,6 @@ function parsePositiveInteger(raw, key) {
   return parsed;
 }
 var SUPPORTED_KEYS = [
-  "bridge.mode",
   "openclaw.path",
   "openclaw.sessionId",
   "openclaw.threadId",
@@ -171,9 +148,6 @@ var SUPPORTED_KEYS = [
 ];
 function applyConfigSet(bridge, telegram, key, value) {
   switch (key) {
-    case "bridge.mode":
-      bridge.mode = parseBridgeModeValue(value);
-      return;
     case "openclaw.path":
       bridge.openclawPath = value;
       return;
@@ -219,9 +193,6 @@ function applyConfigSet(bridge, telegram, key, value) {
 }
 function applyConfigUnset(bridge, telegram, key) {
   switch (key) {
-    case "bridge.mode":
-      delete bridge.mode;
-      return;
     case "openclaw.path":
       delete bridge.openclawPath;
       return;
@@ -279,13 +250,11 @@ async function telegramGetMe(token) {
     hasMainWebApp: data.result.has_main_web_app === true
   };
 }
-async function telegramSetMenuButton(token, url) {
+async function telegramSetMenuButton(token, button) {
   const resp = await fetch(`https://api.telegram.org/bot${token}/setChatMenuButton`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      menu_button: { type: "web_app", text: "Open", web_app: { url } }
-    })
+    body: JSON.stringify({ menu_button: button })
   });
   const data = await resp.json();
   if (!data.ok) {
@@ -300,7 +269,6 @@ function printConfigSummary(saved) {
   console.log("Saved config:");
   console.log(`  apiKey: ${maskSecret(saved.apiKey)}`);
   if (saved.bridge && hasValues(saved.bridge)) {
-    console.log(`  bridge.mode: ${saved.bridge.mode ?? "(unset)"}`);
     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}`);
@@ -375,6 +343,16 @@ function registerConfigureCommand(program2) {
         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: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+        }
         applyConfigUnset(nextBridge, nextTelegram, key.trim());
       }
       if (telegramTokenChanged && nextTelegram.botToken) {
@@ -383,7 +361,11 @@ function registerConfigureCommand(program2) {
         nextTelegram.botUsername = bot.username;
         nextTelegram.hasMainWebApp = bot.hasMainWebApp;
         console.log(`  Bot: @${bot.username}`);
-        await telegramSetMenuButton(nextTelegram.botToken, "https://pub.blue");
+        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("");
@@ -413,15 +395,15 @@ import * as path2 from "path";
 // package.json
 var package_default = {
   name: "pubblue",
-  version: "0.5.0",
+  version: "0.6.1",
   description: "CLI tool for publishing content and running interactive sessions via pub.blue",
   type: "module",
   bin: {
     pubblue: "./dist/index.js"
   },
   scripts: {
-    build: "tsup src/index.ts src/tunnel-daemon-entry.ts src/tunnel-bridge-entry.ts --format esm --dts --clean",
-    dev: "tsup src/index.ts src/tunnel-daemon-entry.ts src/tunnel-bridge-entry.ts --format esm --watch",
+    build: "tsup src/index.ts src/tunnel-daemon-entry.ts --format esm --dts --clean",
+    dev: "tsup src/index.ts src/tunnel-daemon-entry.ts --format esm --watch",
     test: "vitest run",
     "test:watch": "vitest",
     lint: "tsc --noEmit"
@@ -464,529 +446,258 @@ var CLI_VERSION = version;
 
 // src/commands/live.ts
 function registerLiveCommands(program2) {
-  registerOpenCommand(program2);
-  registerCloseCommand(program2);
+  registerStartCommand(program2);
+  registerStopCommand(program2);
   registerStatusCommand(program2);
   registerWriteCommand(program2);
   registerReadCommand(program2);
   registerChannelsCommand(program2);
   registerDoctorCommand(program2);
 }
-function registerOpenCommand(program2) {
-  program2.command("open").description("Go live on a pub (starts WebRTC daemon)").argument("[slug]", "Pub slug (reuses existing live when possible)").option("--expires <duration>", "Auto-close after duration (e.g. 4h, 1d)", "24h").option("--new", "Always create a new live (skip reuse)").option("--bridge <mode>", "Bridge mode: openclaw|none").option("--foreground", "Run in foreground (don't fork, no managed bridge)").action(
-    async (slugArg, opts) => {
-      await ensureNodeDatachannelAvailable();
-      writeLatestCliVersion(CLI_VERSION);
-      const runtimeConfig = getConfig();
-      const apiClient = createApiClient(runtimeConfig);
-      let target = null;
-      const bridgeMode = parseBridgeMode(opts.bridge || runtimeConfig.bridge?.mode || "openclaw");
-      const bridgeProcessEnv = buildBridgeProcessEnv(runtimeConfig.bridge);
-      if (slugArg && !opts.new) {
-        try {
-          const pub = await apiClient.get(slugArg);
-          if (pub.live?.status === "active" && pub.live.expiresAt > Date.now()) {
-            target = {
-              createdNew: false,
-              expiresAt: pub.live.expiresAt,
-              mode: "existing",
-              slug: pub.slug,
-              url: getPublicUrl(pub.slug)
-            };
-            console.error(`Reusing existing active live for ${pub.slug}.`);
-          }
-        } catch (error) {
-          if (!(error instanceof PubApiError && error.status === 404)) {
-            failCli(`Failed to inspect pub ${slugArg}: ${formatApiError(error)}`);
-          }
-        }
-      } else if (!slugArg && !opts.new) {
-        try {
-          const pubs = await apiClient.list();
-          const reusable = pickReusableLive(pubs);
-          if (reusable) {
-            if (!reusable.live) {
-              failCli("Internal error: reusable live is missing from selected pub.");
-            }
-            target = {
-              createdNew: false,
-              expiresAt: reusable.live.expiresAt,
-              mode: "existing",
-              slug: reusable.slug,
-              url: getPublicUrl(reusable.slug)
-            };
-            const activeLives = pubs.filter(
-              (p) => p.live?.status === "active" && p.live.expiresAt > Date.now()
-            );
-            if (activeLives.length > 1) {
-              console.error(
-                [
-                  `Multiple active lives found: ${activeLives.map((p) => p.slug).join(", ")}`,
-                  `Reusing most recent: ${reusable.slug}.`,
-                  "Use `pubblue open <slug>` to choose explicitly or --new to force creation."
-                ].join("\n")
-              );
-            } else {
-              console.error(
-                `Reusing existing live for ${reusable.slug}. Use --new to force creation.`
-              );
-            }
-          }
-        } catch (error) {
-          failCli(`Failed to list pubs for live reuse check: ${formatApiError(error)}`);
-        }
-      }
-      if (!target) {
-        try {
-          let created;
-          if (slugArg) {
-            created = await apiClient.openLive(slugArg, {
-              expiresIn: opts.expires
-            });
-          } else {
-            const newPub = await apiClient.create({});
-            try {
-              created = await apiClient.openLive(newPub.slug, {
-                expiresIn: opts.expires
-              });
-            } catch (error) {
-              try {
-                await apiClient.remove(newPub.slug);
-              } catch (cleanupError) {
-                console.error(
-                  `Warning: failed to remove pub ${newPub.slug} after open failure: ${formatApiError(cleanupError)}`
-                );
-              }
-              throw error;
-            }
-          }
-          target = {
-            createdNew: true,
-            expiresAt: created.expiresAt,
-            mode: "created",
-            slug: created.slug,
-            url: created.url
-          };
-        } catch (error) {
-          failCli(`Failed to go live: ${formatApiError(error)}`);
-        }
-      }
-      if (!target) {
-        failCli("Failed to resolve live target.");
-      }
-      const socketPath = getSocketPath(target.slug);
-      const infoPath = liveInfoPath(target.slug);
-      const logPath = liveLogPath(target.slug);
+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();
+    writeLatestCliVersion(CLI_VERSION);
+    const runtimeConfig = getConfig();
+    const apiClient = createApiClient(runtimeConfig);
+    const bridgeMode = resolveBridgeMode(opts);
+    const bridgeProcessEnv = buildBridgeProcessEnv(runtimeConfig.bridge);
+    const socketPath = getAgentSocketPath();
+    const infoPath = liveInfoPath("agent");
+    const logPath = liveLogPath("agent");
+    await stopOtherDaemons();
+    if (opts.foreground) {
+      const { startDaemon } = await import("./tunnel-daemon-BR5XKNEA.js");
+      console.log("Agent daemon starting in foreground...");
+      console.log("Press Ctrl+C to stop.");
       try {
-        await stopOtherDaemons(target.slug);
-      } catch (error) {
-        failCli(error instanceof Error ? error.message : String(error));
-      }
-      if (opts.foreground) {
-        if (bridgeMode !== "none") {
-          throw new Error(
-            "Foreground mode disables managed bridge process. Use background mode for --bridge openclaw."
-          );
-        }
-        const { startDaemon } = await import("./tunnel-daemon-QN6TVUX6.js");
-        console.log(`Live started: ${target.url}`);
-        const fgTma = getTelegramMiniAppUrl(target.slug);
-        if (fgTma) console.log(`Telegram: ${fgTma}`);
-        console.log(`Slug: ${target.slug}`);
-        console.log(`Expires: ${new Date(target.expiresAt).toISOString()}`);
-        if (target.mode === "existing") console.log("Mode: attached existing live");
-        console.log("Running in foreground. Press Ctrl+C to stop.");
-        try {
-          await startDaemon({
-            cliVersion: CLI_VERSION,
-            slug: target.slug,
-            apiClient,
-            socketPath,
-            infoPath
-          });
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          failCli(`Daemon failed: ${message}`);
-        }
-        return;
-      }
-      const runningDaemonInfo = readDaemonProcessInfo(target.slug);
-      if (runningDaemonInfo) {
-        const daemonVersion = runningDaemonInfo.cliVersion;
-        const shouldRestartForUpgrade = shouldRestartDaemonForCliUpgrade(
-          daemonVersion,
-          CLI_VERSION
-        );
-        if (shouldRestartForUpgrade) {
-          console.error(
-            `Restarting daemon for CLI version ${CLI_VERSION} (running: ${daemonVersion || "unknown"}).`
-          );
-          const bridgeError = await stopBridge(target.slug);
-          if (bridgeError) failCli(bridgeError);
-          try {
-            await ipcCall(socketPath, { method: "close", params: {} });
-          } catch (error) {
-            failCli(
-              [
-                `Failed to stop running daemon for upgrade: ${error instanceof Error ? error.message : String(error)}`,
-                "Run `pubblue close <slug>` and retry."
-              ].join("\n")
-            );
-          }
-          const daemonStopped = await waitForProcessExit(runningDaemonInfo.pid, 6e3);
-          if (!daemonStopped) {
-            failCli("Daemon did not stop in time during upgrade restart.");
-          }
-        } else {
-          try {
-            const status = await ipcCall(socketPath, { method: "status", params: {} });
-            if (!status.ok) throw new Error(String(status.error || "status check failed"));
-          } catch (error) {
-            failCli(
-              [
-                `Daemon process exists but is not responding: ${error instanceof Error ? error.message : String(error)}`,
-                "Run `pubblue close <slug>` and start again."
-              ].join("\n")
-            );
-          }
-          if (bridgeMode !== "none") {
-            const bridgeReady = await ensureBridgeReady({
-              bridgeMode,
-              slug: target.slug,
-              socketPath,
-              bridgeProcessEnv,
-              timeoutMs: 8e3
-            });
-            if (!bridgeReady.ok) {
-              const lines = [
-                `Bridge failed to start for running live: ${bridgeReady.reason ?? "unknown reason"}`
-              ];
-              const existingBridgeLog = bridgeLogPath(target.slug);
-              if (fs2.existsSync(existingBridgeLog)) {
-                lines.push(`Bridge log: ${existingBridgeLog}`);
-                const bridgeTail = readLogTail(existingBridgeLog);
-                if (bridgeTail) {
-                  lines.push("---- bridge log tail ----");
-                  lines.push(bridgeTail.trimEnd());
-                  lines.push("---- end bridge log tail ----");
-                }
-              }
-              failCli(lines.join("\n"));
-            }
-          }
-          console.log(`Live started: ${target.url}`);
-          const runTma = getTelegramMiniAppUrl(target.slug);
-          if (runTma) console.log(`Telegram: ${runTma}`);
-          console.log(`Slug: ${target.slug}`);
-          console.log(`Expires: ${new Date(target.expiresAt).toISOString()}`);
-          console.log("Daemon already running for this live.");
-          console.log(`Daemon log: ${logPath}`);
-          if (bridgeMode !== "none") {
-            console.log("Bridge mode: openclaw");
-            console.log(`Bridge log: ${bridgeLogPath(target.slug)}`);
-          }
-          return;
-        }
-      }
-      const { fork } = await import("child_process");
-      const daemonScript = path2.join(import.meta.dirname, "tunnel-daemon-entry.js");
-      const bridgeScript = path2.join(import.meta.dirname, "tunnel-bridge-entry.js");
-      const daemonLogFd = fs2.openSync(logPath, "a");
-      const child = fork(daemonScript, [], {
-        detached: true,
-        stdio: buildDaemonForkStdio(daemonLogFd),
-        env: {
-          ...bridgeProcessEnv,
-          PUBBLUE_DAEMON_SLUG: target.slug,
-          PUBBLUE_DAEMON_BASE_URL: runtimeConfig.baseUrl,
-          PUBBLUE_DAEMON_API_KEY: runtimeConfig.apiKey,
-          PUBBLUE_DAEMON_SOCKET: socketPath,
-          PUBBLUE_DAEMON_INFO: infoPath,
-          PUBBLUE_CLI_VERSION: CLI_VERSION,
-          PUBBLUE_DAEMON_BRIDGE_MODE: bridgeMode,
-          PUBBLUE_DAEMON_BRIDGE_SCRIPT: bridgeScript,
-          PUBBLUE_DAEMON_BRIDGE_INFO: bridgeInfoPath(target.slug),
-          PUBBLUE_DAEMON_BRIDGE_LOG: bridgeLogPath(target.slug)
-        }
-      });
-      fs2.closeSync(daemonLogFd);
-      if (child.connected) {
-        child.disconnect();
-      }
-      child.unref();
-      console.log(`Starting daemon for ${target.slug}...`);
-      const ready = await waitForDaemonReady({
-        child,
-        infoPath,
-        socketPath,
-        timeoutMs: 8e3
-      });
-      if (!ready.ok) {
-        const lines = [
-          `Daemon failed to start: ${ready.reason ?? "unknown reason"}`,
-          `Daemon log: ${logPath}`
-        ];
-        const tail = readLogTail(logPath);
-        if (tail) {
-          lines.push("---- daemon log tail ----");
-          lines.push(tail.trimEnd());
-          lines.push("---- end daemon log tail ----");
-        }
-        await cleanupLiveOnStartFailure(apiClient, target);
-        failCli(lines.join("\n"));
-      }
-      const offerReady = await waitForAgentOffer({
-        apiClient,
-        slug: target.slug,
-        timeoutMs: 5e3
-      });
-      if (!offerReady.ok) {
-        const lines = [
-          `Daemon started but signaling is not ready: ${offerReady.reason}`,
-          `Daemon log: ${logPath}`
-        ];
-        const tail = readLogTail(logPath);
-        if (tail) {
-          lines.push("---- daemon log tail ----");
-          lines.push(tail.trimEnd());
-          lines.push("---- end daemon log tail ----");
-        }
-        await cleanupLiveOnStartFailure(apiClient, target);
-        failCli(lines.join("\n"));
-      }
-      if (bridgeMode !== "none") {
-        const bridgeReady = await ensureBridgeReady({
-          bridgeMode,
-          slug: target.slug,
+        await startDaemon({
+          cliVersion: CLI_VERSION,
+          apiClient,
           socketPath,
-          bridgeProcessEnv,
-          timeoutMs: 8e3
+          infoPath,
+          bridgeMode,
+          agentName: opts.agentName
         });
-        if (!bridgeReady.ok) {
-          const lines = [`Bridge failed to start: ${bridgeReady.reason ?? "unknown reason"}`];
-          const bridgeLog = bridgeLogPath(target.slug);
-          if (fs2.existsSync(bridgeLog)) {
-            lines.push(`Bridge log: ${bridgeLog}`);
-            const bridgeTail = readLogTail(bridgeLog);
-            if (bridgeTail) {
-              lines.push("---- bridge log tail ----");
-              lines.push(bridgeTail.trimEnd());
-              lines.push("---- end bridge log tail ----");
-            }
-          }
-          let daemonCloseWarning = null;
-          try {
-            await ipcCall(socketPath, { method: "close", params: {} });
-          } catch (error) {
-            daemonCloseWarning = `failed to stop daemon after bridge startup failure: ${error instanceof Error ? error.message : String(error)}`;
-          }
-          if (daemonCloseWarning) {
-            lines.push(`Warning: ${daemonCloseWarning}`);
-          }
-          await cleanupLiveOnStartFailure(apiClient, target);
-          failCli(lines.join("\n"));
-        }
-      }
-      console.log(`Live started: ${target.url}`);
-      const tma = getTelegramMiniAppUrl(target.slug);
-      if (tma) console.log(`Telegram: ${tma}`);
-      console.log(`Slug: ${target.slug}`);
-      console.log(`Expires: ${new Date(target.expiresAt).toISOString()}`);
-      if (target.mode === "existing") console.log("Mode: attached existing live");
-      console.log("Daemon health: OK");
-      console.log(`Daemon log: ${logPath}`);
-      if (bridgeMode !== "none") {
-        console.log("Bridge mode: openclaw");
-        console.log(`Bridge log: ${bridgeLogPath(target.slug)}`);
-      }
-    }
-  );
-}
-function registerCloseCommand(program2) {
-  program2.command("close").description("Close a live and stop its daemon").argument("<slug>", "Pub slug").action(async (slug) => {
-    const bridgeError = await stopBridge(slug);
-    if (bridgeError) console.error(bridgeError);
-    fs2.rmSync(bridgeInfoPath(slug), { force: true });
-    const socketPath = getSocketPath(slug);
-    if (isDaemonRunning(slug)) {
-      try {
-        await ipcCall(socketPath, { method: "close", params: {} });
       } catch (error) {
-        console.error(
-          `Warning: failed to stop daemon over IPC for ${slug}: ${error instanceof Error ? error.message : String(error)}`
-        );
+        const message = error instanceof Error ? error.message : String(error);
+        failCli(`Daemon failed: ${message}`);
       }
+      return;
     }
-    const apiClient = createApiClient();
-    try {
-      await apiClient.closeLive(slug);
-    } catch (error) {
-      const message = formatApiError(error);
-      if (!/Live not found/i.test(message)) {
-        failCli(`Failed to close live for ${slug}: ${message}`);
-      }
+    const { fork } = await import("child_process");
+    const daemonScript = path2.join(import.meta.dirname, "tunnel-daemon-entry.js");
+    const daemonLogFd = fs2.openSync(logPath, "a");
+    const child = fork(daemonScript, [], {
+      detached: true,
+      stdio: buildDaemonForkStdio(daemonLogFd),
+      env: {
+        ...bridgeProcessEnv,
+        PUBBLUE_DAEMON_BASE_URL: runtimeConfig.baseUrl,
+        PUBBLUE_DAEMON_API_KEY: runtimeConfig.apiKey,
+        PUBBLUE_DAEMON_SOCKET: socketPath,
+        PUBBLUE_DAEMON_INFO: infoPath,
+        PUBBLUE_DAEMON_AGENT_NAME: opts.agentName,
+        PUBBLUE_CLI_VERSION: CLI_VERSION,
+        PUBBLUE_DAEMON_BRIDGE_MODE: bridgeMode
+      }
+    });
+    fs2.closeSync(daemonLogFd);
+    if (child.connected) {
+      child.disconnect();
     }
-    console.log(`Closed: ${slug}`);
+    child.unref();
+    console.log("Starting agent daemon...");
+    const ready = await waitForDaemonReady({
+      child,
+      infoPath,
+      socketPath,
+      timeoutMs: 8e3
+    });
+    if (!ready.ok) {
+      const lines = [
+        `Daemon failed to start: ${ready.reason ?? "unknown reason"}`,
+        `Daemon log: ${logPath}`
+      ];
+      const tail = readLogTail(logPath);
+      if (tail) {
+        lines.push("---- daemon log tail ----");
+        lines.push(tail.trimEnd());
+        lines.push("---- end daemon log tail ----");
+      }
+      failCli(lines.join("\n"));
+    }
+    console.log("Agent daemon started. Waiting for browser to initiate live.");
+    console.log(`Daemon log: ${logPath}`);
+    console.log(`Bridge mode: ${bridgeMode}`);
+  });
+}
+function registerStopCommand(program2) {
+  program2.command("stop").description("Stop the agent daemon (deregisters presence, closes active live)").action(async () => {
+    if (!isDaemonRunning("agent")) {
+      console.log("Agent daemon is not running.");
+      return;
+    }
+    await stopOtherDaemons();
+    console.log("Agent daemon stopped.");
   });
 }
 function registerStatusCommand(program2) {
-  program2.command("status").description("Check live connection status").argument("[slug]", "Pub slug").option("-s, --slug <slug>", "Pub slug (alternative to positional arg)").action(async (slugArg, opts) => {
-    const slug = resolveSlugSelection(slugArg, opts.slug) || await resolveActiveSlug();
-    const socketPath = getSocketPath(slug);
-    const response = await ipcCall(socketPath, { method: "status", params: {} });
+  program2.command("status").description("Check agent daemon and live connection status").action(async () => {
+    const socketPath = getAgentSocketPath();
+    let response;
+    try {
+      response = await ipcCall(socketPath, { method: "status", params: {} });
+    } catch {
+      console.log("Agent daemon is not running.");
+      return;
+    }
+    const activeSlug = response.activeSlug;
+    console.log(`  Daemon: running`);
+    console.log(`  Active slug: ${activeSlug || "(none)"}`);
     console.log(`  Status: ${response.connected ? "connected" : "waiting"}`);
     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(", ")}`);
+    console.log(`  Channels: ${chNames.join(", ") || "(none)"}`);
     console.log(`  Buffered: ${response.bufferedMessages ?? 0} messages`);
     if (typeof response.lastError === "string" && response.lastError.length > 0) {
       console.log(`  Last error: ${response.lastError}`);
     }
-    const logPath = liveLogPath(slug);
+    const logPath = liveLogPath("agent");
     if (fs2.existsSync(logPath)) {
       console.log(`  Log: ${logPath}`);
     }
-    const bridgeInfo = readBridgeProcessInfo(slug);
-    if (bridgeInfo) {
-      const bridgeRunning = isBridgeRunning(slug);
-      const bridgeState = bridgeInfo.status || (bridgeRunning ? "running" : "stopped");
-      console.log(`  Bridge: ${bridgeInfo.mode} (${bridgeState})`);
-      if (bridgeInfo.sessionId) {
-        console.log(`  Bridge session: ${bridgeInfo.sessionId}`);
+    const bridge = response.bridge;
+    if (bridge) {
+      console.log(`  Bridge: openclaw (${bridge.running ? "running" : "stopped"})`);
+      if (bridge.sessionId) {
+        console.log(`  Bridge session: ${bridge.sessionId}`);
       }
-      if (bridgeInfo.sessionSource) {
-        console.log(`  Bridge session source: ${bridgeInfo.sessionSource}`);
+      if (bridge.sessionSource) {
+        console.log(`  Bridge session source: ${bridge.sessionSource}`);
       }
-      if (bridgeInfo.sessionKey) {
-        console.log(`  Bridge session key: ${bridgeInfo.sessionKey}`);
+      if (bridge.sessionKey) {
+        console.log(`  Bridge session key: ${bridge.sessionKey}`);
       }
-      if (bridgeInfo.lastError) {
-        console.log(`  Bridge last error: ${bridgeInfo.lastError}`);
+      if (bridge.forwardedMessages !== void 0) {
+        console.log(`  Bridge forwarded: ${bridge.forwardedMessages} messages`);
+      }
+      if (bridge.lastError) {
+        console.log(`  Bridge last error: ${bridge.lastError}`);
       }
-    }
-    const bridgeLog = bridgeLogPath(slug);
-    if (fs2.existsSync(bridgeLog)) {
-      console.log(`  Bridge log: ${bridgeLog}`);
     }
   });
 }
 function registerWriteCommand(program2) {
-  program2.command("write").description("Write data to a live channel").argument("[message]", "Text message (or use --file)").option("-s, --slug <slug>", "Pub slug (auto-detected if one active)").option("-c, --channel <channel>", "Channel name", "chat").option("-f, --file <file>", "Read content from file").action(
-    async (messageArg, opts) => {
-      let msg;
-      let binaryBase64;
-      if (opts.file) {
-        const filePath = path2.resolve(opts.file);
-        const ext = path2.extname(filePath).toLowerCase();
-        const bytes = fs2.readFileSync(filePath);
-        const filename = path2.basename(filePath);
-        if (ext === ".html" || ext === ".htm") {
-          msg = {
-            id: generateMessageId(),
-            type: "html",
-            data: bytes.toString("utf-8"),
-            meta: { title: filename, filename, mime: getMimeType(filePath), size: bytes.length }
-          };
-        } else if (TEXT_FILE_EXTENSIONS.has(ext)) {
-          msg = {
-            id: generateMessageId(),
-            type: "text",
-            data: bytes.toString("utf-8"),
-            meta: { filename, mime: getMimeType(filePath), size: bytes.length }
-          };
-        } else {
-          msg = {
-            id: generateMessageId(),
-            type: "binary",
-            meta: { filename, mime: getMimeType(filePath), size: bytes.length }
-          };
-          binaryBase64 = bytes.toString("base64");
-        }
-      } else if (messageArg) {
+  program2.command("write").description("Write data to a live channel").argument("[message]", "Text message (or use --file)").option("-c, --channel <channel>", "Channel name", "chat").option("-f, --file <file>", "Read content from file").action(async (messageArg, opts) => {
+    let msg;
+    let binaryBase64;
+    if (opts.file) {
+      const filePath = path2.resolve(opts.file);
+      const ext = path2.extname(filePath).toLowerCase();
+      const bytes = fs2.readFileSync(filePath);
+      const filename = path2.basename(filePath);
+      if (ext === ".html" || ext === ".htm") {
+        msg = {
+          id: generateMessageId(),
+          type: "html",
+          data: bytes.toString("utf-8"),
+          meta: { title: filename, filename, mime: getMimeType(filePath), size: bytes.length }
+        };
+      } else if (TEXT_FILE_EXTENSIONS.has(ext)) {
         msg = {
           id: generateMessageId(),
           type: "text",
-          data: messageArg
+          data: bytes.toString("utf-8"),
+          meta: { filename, mime: getMimeType(filePath), size: bytes.length }
         };
       } else {
-        const chunks = [];
-        for await (const chunk of process.stdin) chunks.push(chunk);
         msg = {
           id: generateMessageId(),
-          type: "text",
-          data: Buffer.concat(chunks).toString("utf-8").trim()
+          type: "binary",
+          meta: { filename, mime: getMimeType(filePath), size: bytes.length }
         };
+        binaryBase64 = bytes.toString("base64");
       }
-      const slug = opts.slug || await resolveActiveSlug();
-      const socketPath = getSocketPath(slug);
-      const response = await ipcCall(socketPath, {
-        method: "write",
-        params: { channel: opts.channel, msg, binaryBase64 }
-      });
-      if (!response.ok) {
-        failCli(`Failed: ${response.error}`);
-      }
+    } else if (messageArg) {
+      msg = {
+        id: generateMessageId(),
+        type: "text",
+        data: messageArg
+      };
+    } else {
+      const chunks = [];
+      for await (const chunk of process.stdin) chunks.push(chunk);
+      msg = {
+        id: generateMessageId(),
+        type: "text",
+        data: Buffer.concat(chunks).toString("utf-8").trim()
+      };
     }
-  );
+    const socketPath = getAgentSocketPath();
+    const response = await ipcCall(socketPath, {
+      method: "write",
+      params: { channel: opts.channel, msg, binaryBase64 }
+    });
+    if (!response.ok) {
+      failCli(`Failed: ${response.error}`);
+    }
+  });
 }
 function registerReadCommand(program2) {
-  program2.command("read").description("Read buffered messages from live channels").argument("[slug]", "Pub slug (auto-detected if one active)").option("-s, --slug <slug>", "Pub slug (alternative to positional arg)").option("-c, --channel <channel>", "Filter by channel").option("--follow", "Stream messages continuously").option("--all", "With --follow, include all channels instead of chat-only default").action(
-    async (slugArg, opts) => {
-      const slug = resolveSlugSelection(slugArg, opts.slug) || await resolveActiveSlug();
-      const socketPath = getSocketPath(slug);
-      const readChannel = opts.channel || (opts.follow && !opts.all ? CHANNELS.CHAT : void 0);
-      if (opts.follow) {
-        if (!opts.channel && !opts.all) {
-          console.error(
-            "Following chat channel by default. Use `--all` to include binary/file channels."
-          );
-        }
-        let consecutiveFailures = 0;
-        let warnedDisconnected = false;
-        while (true) {
-          try {
-            const response = await ipcCall(socketPath, {
-              method: "read",
-              params: { channel: readChannel }
-            });
-            if (warnedDisconnected) {
-              console.error("Daemon reconnected.");
-              warnedDisconnected = false;
-            }
-            consecutiveFailures = 0;
-            if (response.messages && response.messages.length > 0) {
-              for (const m of response.messages) {
-                console.log(JSON.stringify(m));
-              }
-            }
-          } catch (error) {
-            consecutiveFailures += 1;
-            if (!warnedDisconnected) {
-              const detail = error instanceof Error ? ` ${error.message}` : "";
-              console.error(`Daemon disconnected. Waiting for recovery...${detail}`);
-              warnedDisconnected = true;
+  program2.command("read").description("Read buffered messages from live channels").option("-c, --channel <channel>", "Filter by channel").option("--follow", "Stream messages continuously").option("--all", "With --follow, include all channels instead of chat-only default").action(async (opts) => {
+    const socketPath = getAgentSocketPath();
+    const readChannel = opts.channel || (opts.follow && !opts.all ? CHANNELS.CHAT : void 0);
+    if (opts.follow) {
+      if (!opts.channel && !opts.all) {
+        console.error(
+          "Following chat channel by default. Use `--all` to include binary/file channels."
+        );
+      }
+      let consecutiveFailures = 0;
+      let warnedDisconnected = false;
+      while (true) {
+        try {
+          const response = await ipcCall(socketPath, {
+            method: "read",
+            params: { channel: readChannel }
+          });
+          if (warnedDisconnected) {
+            console.error("Daemon reconnected.");
+            warnedDisconnected = false;
+          }
+          consecutiveFailures = 0;
+          if (response.messages && response.messages.length > 0) {
+            for (const m of response.messages) {
+              console.log(JSON.stringify(m));
             }
           }
-          const delayMs = getFollowReadDelayMs(warnedDisconnected, consecutiveFailures);
-          await new Promise((resolve3) => setTimeout(resolve3, delayMs));
-        }
-      } else {
-        const response = await ipcCall(socketPath, {
-          method: "read",
-          params: { channel: readChannel }
-        });
-        if (!response.ok) {
-          failCli(`Failed: ${response.error}`);
+        } catch (error) {
+          consecutiveFailures += 1;
+          if (!warnedDisconnected) {
+            const detail = error instanceof Error ? ` ${error.message}` : "";
+            console.error(`Daemon disconnected. Waiting for recovery...${detail}`);
+            warnedDisconnected = true;
+          }
         }
-        console.log(JSON.stringify(response.messages || [], null, 2));
+        const delayMs = getFollowReadDelayMs(warnedDisconnected, consecutiveFailures);
+        await new Promise((resolve3) => setTimeout(resolve3, delayMs));
       }
+    } else {
+      const response = await ipcCall(socketPath, {
+        method: "read",
+        params: { channel: readChannel }
+      });
+      if (!response.ok) {
+        failCli(`Failed: ${response.error}`);
+      }
+      console.log(JSON.stringify(response.messages || [], null, 2));
     }
-  );
+  });
 }
 function registerChannelsCommand(program2) {
-  program2.command("channels").description("List active live channels").argument("[slug]", "Pub slug").option("-s, --slug <slug>", "Pub slug (alternative to positional arg)").action(async (slugArg, opts) => {
-    const slug = resolveSlugSelection(slugArg, opts.slug) || await resolveActiveSlug();
-    const socketPath = getSocketPath(slug);
+  program2.command("channels").description("List active live channels").action(async () => {
+    const socketPath = getAgentSocketPath();
     const response = await ipcCall(socketPath, { method: "channels", params: {} });
     if (response.channels) {
       for (const ch of response.channels) {
@@ -996,12 +707,12 @@ function registerChannelsCommand(program2) {
   });
 }
 function registerDoctorCommand(program2) {
-  program2.command("doctor").description("Run end-to-end live checks (daemon, channels, chat/canvas ping)").option("-s, --slug <slug>", "Pub slug (auto-detected if one active)").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(
+  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 timeoutMs = timeoutSeconds * 1e3;
-      const slug = opts.slug || await resolveActiveSlug();
-      const socketPath = getSocketPath(slug);
+      const socketPath = getAgentSocketPath();
+      const slug = await resolveActiveSlug();
       const apiClient = createApiClient();
       const fail = (message) => failCli(`Doctor failed: ${message}`);
       console.log(`Doctor: ${slug}`);
@@ -1047,8 +758,11 @@ function registerDoctorCommand(program2) {
       if (live.expiresAt <= Date.now()) {
         fail("API reports live is expired.");
       }
-      if (typeof live.agentOffer !== "string" || live.agentOffer.length === 0) {
-        fail("agent offer was not published.");
+      if (typeof live.browserOffer !== "string" || live.browserOffer.length === 0) {
+        fail("browser offer was not published.");
+      }
+      if (typeof live.agentAnswer !== "string" || live.agentAnswer.length === 0) {
+        fail("agent answer was not published.");
       }
       console.log("API/signaling check: OK");
       if (!opts.skipChat) {
@@ -1117,7 +831,7 @@ 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)").option("--expires <duration>", "Auto-delete after duration (e.g. 1h, 24h, 7d)").option("--open", "Also open an interactive session immediately").option("--bridge <mode>", "Bridge mode if --open (openclaw/none)").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").option("--public", "Make the pub public").option("--private", "Make the pub private (default)").option("--expires <duration>", "Auto-delete after duration (e.g. 1h, 24h, 7d)").action(
     async (fileArg, opts) => {
       const client = createClient();
       let content;
@@ -1126,7 +840,7 @@ function registerPubCommands(program2) {
         const file = readFile(fileArg);
         content = file.content;
         filename = file.basename;
-      } else if (!opts.open) {
+      } else {
         content = await readFromStdin();
       }
       const resolvedVisibility = resolveVisibilityFlags({
@@ -1148,10 +862,6 @@ function registerPubCommands(program2) {
       if (result.expiresAt) {
         console.log(`  Expires: ${new Date(result.expiresAt).toISOString()}`);
       }
-      if (opts.open) {
-        console.log(`
-To open an interactive session, use: pubblue open ${result.slug}`);
-      }
     }
   );
   program2.command("get").description("Get details of a pub").argument("<slug>", "Slug of the pub").option("--content", "Output raw content to stdout (no metadata, pipeable)").action(async (slug, opts) => {