pubblue 0.4.12 → 0.6.1

package/dist/index.js

@@ -1,55 +1,37 @@
 #!/usr/bin/env node
-import {
-  getSocketPath,
-  ipcCall
-} from "./chunk-HJ5LTUHS.js";
-import {
-  TunnelApiClient,
-  TunnelApiError
-} from "./chunk-7NFHPJ76.js";
 import {
   CHANNELS,
   CONTROL_CHANNEL,
-  generateMessageId
-} from "./chunk-4YTJ2WKF.js";
-
-// src/lib/cli-error.ts
-import { CommanderError } from "commander";
-var CliError = class extends Error {
-  exitCode;
-  constructor(message, exitCode = 1) {
-    super(message);
-    this.name = "CliError";
-    this.exitCode = exitCode;
-  }
-};
-function failCli(message, exitCode = 1) {
-  throw new CliError(message, exitCode);
-}
-function toCliFailure(error) {
-  if (error instanceof CommanderError) {
-    return {
-      exitCode: error.exitCode,
-      message: ""
-    };
-  }
-  if (error instanceof CliError) {
-    return {
-      exitCode: error.exitCode,
-      message: error.message
-    };
-  }
-  if (error instanceof Error) {
-    return {
-      exitCode: 1,
-      message: error.message
-    };
-  }
-  return {
-    exitCode: 1,
-    message: String(error)
-  };
-}
+  PubApiClient,
+  TEXT_FILE_EXTENSIONS,
+  buildBridgeProcessEnv,
+  buildDaemonForkStdio,
+  createApiClient,
+  ensureNodeDatachannelAvailable,
+  failCli,
+  formatApiError,
+  generateMessageId,
+  getAgentSocketPath,
+  getConfig,
+  getFollowReadDelayMs,
+  getMimeType,
+  getTelegramMiniAppUrl,
+  ipcCall,
+  isDaemonRunning,
+  liveInfoPath,
+  liveLogPath,
+  loadConfig,
+  messageContainsPong,
+  parsePositiveIntegerOption,
+  readLogTail,
+  resolveActiveSlug,
+  resolveBridgeMode,
+  saveConfig,
+  stopOtherDaemons,
+  toCliFailure,
+  waitForDaemonReady,
+  writeLatestCliVersion
+} from "./chunk-BBJOOZHS.js";
 
 // src/program.ts
 import { Command } from "commander";
@@ -57,136 +39,9 @@ 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 loadConfig(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 = loadConfig(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(type, id) {
-  const saved = loadConfig();
-  if (!saved?.telegram?.botUsername) return null;
-  return `https://t.me/${saved.telegram.botUsername}?startapp=${type === "pub" ? "p" : "t"}_${id}`;
-}
-
-// src/commands/shared.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-
-// src/lib/api.ts
-var PubApiClient = class {
-  constructor(baseUrl, apiKey) {
-    this.baseUrl = baseUrl;
-    this.apiKey = apiKey;
-  }
-  async request(path6, options = {}) {
-    const url = new URL(path6, this.baseUrl);
-    const res = await fetch(url, {
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`,
-        ...options.headers
-      }
-    });
-    const data = await res.json();
-    if (!res.ok) {
-      throw new Error(data.error || `Request failed with status ${res.status}`);
-    }
-    return data;
-  }
-  async create(opts) {
-    return this.request("/api/v1/publications", {
-      method: "POST",
-      body: JSON.stringify(opts)
-    });
-  }
-  async get(slug) {
-    const data = await this.request(`/api/v1/publications/${encodeURIComponent(slug)}`);
-    return data.publication;
-  }
-  async listPage(cursor, limit) {
-    const params = new URLSearchParams();
-    if (cursor) params.set("cursor", cursor);
-    if (limit) params.set("limit", String(limit));
-    const qs = params.toString();
-    return this.request(`/api/v1/publications${qs ? `?${qs}` : ""}`);
-  }
-  async list() {
-    const all = [];
-    let cursor;
-    do {
-      const result = await this.listPage(cursor, 100);
-      all.push(...result.publications);
-      cursor = result.hasMore ? result.cursor : void 0;
-    } while (cursor);
-    return all;
-  }
-  async update(opts) {
-    const { slug, newSlug, ...rest } = opts;
-    const body = { ...rest };
-    if (newSlug) body.slug = newSlug;
-    return this.request(`/api/v1/publications/${encodeURIComponent(slug)}`, {
-      method: "PATCH",
-      body: JSON.stringify(body)
-    });
-  }
-  async remove(slug) {
-    await this.request(`/api/v1/publications/${encodeURIComponent(slug)}`, {
-      method: "DELETE"
-    });
-  }
-};
-
-// src/commands/shared.ts
 function createClient() {
   const config = getConfig();
   return new PubApiClient(config.baseUrl, config.apiKey);
@@ -210,13 +65,13 @@ 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)
   };
 }
 
@@ -271,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) {
@@ -284,7 +134,6 @@ function parsePositiveInteger(raw, key) {
   return parsed;
 }
 var SUPPORTED_KEYS = [
-  "bridge.mode",
   "openclaw.path",
   "openclaw.sessionId",
   "openclaw.threadId",
@@ -299,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;
@@ -347,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;
@@ -407,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) {
@@ -428,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}`);
@@ -503,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) {
@@ -511,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("");
@@ -534,525 +388,316 @@ function registerConfigureCommand(program2) {
   );
 }
 
-// src/commands/publications.ts
-function registerPublicationCommands(program2) {
-  program2.command("create").description("Create a new publication").argument("[file]", "Path to the file (reads stdin if omitted)").option("--slug <slug>", "Custom slug for the URL").option("--title <title>", "Title for the publication").option("--public", "Make the publication public").option("--private", "Make the publication private (default)").option("--expires <duration>", "Auto-delete after duration (e.g. 1h, 24h, 7d)").action(
-    async (fileArg, opts) => {
-      const client = createClient();
-      let content;
-      let filename;
-      if (fileArg) {
-        const file = readFile(fileArg);
-        content = file.content;
-        filename = file.basename;
-      } else {
-        content = await readFromStdin();
-      }
-      const resolvedVisibility = resolveVisibilityFlags({
-        public: opts.public,
-        private: opts.private,
-        commandName: "create"
-      });
-      const result = await client.create({
-        content,
-        filename,
-        title: opts.title,
-        slug: opts.slug,
-        isPublic: resolvedVisibility ?? false,
-        expiresIn: opts.expires
-      });
-      console.log(`Created: ${result.url}`);
-      const tmaUrl = getTelegramMiniAppUrl("pub", result.slug);
-      if (tmaUrl) console.log(`Telegram: ${tmaUrl}`);
-      if (result.expiresAt) {
-        console.log(`  Expires: ${new Date(result.expiresAt).toISOString()}`);
+// src/commands/live.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// package.json
+var package_default = {
+  name: "pubblue",
+  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 --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"
+  },
+  dependencies: {
+    commander: "^13.0.0",
+    "node-datachannel": "^0.32.0"
+  },
+  devDependencies: {
+    "@types/node": "22.10.2",
+    tsup: "^8.3.6",
+    typescript: "^5.7.2",
+    vitest: "^3.0.0"
+  },
+  files: [
+    "dist"
+  ],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/xmanatee/pub.git",
+    directory: "cli"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  pnpm: {
+    onlyBuiltDependencies: [
+      "esbuild",
+      "node-datachannel"
+    ]
+  }
+};
+
+// src/lib/version.ts
+var version = package_default.version;
+if (typeof version !== "string" || version.length === 0) {
+  throw new Error("Invalid CLI version in package.json");
+}
+var CLI_VERSION = version;
+
+// src/commands/live.ts
+function registerLiveCommands(program2) {
+  registerStartCommand(program2);
+  registerStopCommand(program2);
+  registerStatusCommand(program2);
+  registerWriteCommand(program2);
+  registerReadCommand(program2);
+  registerChannelsCommand(program2);
+  registerDoctorCommand(program2);
+}
+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 startDaemon({
+          cliVersion: CLI_VERSION,
+          apiClient,
+          socketPath,
+          infoPath,
+          bridgeMode,
+          agentName: opts.agentName
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        failCli(`Daemon failed: ${message}`);
       }
-    }
-  );
-  program2.command("get").description("Get details of a publication").argument("<slug>", "Slug of the publication").option("--content", "Output raw content to stdout (no metadata, pipeable)").action(async (slug, opts) => {
-    const client = createClient();
-    const pub = await client.get(slug);
-    if (opts.content) {
-      process.stdout.write(pub.content);
       return;
     }
-    console.log(`  Slug:    ${pub.slug}`);
-    console.log(`  Type:    ${pub.contentType}`);
-    if (pub.title) console.log(`  Title:   ${pub.title}`);
-    console.log(`  Status:  ${formatVisibility(pub.isPublic)}`);
-    if (pub.expiresAt) console.log(`  Expires: ${new Date(pub.expiresAt).toISOString()}`);
-    console.log(`  Created: ${new Date(pub.createdAt).toLocaleDateString()}`);
-    console.log(`  Updated: ${new Date(pub.updatedAt).toLocaleDateString()}`);
-    console.log(`  Size:    ${pub.content.length} bytes`);
-  });
-  program2.command("update").description("Update a publication's content and/or metadata").argument("<slug>", "Slug of the publication to update").option("--file <file>", "New content from file").option("--title <title>", "New title").option("--public", "Make the publication public").option("--private", "Make the publication private").option("--slug <newSlug>", "Rename the slug").action(
-    async (slug, opts) => {
-      const client = createClient();
-      let content;
-      let filename;
-      if (opts.file) {
-        const file = readFile(opts.file);
-        content = file.content;
-        filename = file.basename;
+    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
       }
-      const isPublic = resolveVisibilityFlags({
-        public: opts.public,
-        private: opts.private,
-        commandName: "update"
-      });
-      const result = await client.update({
-        slug,
-        content,
-        filename,
-        title: opts.title,
-        isPublic,
-        newSlug: opts.slug
-      });
-      console.log(`Updated: ${result.slug}`);
-      if (result.title) console.log(`  Title:  ${result.title}`);
-      console.log(`  Status: ${formatVisibility(result.isPublic)}`);
-    }
-  );
-  program2.command("list").description("List your publications").action(async () => {
-    const client = createClient();
-    const pubs = await client.list();
-    if (pubs.length === 0) {
-      console.log("No publications.");
-      return;
+    });
+    fs2.closeSync(daemonLogFd);
+    if (child.connected) {
+      child.disconnect();
     }
-    for (const pub of pubs) {
-      const date = new Date(pub.createdAt).toLocaleDateString();
-      const expires = pub.expiresAt ? ` expires:${new Date(pub.expiresAt).toISOString()}` : "";
-      console.log(
-        `  ${pub.slug}  [${pub.contentType}]  ${formatVisibility(pub.isPublic)}  ${date}${expires}`
-      );
+    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}`);
   });
-  program2.command("delete").description("Delete a publication").argument("<slug>", "Slug of the publication to delete").action(async (slug) => {
-    const client = createClient();
-    await client.remove(slug);
-    console.log(`Deleted: ${slug}`);
-  });
-}
-
-// src/commands/tunnel/management-commands.ts
-import * as fs4 from "fs";
-
-// src/commands/tunnel-helpers.ts
-import { fork } from "child_process";
-import * as fs3 from "fs";
-import * as path3 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"
-]);
-function getMimeType(filePath) {
-  const ext = path3.extname(filePath).toLowerCase();
-  const mimeByExt = {
-    ".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",
-    ".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"
-  };
-  return mimeByExt[ext] || "application/octet-stream";
-}
-function tunnelInfoDir() {
-  const dir = path3.join(
-    process.env.HOME || process.env.USERPROFILE || "/tmp",
-    ".config",
-    "pubblue",
-    "tunnels"
-  );
-  if (!fs3.existsSync(dir)) fs3.mkdirSync(dir, { recursive: true });
-  return dir;
-}
-function tunnelInfoPath(tunnelId) {
-  return path3.join(tunnelInfoDir(), `${tunnelId}.json`);
-}
-function tunnelLogPath(tunnelId) {
-  return path3.join(tunnelInfoDir(), `${tunnelId}.log`);
-}
-function bridgeInfoPath(tunnelId) {
-  return path3.join(tunnelInfoDir(), `${tunnelId}.bridge.json`);
 }
-function bridgeLogPath(tunnelId) {
-  return path3.join(tunnelInfoDir(), `${tunnelId}.bridge.log`);
-}
-function createApiClient(configOverride) {
-  const config = configOverride || getConfig();
-  return new TunnelApiClient(config.baseUrl, config.apiKey);
-}
-function buildBridgeProcessEnv(bridgeConfig) {
-  const env = { ...process.env };
-  if (!bridgeConfig) return env;
-  const setIfMissing = (key, value) => {
-    if (value === void 0 || value === null) return;
-    const current = env[key];
-    if (typeof current === "string" && current.length > 0) return;
-    env[key] = String(value);
-  };
-  setIfMissing("OPENCLAW_PATH", bridgeConfig.openclawPath);
-  setIfMissing("OPENCLAW_SESSION_ID", bridgeConfig.sessionId);
-  setIfMissing("OPENCLAW_THREAD_ID", bridgeConfig.threadId);
-  if (bridgeConfig.canvasReminderEvery !== void 0) {
-    setIfMissing("OPENCLAW_CANVAS_REMINDER_EVERY", bridgeConfig.canvasReminderEvery);
-  }
-  if (bridgeConfig.deliver !== void 0) {
-    setIfMissing("OPENCLAW_DELIVER", bridgeConfig.deliver ? "1" : "0");
-  }
-  setIfMissing("OPENCLAW_DELIVER_CHANNEL", bridgeConfig.deliverChannel);
-  setIfMissing("OPENCLAW_REPLY_TO", bridgeConfig.replyTo);
-  if (bridgeConfig.deliverTimeoutMs !== void 0) {
-    setIfMissing("OPENCLAW_DELIVER_TIMEOUT_MS", bridgeConfig.deliverTimeoutMs);
-  }
-  setIfMissing("OPENCLAW_ATTACHMENT_DIR", bridgeConfig.attachmentDir);
-  if (bridgeConfig.attachmentMaxBytes !== void 0) {
-    setIfMissing("OPENCLAW_ATTACHMENT_MAX_BYTES", bridgeConfig.attachmentMaxBytes);
-  }
-  return env;
-}
-async function ensureNodeDatachannelAvailable() {
-  try {
-    await import("node-datachannel");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    failCli(
-      [
-        "node-datachannel native module is not available.",
-        "Run `pnpm rebuild node-datachannel` in the cli package and retry.",
-        `Details: ${message}`
-      ].join("\n")
-    );
-  }
-}
-function isDaemonRunning(tunnelId) {
-  return readDaemonProcessInfo(tunnelId) !== null;
-}
-function readDaemonProcessInfo(tunnelId) {
-  const infoPath = tunnelInfoPath(tunnelId);
-  if (!fs3.existsSync(infoPath)) return null;
-  try {
-    const info = JSON.parse(fs3.readFileSync(infoPath, "utf-8"));
-    if (!Number.isFinite(info.pid)) throw new Error("invalid daemon pid");
-    process.kill(info.pid, 0);
-    return info;
-  } catch {
-    try {
-      fs3.unlinkSync(infoPath);
-    } catch {
+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;
     }
-    return null;
-  }
-}
-function readBridgeProcessInfo(tunnelId) {
-  const infoPath = bridgeInfoPath(tunnelId);
-  if (!fs3.existsSync(infoPath)) return null;
-  try {
-    return JSON.parse(fs3.readFileSync(infoPath, "utf-8"));
-  } catch {
-    return null;
-  }
+    await stopOtherDaemons();
+    console.log("Agent daemon stopped.");
+  });
 }
-function isBridgeRunning(tunnelId) {
-  const infoPath = bridgeInfoPath(tunnelId);
-  if (!fs3.existsSync(infoPath)) return false;
-  try {
-    const info = JSON.parse(fs3.readFileSync(infoPath, "utf-8"));
-    process.kill(info.pid, 0);
-    return true;
-  } catch {
+function registerStatusCommand(program2) {
+  program2.command("status").description("Check agent daemon and live connection status").action(async () => {
+    const socketPath = getAgentSocketPath();
+    let response;
     try {
-      fs3.unlinkSync(infoPath);
+      response = await ipcCall(socketPath, { method: "status", params: {} });
     } catch {
+      console.log("Agent daemon is not running.");
+      return;
     }
-    return false;
-  }
-}
-function stopBridgeProcess(tunnelId) {
-  const info = readBridgeProcessInfo(tunnelId);
-  if (!info || !Number.isFinite(info.pid)) return;
-  try {
-    process.kill(info.pid, "SIGTERM");
-  } catch {
-  }
-}
-function buildBridgeForkStdio(logFd) {
-  return ["ignore", logFd, logFd, "ipc"];
-}
-function getFollowReadDelayMs(disconnected, consecutiveFailures) {
-  if (!disconnected) return 1e3;
-  return Math.min(5e3, 1e3 * 2 ** Math.min(consecutiveFailures, 3));
-}
-function resolveTunnelIdSelection(tunnelIdArg, tunnelOpt) {
-  return tunnelOpt || tunnelIdArg;
-}
-function buildDaemonForkStdio(logFd) {
-  return ["ignore", logFd, logFd, "ipc"];
+    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(", ") || "(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("agent");
+    if (fs2.existsSync(logPath)) {
+      console.log(`  Log: ${logPath}`);
+    }
+    const bridge = response.bridge;
+    if (bridge) {
+      console.log(`  Bridge: openclaw (${bridge.running ? "running" : "stopped"})`);
+      if (bridge.sessionId) {
+        console.log(`  Bridge session: ${bridge.sessionId}`);
+      }
+      if (bridge.sessionSource) {
+        console.log(`  Bridge session source: ${bridge.sessionSource}`);
+      }
+      if (bridge.sessionKey) {
+        console.log(`  Bridge session key: ${bridge.sessionKey}`);
+      }
+      if (bridge.forwardedMessages !== void 0) {
+        console.log(`  Bridge forwarded: ${bridge.forwardedMessages} messages`);
+      }
+      if (bridge.lastError) {
+        console.log(`  Bridge last error: ${bridge.lastError}`);
+      }
+    }
+  });
 }
-function parsePositiveIntegerOption(raw, optionName) {
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new Error(`${optionName} must be a positive integer. Received: ${raw}`);
-  }
-  return parsed;
-}
-function parseBridgeMode(raw) {
-  const normalized = raw.trim().toLowerCase();
-  if (normalized === "openclaw" || normalized === "none") {
-    return normalized;
-  }
-  throw new Error(`--bridge must be one of: openclaw, none. Received: ${raw}`);
-}
-function shouldRestartDaemonForCliUpgrade(daemonCliVersion, currentCliVersion) {
-  if (!daemonCliVersion || daemonCliVersion.trim().length === 0) return true;
-  return daemonCliVersion.trim() !== currentCliVersion;
-}
-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 getPublicTunnelUrl(tunnelId) {
-  const base = process.env.PUBBLUE_PUBLIC_URL || "https://pub.blue";
-  return `${base.replace(/\/$/, "")}/t/${tunnelId}`;
-}
-function pickReusableTunnel(tunnels, nowMs = Date.now()) {
-  const active = tunnels.filter((t) => t.status === "active" && t.expiresAt > nowMs).sort((a, b) => b.createdAt - a.createdAt);
-  return active[0] ?? null;
-}
-function readLogTail(logPath, maxChars = 4e3) {
-  if (!fs3.existsSync(logPath)) return null;
-  try {
-    const content = fs3.readFileSync(logPath, "utf-8");
-    if (content.length <= maxChars) return content;
-    return content.slice(-maxChars);
-  } catch {
-    return null;
-  }
-}
-function formatApiError(error) {
-  if (error instanceof TunnelApiError) {
-    if (error.status === 429 && error.retryAfterSeconds !== void 0) {
-      return `Rate limit exceeded. Retry after ${error.retryAfterSeconds}s.`;
-    }
-    return `${error.message} (HTTP ${error.status})`;
-  }
-  return error instanceof Error ? error.message : String(error);
-}
-async function cleanupCreatedTunnelOnStartFailure(apiClient, target) {
-  if (!target.createdNew) return;
-  try {
-    await apiClient.close(target.tunnelId);
-  } catch (closeError) {
-    console.error(
-      `Failed to clean up newly created tunnel ${target.tunnelId}: ${formatApiError(closeError)}`
-    );
-  }
-}
-async function resolveActiveTunnel() {
-  const dir = tunnelInfoDir();
-  const files = fs3.readdirSync(dir).filter((f) => f.endsWith(".json") && !f.endsWith(".bridge.json"));
-  const active = [];
-  for (const f of files) {
-    const tunnelId = f.replace(".json", "");
-    if (isDaemonRunning(tunnelId)) active.push(tunnelId);
-  }
-  if (active.length === 0) {
-    failCli("No active tunnels. Run `pubblue tunnel start` first.");
-  }
-  if (active.length === 1) return active[0];
-  failCli(`Multiple active tunnels: ${active.join(", ")}. Specify one.`);
-}
-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 || !fs3.existsSync(infoPath)) return;
-      pollInFlight = true;
-      void ipcCall(socketPath, { method: "status", params: {} }).then((status) => {
-        if (status.ok) done({ ok: true });
-      }).catch((error) => {
-        lastIpcError = error instanceof Error ? error.message : String(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 waitForAgentOffer(params) {
-  const startedAt = Date.now();
-  let lastError = null;
-  while (Date.now() - startedAt < params.timeoutMs) {
-    try {
-      const tunnel = await params.apiClient.get(params.tunnelId);
-      if (typeof tunnel.agentOffer === "string" && tunnel.agentOffer.length > 0) {
-        return { ok: true };
+function registerWriteCommand(program2) {
+  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: 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");
       }
-    } catch (error) {
-      lastError = formatApiError(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()
+      };
     }
-    await new Promise((resolve3) => setTimeout(resolve3, 150));
-  }
-  return {
-    ok: false,
-    reason: lastError ? `agent offer was not published in time (last API error: ${lastError})` : "agent offer was not published in time"
-  };
-}
-async function ensureBridgeReady(params) {
-  if (params.bridgeMode === "none") {
-    return { ok: true };
-  }
-  const infoPath = bridgeInfoPath(params.tunnelId);
-  if (isBridgeRunning(params.tunnelId)) {
-    return waitForBridgeReady({
-      infoPath,
-      tunnelId: params.tunnelId,
-      timeoutMs: params.timeoutMs
+    const socketPath = getAgentSocketPath();
+    const response = await ipcCall(socketPath, {
+      method: "write",
+      params: { channel: opts.channel, msg, binaryBase64 }
     });
-  }
-  const bridgeScript = path3.join(import.meta.dirname, "tunnel-bridge-entry.js");
-  const logPath = bridgeLogPath(params.tunnelId);
-  const logFd = fs3.openSync(logPath, "a");
-  const child = fork(bridgeScript, [], {
-    detached: true,
-    stdio: buildBridgeForkStdio(logFd),
-    env: {
-      ...params.bridgeProcessEnv,
-      PUBBLUE_BRIDGE_MODE: params.bridgeMode,
-      PUBBLUE_BRIDGE_TUNNEL_ID: params.tunnelId,
-      PUBBLUE_BRIDGE_SOCKET: params.socketPath,
-      PUBBLUE_BRIDGE_INFO: infoPath
+    if (!response.ok) {
+      failCli(`Failed: ${response.error}`);
     }
   });
-  fs3.closeSync(logFd);
-  if (child.connected) {
-    child.disconnect();
-  }
-  child.unref();
-  return waitForBridgeReady({
-    child,
-    infoPath,
-    tunnelId: params.tunnelId,
-    timeoutMs: params.timeoutMs
-  });
 }
-function waitForBridgeReady({
-  child,
-  infoPath,
-  tunnelId,
-  timeoutMs
-}) {
-  return new Promise((resolve3) => {
-    let settled = false;
-    let lastState;
-    let lastError;
-    const done = (result) => {
-      if (settled) return;
-      settled = true;
-      clearInterval(poll);
-      clearTimeout(timeout);
-      if (child) {
-        child.off("exit", onExit);
+function registerReadCommand(program2) {
+  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."
+        );
       }
-      resolve3(result);
-    };
-    const onExit = (code, signal) => {
-      const suffix = signal ? ` (signal ${signal})` : "";
-      done({ ok: false, reason: `bridge exited with code ${code ?? 0}${suffix}` });
-    };
-    if (child) {
-      child.on("exit", onExit);
-    }
-    const poll = setInterval(() => {
-      if (!fs3.existsSync(infoPath)) return;
-      const info = readBridgeProcessInfo(tunnelId);
-      if (!info) return;
-      lastState = info.status;
-      lastError = info.lastError;
-      if (info.status === "ready" && isBridgeRunning(tunnelId)) {
-        done({ ok: true });
-        return;
+      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;
+          }
+        }
+        const delayMs = getFollowReadDelayMs(warnedDisconnected, consecutiveFailures);
+        await new Promise((resolve3) => setTimeout(resolve3, delayMs));
       }
-      if (info.status === "error") {
-        done({
-          ok: false,
-          reason: info.lastError ? `bridge reported startup error: ${info.lastError}` : "bridge reported startup error"
-        });
+    } else {
+      const response = await ipcCall(socketPath, {
+        method: "read",
+        params: { channel: readChannel }
+      });
+      if (!response.ok) {
+        failCli(`Failed: ${response.error}`);
       }
-    }, 120);
-    const timeout = setTimeout(() => {
-      const reason = lastError && lastError.length > 0 ? `timed out after ${timeoutMs}ms waiting for bridge readiness (last error: ${lastError})` : `timed out after ${timeoutMs}ms waiting for bridge readiness (state: ${lastState || "unknown"})`;
-      done({ ok: false, reason });
-    }, timeoutMs);
+      console.log(JSON.stringify(response.messages || [], null, 2));
+    }
   });
 }
-
-// src/commands/tunnel/management-commands.ts
-function registerTunnelManagementCommands(tunnel) {
-  tunnel.command("channels").description("List active channels").argument("[tunnelId]", "Tunnel ID").option("-t, --tunnel <tunnelId>", "Tunnel ID (alternative to positional arg)").action(async (tunnelIdArg, opts) => {
-    const tunnelId = resolveTunnelIdSelection(tunnelIdArg, opts.tunnel) || await resolveActiveTunnel();
-    const socketPath = getSocketPath(tunnelId);
+function registerChannelsCommand(program2) {
+  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) {
@@ -1060,54 +705,17 @@ function registerTunnelManagementCommands(tunnel) {
       }
     }
   });
-  tunnel.command("status").description("Check tunnel connection status").argument("[tunnelId]", "Tunnel ID").option("-t, --tunnel <tunnelId>", "Tunnel ID (alternative to positional arg)").action(async (tunnelIdArg, opts) => {
-    const tunnelId = resolveTunnelIdSelection(tunnelIdArg, opts.tunnel) || await resolveActiveTunnel();
-    const socketPath = getSocketPath(tunnelId);
-    const response = await ipcCall(socketPath, { method: "status", params: {} });
-    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(`  Buffered: ${response.bufferedMessages ?? 0} messages`);
-    if (typeof response.lastError === "string" && response.lastError.length > 0) {
-      console.log(`  Last error: ${response.lastError}`);
-    }
-    const logPath = tunnelLogPath(tunnelId);
-    if (fs4.existsSync(logPath)) {
-      console.log(`  Log: ${logPath}`);
-    }
-    const bridgeInfo = readBridgeProcessInfo(tunnelId);
-    if (bridgeInfo) {
-      const bridgeRunning = isBridgeRunning(tunnelId);
-      const bridgeState = bridgeInfo.status || (bridgeRunning ? "running" : "stopped");
-      console.log(`  Bridge: ${bridgeInfo.mode} (${bridgeState})`);
-      if (bridgeInfo.sessionId) {
-        console.log(`  Bridge session: ${bridgeInfo.sessionId}`);
-      }
-      if (bridgeInfo.sessionSource) {
-        console.log(`  Bridge session source: ${bridgeInfo.sessionSource}`);
-      }
-      if (bridgeInfo.sessionKey) {
-        console.log(`  Bridge session key: ${bridgeInfo.sessionKey}`);
-      }
-      if (bridgeInfo.lastError) {
-        console.log(`  Bridge last error: ${bridgeInfo.lastError}`);
-      }
-    }
-    const bridgeLog = bridgeLogPath(tunnelId);
-    if (fs4.existsSync(bridgeLog)) {
-      console.log(`  Bridge log: ${bridgeLog}`);
-    }
-  });
-  tunnel.command("doctor").description("Run strict end-to-end tunnel checks (daemon, channels, chat/canvas ping)").option("-t, --tunnel <tunnelId>", "Tunnel ID (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(
+}
+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 timeoutMs = timeoutSeconds * 1e3;
-      const tunnelId = opts.tunnel || await resolveActiveTunnel();
-      const socketPath = getSocketPath(tunnelId);
+      const socketPath = getAgentSocketPath();
+      const slug = await resolveActiveSlug();
       const apiClient = createApiClient();
       const fail = (message) => failCli(`Doctor failed: ${message}`);
-      console.log(`Doctor tunnel: ${tunnelId}`);
+      console.log(`Doctor: ${slug}`);
       let statusResponse = null;
       try {
         statusResponse = await ipcCall(socketPath, {
@@ -1136,23 +744,25 @@ function registerTunnelManagementCommands(tunnel) {
         }
       }
       console.log("Daemon/channel check: OK");
-      let apiTunnel;
-      try {
-        apiTunnel = await apiClient.get(tunnelId);
-      } catch (error) {
-        fail(`failed to fetch tunnel info from API: ${formatApiError(error)}`);
-      }
-      if (apiTunnel.status !== "active") {
-        fail(`API reports tunnel is not active (status: ${apiTunnel.status})`);
+      const live = await (async () => {
+        try {
+          return await apiClient.getLive(slug);
+        } catch (error) {
+          fail(`failed to fetch live info from API: ${formatApiError(error)}`);
+        }
+        throw new Error("unreachable");
+      })();
+      if (live.status !== "active") {
+        fail(`API reports live is not active (status: ${live.status})`);
       }
-      if (apiTunnel.expiresAt <= Date.now()) {
-        fail("API reports tunnel is expired.");
+      if (live.expiresAt <= Date.now()) {
+        fail("API reports live is expired.");
       }
-      if (!apiTunnel.hasConnection) {
-        fail("API reports no browser connection.");
+      if (typeof live.browserOffer !== "string" || live.browserOffer.length === 0) {
+        fail("browser offer was not published.");
       }
-      if (typeof apiTunnel.agentOffer !== "string" || apiTunnel.agentOffer.length === 0) {
-        fail("agent 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) {
@@ -1214,545 +824,127 @@ function registerTunnelManagementCommands(tunnel) {
         }
         console.log("Canvas ping write ACK: OK");
       }
-      console.log("Tunnel doctor: PASS");
+      console.log("Doctor: PASS");
     }
   );
-  tunnel.command("list").description("List active tunnels").action(async () => {
-    const apiClient = createApiClient();
-    const tunnels = await apiClient.list();
-    if (tunnels.length === 0) {
-      console.log("No active tunnels.");
-      return;
-    }
-    for (const t of tunnels) {
-      const age = Math.floor((Date.now() - t.createdAt) / 6e4);
-      const running = isDaemonRunning(t.tunnelId) ? "running" : "no daemon";
-      const bridgeInfo = readBridgeProcessInfo(t.tunnelId);
-      const bridge = bridgeInfo ? isBridgeRunning(t.tunnelId) ? `${bridgeInfo.mode}:running` : `${bridgeInfo.mode}:stopped` : "none";
-      const conn = t.hasConnection ? "connected" : "waiting";
-      console.log(`  ${t.tunnelId}  ${conn}  ${running}  bridge=${bridge}  ${age}m ago`);
-    }
-  });
-  tunnel.command("close").description("Close a tunnel and stop its daemon").argument("<tunnelId>", "Tunnel ID").action(async (tunnelId) => {
-    stopBridgeProcess(tunnelId);
-    try {
-      fs4.unlinkSync(bridgeInfoPath(tunnelId));
-    } catch {
-    }
-    const socketPath = getSocketPath(tunnelId);
-    try {
-      await ipcCall(socketPath, { method: "close", params: {} });
-    } catch {
-    }
-    const apiClient = createApiClient();
-    try {
-      await apiClient.close(tunnelId);
-    } catch (error) {
-      const message = formatApiError(error);
-      if (!/Tunnel not found/i.test(message)) {
-        failCli(`Failed to close tunnel ${tunnelId}: ${message}`);
-      }
-    }
-    console.log(`Closed: ${tunnelId}`);
-  });
 }
 
-// src/commands/tunnel/message-commands.ts
-import * as fs5 from "fs";
-import * as path4 from "path";
-function registerTunnelMessageCommands(tunnel) {
-  tunnel.command("write").description("Write data to a channel").argument("[message]", "Text message (or use --file)").option("-t, --tunnel <tunnelId>", "Tunnel ID (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 = path4.resolve(opts.file);
-        const ext = path4.extname(filePath).toLowerCase();
-        const bytes = fs5.readFileSync(filePath);
-        const filename = path4.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) {
-        msg = {
-          id: generateMessageId(),
-          type: "text",
-          data: messageArg
-        };
+// 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)").action(
+    async (fileArg, opts) => {
+      const client = createClient();
+      let content;
+      let filename;
+      if (fileArg) {
+        const file = readFile(fileArg);
+        content = file.content;
+        filename = file.basename;
       } 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()
-        };
+        content = await readFromStdin();
       }
-      const tunnelId = opts.tunnel || await resolveActiveTunnel();
-      const socketPath = getSocketPath(tunnelId);
-      const response = await ipcCall(socketPath, {
-        method: "write",
-        params: { channel: opts.channel, msg, binaryBase64 }
+      const resolvedVisibility = resolveVisibilityFlags({
+        public: opts.public,
+        private: opts.private,
+        commandName: "create"
       });
-      if (!response.ok) {
-        failCli(`Failed: ${response.error}`);
+      const result = await client.create({
+        content,
+        filename,
+        title: opts.title,
+        slug: opts.slug,
+        isPublic: resolvedVisibility ?? false,
+        expiresIn: opts.expires
+      });
+      console.log(`Created: ${result.url}`);
+      const tmaUrl = getTelegramMiniAppUrl(result.slug);
+      if (tmaUrl) console.log(`Telegram: ${tmaUrl}`);
+      if (result.expiresAt) {
+        console.log(`  Expires: ${new Date(result.expiresAt).toISOString()}`);
       }
     }
   );
-  tunnel.command("read").description("Read buffered messages from channels").argument("[tunnelId]", "Tunnel ID (auto-detected if one active)").option("-t, --tunnel <tunnelId>", "Tunnel ID (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 (tunnelIdArg, opts) => {
-      const tunnelId = resolveTunnelIdSelection(tunnelIdArg, opts.tunnel) || await resolveActiveTunnel();
-      const socketPath = getSocketPath(tunnelId);
-      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;
-            }
-          }
-          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));
-      }
+  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) => {
+    const client = createClient();
+    const pub = await client.get(slug);
+    if (opts.content) {
+      process.stdout.write(pub.content ?? "");
+      return;
     }
-  );
-}
-
-// src/commands/tunnel/start-command.ts
-import { fork as fork2 } from "child_process";
-import * as fs6 from "fs";
-import * as path5 from "path";
-
-// package.json
-var package_default = {
-  name: "pubblue",
-  version: "0.4.12",
-  description: "CLI tool for publishing static content 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",
-    test: "vitest run",
-    "test:watch": "vitest",
-    lint: "tsc --noEmit"
-  },
-  dependencies: {
-    commander: "^13.0.0",
-    "node-datachannel": "^0.32.0"
-  },
-  devDependencies: {
-    "@types/node": "22.10.2",
-    tsup: "^8.3.6",
-    typescript: "^5.7.2",
-    vitest: "^3.0.0"
-  },
-  files: [
-    "dist"
-  ],
-  repository: {
-    type: "git",
-    url: "git+https://github.com/xmanatee/pub.git",
-    directory: "cli"
-  },
-  publishConfig: {
-    access: "public"
-  },
-  pnpm: {
-    onlyBuiltDependencies: [
-      "esbuild",
-      "node-datachannel"
-    ]
-  }
-};
-
-// src/lib/version.ts
-var version = package_default.version;
-if (typeof version !== "string" || version.length === 0) {
-  throw new Error("Invalid CLI version in package.json");
-}
-var CLI_VERSION = version;
-
-// src/commands/tunnel/start-command.ts
-async function waitForStopped(isRunning, timeoutMs, pollMs = 120) {
-  const started = Date.now();
-  while (Date.now() - started < timeoutMs) {
-    if (!isRunning()) return true;
-    await new Promise((resolve3) => setTimeout(resolve3, pollMs));
-  }
-  return !isRunning();
-}
-function registerTunnelStartCommand(tunnel) {
-  tunnel.command("start").description("Start a tunnel daemon (reuses existing tunnel when possible)").option("--expires <duration>", "Auto-close after duration (e.g. 4h, 1d)", "24h").option("-t, --tunnel <tunnelId>", "Attach/start daemon for an existing tunnel").option("--new", "Always create a new tunnel (skip single-tunnel reuse)").option("--bridge <mode>", "Bridge mode: openclaw|none").option("--foreground", "Run in foreground (don't fork, no managed bridge)").action(
-    async (opts) => {
-      await ensureNodeDatachannelAvailable();
-      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 (opts.tunnel) {
-        try {
-          const existing = await apiClient.get(opts.tunnel);
-          if (existing.status === "closed" || existing.expiresAt <= Date.now()) {
-            failCli(`Tunnel ${opts.tunnel} is closed or expired.`);
-          }
-          target = {
-            createdNew: false,
-            expiresAt: existing.expiresAt,
-            mode: "existing",
-            tunnelId: existing.tunnelId,
-            url: getPublicTunnelUrl(existing.tunnelId)
-          };
-        } catch (error) {
-          failCli(`Failed to use tunnel ${opts.tunnel}: ${formatApiError(error)}`);
-        }
-      } else if (!opts.new) {
-        try {
-          const listed = await apiClient.list();
-          const active = listed.filter((t) => t.status === "active" && t.expiresAt > Date.now()).sort((a, b) => b.createdAt - a.createdAt);
-          const reusable = pickReusableTunnel(listed);
-          if (reusable) {
-            target = {
-              createdNew: false,
-              expiresAt: reusable.expiresAt,
-              mode: "existing",
-              tunnelId: reusable.tunnelId,
-              url: getPublicTunnelUrl(reusable.tunnelId)
-            };
-            if (active.length > 1) {
-              console.error(
-                [
-                  `Multiple active tunnels found: ${active.map((t) => t.tunnelId).join(", ")}`,
-                  `Reusing most recent active tunnel ${reusable.tunnelId}.`,
-                  "Use --tunnel <id> to choose explicitly or --new to force creation."
-                ].join("\n")
-              );
-            } else {
-              console.error(
-                `Reusing existing active tunnel ${reusable.tunnelId}. Use --new to force creation.`
-              );
-            }
-          }
-        } catch (error) {
-          failCli(`Failed to list tunnels for reuse check: ${formatApiError(error)}`);
-        }
-      }
-      if (!target) {
-        try {
-          const created = await apiClient.create({
-            expiresIn: opts.expires
-          });
-          target = {
-            createdNew: true,
-            expiresAt: created.expiresAt,
-            mode: "created",
-            tunnelId: created.tunnelId,
-            url: created.url
-          };
-        } catch (error) {
-          failCli(`Failed to create tunnel: ${formatApiError(error)}`);
-        }
-      }
-      if (!target) {
-        failCli("Failed to resolve tunnel target.");
-      }
-      const socketPath = getSocketPath(target.tunnelId);
-      const infoPath = tunnelInfoPath(target.tunnelId);
-      const logPath = tunnelLogPath(target.tunnelId);
-      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-RKWEA5BV.js");
-        console.log(`Tunnel started: ${target.url}`);
-        const fgTma = getTelegramMiniAppUrl("tunnel", target.tunnelId);
-        if (fgTma) console.log(`Telegram: ${fgTma}`);
-        console.log(`Tunnel ID: ${target.tunnelId}`);
-        console.log(`Expires: ${new Date(target.expiresAt).toISOString()}`);
-        if (target.mode === "existing") console.log("Mode: attached existing tunnel");
-        console.log("Running in foreground. Press Ctrl+C to stop.");
-        try {
-          await startDaemon({
-            cliVersion: CLI_VERSION,
-            tunnelId: target.tunnelId,
-            apiClient,
-            socketPath,
-            infoPath
-          });
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          failCli(`Daemon failed: ${message}`);
-        }
-        return;
-      }
-      const runningDaemonInfo = readDaemonProcessInfo(target.tunnelId);
-      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"}).`
-          );
-          if (isBridgeRunning(target.tunnelId)) {
-            stopBridgeProcess(target.tunnelId);
-            const bridgeStopped = await waitForStopped(
-              () => isBridgeRunning(target.tunnelId),
-              5e3
-            );
-            if (!bridgeStopped) {
-              failCli("Bridge process did not stop during daemon upgrade restart.");
-            }
-          }
-          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 tunnel close <id>` and retry."
-              ].join("\n")
-            );
-          }
-          const daemonStopped = await waitForStopped(
-            () => isDaemonRunning(target.tunnelId),
-            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 tunnel close <id>` and start again."
-              ].join("\n")
-            );
-          }
-          if (bridgeMode !== "none") {
-            const bridgeReady = await ensureBridgeReady({
-              bridgeMode,
-              tunnelId: target.tunnelId,
-              socketPath,
-              bridgeProcessEnv,
-              timeoutMs: 8e3
-            });
-            if (!bridgeReady.ok) {
-              const lines = [
-                `Bridge failed to start for running tunnel: ${bridgeReady.reason ?? "unknown reason"}`
-              ];
-              const existingBridgeLog = bridgeLogPath(target.tunnelId);
-              if (fs6.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(`Tunnel started: ${target.url}`);
-          const runTma = getTelegramMiniAppUrl("tunnel", target.tunnelId);
-          if (runTma) console.log(`Telegram: ${runTma}`);
-          console.log(`Tunnel ID: ${target.tunnelId}`);
-          console.log(`Expires: ${new Date(target.expiresAt).toISOString()}`);
-          console.log("Daemon already running for this tunnel.");
-          console.log(`Daemon log: ${logPath}`);
-          if (bridgeMode !== "none") {
-            console.log("Bridge mode: openclaw");
-            console.log(`Bridge log: ${bridgeLogPath(target.tunnelId)}`);
-          }
-          return;
-        }
-      }
-      const daemonScript = path5.join(import.meta.dirname, "tunnel-daemon-entry.js");
-      const daemonLogFd = fs6.openSync(logPath, "a");
-      const child = fork2(daemonScript, [], {
-        detached: true,
-        stdio: buildDaemonForkStdio(daemonLogFd),
-        env: {
-          ...process.env,
-          PUBBLUE_DAEMON_TUNNEL_ID: target.tunnelId,
-          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
-        }
-      });
-      fs6.closeSync(daemonLogFd);
-      if (child.connected) {
-        child.disconnect();
+    console.log(`  Slug:    ${pub.slug}`);
+    if (pub.contentType) console.log(`  Type:    ${pub.contentType}`);
+    if (pub.title) console.log(`  Title:   ${pub.title}`);
+    console.log(`  Status:  ${formatVisibility(pub.isPublic)}`);
+    if (pub.expiresAt) console.log(`  Expires: ${new Date(pub.expiresAt).toISOString()}`);
+    console.log(`  Created: ${new Date(pub.createdAt).toLocaleDateString()}`);
+    console.log(`  Updated: ${new Date(pub.updatedAt).toLocaleDateString()}`);
+    if (pub.content) console.log(`  Size:    ${pub.content.length} bytes`);
+    if (pub.live) {
+      console.log(`  Live: ${pub.live.status}`);
+      console.log(`    Connected: ${pub.live.hasConnection ? "yes" : "no"}`);
+      console.log(`    Expires:   ${new Date(pub.live.expiresAt).toISOString()}`);
+    }
+  });
+  program2.command("update").description("Update a pub's content and/or metadata").argument("<slug>", "Slug of the pub to update").option("--file <file>", "New content from file").option("--title <title>", "New title").option("--public", "Make the pub public").option("--private", "Make the pub private").option("--slug <newSlug>", "Rename the slug").action(
+    async (slug, opts) => {
+      const client = createClient();
+      let content;
+      let filename;
+      if (opts.file) {
+        const file = readFile(opts.file);
+        content = file.content;
+        filename = file.basename;
       }
-      child.unref();
-      console.log(`Starting daemon for tunnel ${target.tunnelId}...`);
-      const ready = await waitForDaemonReady({
-        child,
-        infoPath,
-        socketPath,
-        timeoutMs: 8e3
+      const isPublic = resolveVisibilityFlags({
+        public: opts.public,
+        private: opts.private,
+        commandName: "update"
       });
-      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 cleanupCreatedTunnelOnStartFailure(apiClient, target);
-        failCli(lines.join("\n"));
-      }
-      const offerReady = await waitForAgentOffer({
-        apiClient,
-        tunnelId: target.tunnelId,
-        timeoutMs: 5e3
+      const result = await client.update({
+        slug,
+        content,
+        filename,
+        title: opts.title,
+        isPublic,
+        newSlug: opts.slug
       });
-      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 cleanupCreatedTunnelOnStartFailure(apiClient, target);
-        failCli(lines.join("\n"));
-      }
-      if (bridgeMode !== "none") {
-        const bridgeReady = await ensureBridgeReady({
-          bridgeMode,
-          tunnelId: target.tunnelId,
-          socketPath,
-          bridgeProcessEnv,
-          timeoutMs: 8e3
-        });
-        if (!bridgeReady.ok) {
-          const lines = [`Bridge failed to start: ${bridgeReady.reason ?? "unknown reason"}`];
-          const bridgeLog = bridgeLogPath(target.tunnelId);
-          if (fs6.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 ----");
-            }
-          }
-          try {
-            await ipcCall(socketPath, { method: "close", params: {} });
-          } catch {
-          }
-          await cleanupCreatedTunnelOnStartFailure(apiClient, target);
-          failCli(lines.join("\n"));
-        }
-      }
-      console.log(`Tunnel started: ${target.url}`);
-      const tma = getTelegramMiniAppUrl("tunnel", target.tunnelId);
-      if (tma) console.log(`Telegram: ${tma}`);
-      console.log(`Tunnel ID: ${target.tunnelId}`);
-      console.log(`Expires: ${new Date(target.expiresAt).toISOString()}`);
-      if (target.mode === "existing") console.log("Mode: attached existing tunnel");
-      console.log("Daemon health: OK");
-      console.log(`Daemon log: ${logPath}`);
-      if (bridgeMode !== "none") {
-        console.log("Bridge mode: openclaw");
-        console.log(`Bridge log: ${bridgeLogPath(target.tunnelId)}`);
-      }
+      console.log(`Updated: ${result.slug}`);
+      if (result.title) console.log(`  Title:  ${result.title}`);
+      console.log(`  Status: ${formatVisibility(result.isPublic)}`);
     }
   );
-}
-
-// src/commands/tunnel.ts
-function registerTunnelCommands(program2) {
-  const tunnel = program2.command("tunnel").description("P2P encrypted tunnel to browser");
-  registerTunnelStartCommand(tunnel);
-  registerTunnelMessageCommands(tunnel);
-  registerTunnelManagementCommands(tunnel);
+  program2.command("list").description("List your pubs").action(async () => {
+    const client = createClient();
+    const pubs = await client.list();
+    if (pubs.length === 0) {
+      console.log("No pubs.");
+      return;
+    }
+    for (const pub of pubs) {
+      const date = new Date(pub.createdAt).toLocaleDateString();
+      const expires = pub.expiresAt ? ` expires:${new Date(pub.expiresAt).toISOString()}` : "";
+      const contentLabel = pub.contentType ? `[${pub.contentType}]` : "[no content]";
+      const sessionLabel = pub.live?.status === "active" ? " [live]" : "";
+      console.log(
+        `  ${pub.slug}  ${contentLabel}  ${formatVisibility(pub.isPublic)}  ${date}${expires}${sessionLabel}`
+      );
+    }
+  });
+  program2.command("delete").description("Delete a pub").argument("<slug>", "Slug of the pub to delete").action(async (slug) => {
+    const client = createClient();
+    await client.remove(slug);
+    console.log(`Deleted: ${slug}`);
+  });
 }
 
 // src/program.ts
 function buildProgram() {
   const program2 = new Command();
   program2.exitOverride();
-  program2.name("pubblue").description("Publish static content and get shareable URLs").version(CLI_VERSION);
+  program2.name("pubblue").description("Publish content and go live").version(CLI_VERSION);
   registerConfigureCommand(program2);
-  registerPublicationCommands(program2);
-  registerTunnelCommands(program2);
+  registerPubCommands(program2);
+  registerLiveCommands(program2);
   return program2;
 }