pubblue 0.5.0 → 0.6.4

package/dist/chunk-YI45G6AG.js

@@ -1,759 +0,0 @@
-import {
-  ipcCall
-} from "./chunk-PFZT7M3E.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)
-  };
-}
-
-// src/lib/api.ts
-var PubApiError = class extends Error {
-  constructor(message, status, retryAfterSeconds) {
-    super(message);
-    this.status = status;
-    this.retryAfterSeconds = retryAfterSeconds;
-    this.name = "PubApiError";
-  }
-};
-var PubApiClient = class {
-  constructor(baseUrl, apiKey) {
-    this.baseUrl = baseUrl;
-    this.apiKey = apiKey;
-  }
-  async request(path3, options = {}) {
-    const url = new URL(path3, this.baseUrl);
-    const res = await fetch(url, {
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`,
-        ...options.headers
-      }
-    });
-    const retryAfterHeader = res.headers.get("Retry-After");
-    const parsedRetryAfterSeconds = typeof retryAfterHeader === "string" ? Number.parseInt(retryAfterHeader, 10) : void 0;
-    const retryAfterSeconds = parsedRetryAfterSeconds !== void 0 && Number.isFinite(parsedRetryAfterSeconds) ? parsedRetryAfterSeconds : void 0;
-    let data;
-    try {
-      data = await res.json();
-    } catch {
-      data = {};
-    }
-    if (!res.ok) {
-      if (res.status === 429) {
-        const retrySuffix = retryAfterSeconds !== void 0 ? ` Retry after ${retryAfterSeconds}s.` : "";
-        throw new PubApiError(`Rate limit exceeded.${retrySuffix}`, res.status, retryAfterSeconds);
-      }
-      throw new PubApiError(data.error || `Request failed with status ${res.status}`, res.status);
-    }
-    return data;
-  }
-  // -- Pub CRUD -------------------------------------------------------------
-  async create(opts) {
-    return this.request("/api/v1/pubs", {
-      method: "POST",
-      body: JSON.stringify(opts)
-    });
-  }
-  async get(slug) {
-    const data = await this.request(`/api/v1/pubs/${encodeURIComponent(slug)}`);
-    return data.pub;
-  }
-  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/pubs${qs ? `?${qs}` : ""}`);
-  }
-  async list() {
-    const all = [];
-    let cursor;
-    do {
-      const result = await this.listPage(cursor, 100);
-      all.push(...result.pubs);
-      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/pubs/${encodeURIComponent(slug)}`, {
-      method: "PATCH",
-      body: JSON.stringify(body)
-    });
-  }
-  async remove(slug) {
-    await this.request(`/api/v1/pubs/${encodeURIComponent(slug)}`, {
-      method: "DELETE"
-    });
-  }
-  // -- Live management -----------------------------------------------------
-  async openLive(slug, opts = {}) {
-    return this.request(`/api/v1/pubs/${encodeURIComponent(slug)}/live`, {
-      method: "POST",
-      body: JSON.stringify(opts)
-    });
-  }
-  async getLive(slug) {
-    const data = await this.request(
-      `/api/v1/pubs/${encodeURIComponent(slug)}/live`
-    );
-    return data.live;
-  }
-  async signal(slug, opts) {
-    await this.request(`/api/v1/pubs/${encodeURIComponent(slug)}/live/signal`, {
-      method: "PATCH",
-      body: JSON.stringify(opts)
-    });
-  }
-  async closeLive(slug) {
-    await this.request(`/api/v1/pubs/${encodeURIComponent(slug)}/live`, {
-      method: "DELETE"
-    });
-  }
-};
-
-// src/commands/tunnel-helpers.ts
-import { fork } from "child_process";
-import * as fs2 from "fs";
-import * as path2 from "path";
-
-// src/lib/config.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(slug) {
-  const saved = loadConfig();
-  if (!saved?.telegram?.botUsername) return null;
-  return `https://t.me/${saved.telegram.botUsername}?startapp=${slug}`;
-}
-
-// src/commands/tunnel-helpers.ts
-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 = path2.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 liveInfoDir() {
-  const dir = path2.join(
-    process.env.HOME || process.env.USERPROFILE || "/tmp",
-    ".config",
-    "pubblue",
-    "lives"
-  );
-  if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
-  return dir;
-}
-function liveInfoPath(slug) {
-  return path2.join(liveInfoDir(), `${slug}.json`);
-}
-function liveLogPath(slug) {
-  return path2.join(liveInfoDir(), `${slug}.log`);
-}
-function bridgeInfoPath(slug) {
-  return path2.join(liveInfoDir(), `${slug}.bridge.json`);
-}
-function bridgeLogPath(slug) {
-  return path2.join(liveInfoDir(), `${slug}.bridge.log`);
-}
-function createApiClient(configOverride) {
-  const config = configOverride || getConfig();
-  return new PubApiClient(config.baseUrl, config.apiKey);
-}
-function buildBridgeProcessEnv(bridgeConfig) {
-  const env = { ...process.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("PUBBLUE_PROJECT_ROOT", process.cwd());
-  if (!bridgeConfig) return env;
-  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(slug) {
-  return readDaemonProcessInfo(slug) !== null;
-}
-function readDaemonProcessInfo(slug) {
-  const infoPath = liveInfoPath(slug);
-  if (!fs2.existsSync(infoPath)) return null;
-  try {
-    const info = JSON.parse(fs2.readFileSync(infoPath, "utf-8"));
-    if (!Number.isFinite(info.pid)) throw new Error("invalid daemon pid");
-    process.kill(info.pid, 0);
-    return info;
-  } catch {
-    try {
-      fs2.unlinkSync(infoPath);
-    } catch {
-    }
-    return null;
-  }
-}
-function readBridgeProcessInfo(slug) {
-  const infoPath = bridgeInfoPath(slug);
-  if (!fs2.existsSync(infoPath)) return null;
-  try {
-    return JSON.parse(fs2.readFileSync(infoPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function isBridgeRunning(slug) {
-  const infoPath = bridgeInfoPath(slug);
-  if (!fs2.existsSync(infoPath)) return false;
-  try {
-    const info = JSON.parse(fs2.readFileSync(infoPath, "utf-8"));
-    process.kill(info.pid, 0);
-    return true;
-  } catch {
-    try {
-      fs2.unlinkSync(infoPath);
-    } catch {
-    }
-  }
-  return false;
-}
-function latestCliVersionPath() {
-  return path2.join(liveInfoDir(), "cli-version.txt");
-}
-function readLatestCliVersion(versionPath) {
-  const resolved = versionPath || latestCliVersionPath();
-  if (!fs2.existsSync(resolved)) return null;
-  try {
-    const value = fs2.readFileSync(resolved, "utf-8").trim();
-    return value.length === 0 ? null : value;
-  } catch {
-    return null;
-  }
-}
-function writeLatestCliVersion(version, versionPath) {
-  if (!version || version.trim().length === 0) return;
-  const resolved = versionPath || latestCliVersionPath();
-  const dir = path2.dirname(resolved);
-  if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
-  fs2.writeFileSync(resolved, version.trim(), "utf-8");
-}
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function waitForProcessExit(pid, timeoutMs) {
-  const startedAt = Date.now();
-  while (Date.now() - startedAt < timeoutMs) {
-    if (!isProcessAlive(pid)) return true;
-    await new Promise((resolve) => setTimeout(resolve, 120));
-  }
-  return !isProcessAlive(pid);
-}
-async function stopBridge(slug) {
-  const bridge = readBridgeProcessInfo(slug);
-  if (!bridge || !Number.isFinite(bridge.pid)) return null;
-  if (!isProcessAlive(bridge.pid)) return null;
-  try {
-    process.kill(bridge.pid, "SIGTERM");
-  } catch (error) {
-    return `bridge ${bridge.pid}: failed to send SIGTERM (${error instanceof Error ? error.message : String(error)})`;
-  }
-  const stopped = await waitForProcessExit(bridge.pid, 6e3);
-  if (!stopped) return `bridge ${bridge.pid}: did not exit after SIGTERM`;
-  return null;
-}
-async function stopDaemonForLive(info) {
-  const pid = info.pid;
-  if (!Number.isFinite(pid) || !isProcessAlive(pid)) return null;
-  const socketPath = info.socketPath;
-  if (socketPath) {
-    try {
-      await ipcCall(socketPath, { method: "close", params: {} });
-    } catch (error) {
-      try {
-        process.kill(pid, "SIGTERM");
-      } catch (killError) {
-        return `daemon ${pid}: IPC close failed (${error instanceof Error ? error.message : String(error)}); SIGTERM failed (${killError instanceof Error ? killError.message : String(killError)})`;
-      }
-    }
-  } else {
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch (error) {
-      return `daemon ${pid}: no socketPath and SIGTERM failed (${error instanceof Error ? error.message : String(error)})`;
-    }
-  }
-  const stopped = await waitForProcessExit(pid, 8e3);
-  if (!stopped) return `daemon ${pid}: did not exit after stop request`;
-  return null;
-}
-async function stopOtherDaemons(exceptSlug) {
-  const dir = liveInfoDir();
-  const entries = fs2.readdirSync(dir).filter((name) => name.endsWith(".json") && !name.endsWith(".bridge.json"));
-  const failures = [];
-  for (const entry of entries) {
-    const slug = entry.replace(/\.json$/, "");
-    if (exceptSlug && slug === exceptSlug) continue;
-    const bridgeError = await stopBridge(slug);
-    if (bridgeError) failures.push(`[${slug}] ${bridgeError}`);
-    const info = readDaemonProcessInfo(slug);
-    if (!info) continue;
-    const daemonError = await stopDaemonForLive(info);
-    if (daemonError) failures.push(`[${slug}] ${daemonError}`);
-  }
-  if (failures.length > 0) {
-    throw new Error(
-      [
-        "Critical: failed to stop previous live daemon/bridge processes.",
-        "Starting a new daemon now would leak resources and increase bandwidth usage.",
-        ...failures
-      ].join("\n")
-    );
-  }
-}
-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 resolveSlugSelection(slugArg, slugOpt) {
-  return slugOpt || slugArg;
-}
-function buildDaemonForkStdio(logFd) {
-  return ["ignore", logFd, logFd, "ipc"];
-}
-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 getPublicUrl(slug) {
-  const base = process.env.PUBBLUE_PUBLIC_URL || "https://pub.blue";
-  return `${base.replace(/\/$/, "")}/p/${slug}`;
-}
-function pickReusableLive(pubs, nowMs = Date.now()) {
-  const active = pubs.filter((p) => p.live?.status === "active" && p.live.expiresAt > nowMs).sort((a, b) => b.createdAt - a.createdAt);
-  return active[0] ?? null;
-}
-function readLogTail(logPath, maxChars = 4e3) {
-  if (!fs2.existsSync(logPath)) return null;
-  try {
-    const content = fs2.readFileSync(logPath, "utf-8");
-    if (content.length <= maxChars) return content;
-    return content.slice(-maxChars);
-  } catch {
-    return null;
-  }
-}
-function formatApiError(error) {
-  if (error instanceof PubApiError) {
-    if (error.status === 429 && error.retryAfterSeconds !== void 0) {
-      return `Rate limit exceeded. Retry after ${error.retryAfterSeconds}s.`;
-    }
-    return `${error.message} (HTTP ${error.status})`;
-  }
-  return error instanceof Error ? error.message : String(error);
-}
-async function cleanupLiveOnStartFailure(apiClient, target) {
-  if (!target.createdNew) return;
-  try {
-    await apiClient.closeLive(target.slug);
-  } catch (closeError) {
-    console.error(`Failed to clean up live for ${target.slug}: ${formatApiError(closeError)}`);
-  }
-}
-async function resolveActiveSlug() {
-  const dir = liveInfoDir();
-  const files = fs2.readdirSync(dir).filter((f) => f.endsWith(".json") && !f.endsWith(".bridge.json"));
-  const active = [];
-  for (const f of files) {
-    const slug = f.replace(".json", "");
-    if (isDaemonRunning(slug)) active.push(slug);
-  }
-  if (active.length === 0) {
-    failCli("No active lives. Run `pubblue open <slug>` first.");
-  }
-  if (active.length === 1) return active[0];
-  failCli(`Multiple active lives: ${active.join(", ")}. Specify one with --slug.`);
-}
-function waitForDaemonReady({
-  child,
-  infoPath,
-  socketPath,
-  timeoutMs
-}) {
-  return new Promise((resolve) => {
-    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);
-      resolve(result);
-    };
-    const onExit = (code, signal) => {
-      const suffix = signal ? ` (signal ${signal})` : "";
-      done({ ok: false, reason: `daemon exited with code ${code ?? 0}${suffix}` });
-    };
-    child.on("exit", onExit);
-    const poll = setInterval(() => {
-      if (pollInFlight || !fs2.existsSync(infoPath)) return;
-      pollInFlight = true;
-      void ipcCall(socketPath, { method: "status", params: {} }).then((status) => {
-        if (status.ok) done({ ok: true });
-      }).catch((error) => {
-        lastIpcError = 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 session = await params.apiClient.getLive(params.slug);
-      if (typeof session.agentOffer === "string" && session.agentOffer.length > 0) {
-        return { ok: true };
-      }
-    } catch (error) {
-      lastError = formatApiError(error);
-    }
-    await new Promise((resolve) => setTimeout(resolve, 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.slug);
-  if (isBridgeRunning(params.slug)) {
-    return waitForBridgeReady({
-      infoPath,
-      slug: params.slug,
-      timeoutMs: params.timeoutMs
-    });
-  }
-  const bridgeScript = path2.join(import.meta.dirname, "tunnel-bridge-entry.js");
-  const logPath = bridgeLogPath(params.slug);
-  const logFd = fs2.openSync(logPath, "a");
-  const child = fork(bridgeScript, [], {
-    detached: true,
-    stdio: buildBridgeForkStdio(logFd),
-    env: {
-      ...params.bridgeProcessEnv,
-      PUBBLUE_BRIDGE_MODE: params.bridgeMode,
-      PUBBLUE_BRIDGE_SLUG: params.slug,
-      PUBBLUE_BRIDGE_SOCKET: params.socketPath,
-      PUBBLUE_BRIDGE_INFO: infoPath
-    }
-  });
-  fs2.closeSync(logFd);
-  if (child.connected) {
-    child.disconnect();
-  }
-  child.unref();
-  return waitForBridgeReady({
-    child,
-    infoPath,
-    slug: params.slug,
-    timeoutMs: params.timeoutMs
-  });
-}
-function waitForBridgeReady({
-  child,
-  infoPath,
-  slug,
-  timeoutMs
-}) {
-  return new Promise((resolve) => {
-    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);
-      }
-      resolve(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 (!fs2.existsSync(infoPath)) return;
-      const info = readBridgeProcessInfo(slug);
-      if (!info) return;
-      lastState = info.status;
-      lastError = info.lastError;
-      if (info.status === "ready" && isBridgeRunning(slug)) {
-        done({ ok: true });
-        return;
-      }
-      if (info.status === "error") {
-        done({
-          ok: false,
-          reason: info.lastError ? `bridge reported startup error: ${info.lastError}` : "bridge reported startup 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);
-  });
-}
-
-export {
-  failCli,
-  toCliFailure,
-  loadConfig,
-  saveConfig,
-  getConfig,
-  getTelegramMiniAppUrl,
-  PubApiError,
-  PubApiClient,
-  TEXT_FILE_EXTENSIONS,
-  getMimeType,
-  liveInfoPath,
-  liveLogPath,
-  bridgeInfoPath,
-  bridgeLogPath,
-  createApiClient,
-  buildBridgeProcessEnv,
-  ensureNodeDatachannelAvailable,
-  isDaemonRunning,
-  readDaemonProcessInfo,
-  readBridgeProcessInfo,
-  isBridgeRunning,
-  latestCliVersionPath,
-  readLatestCliVersion,
-  writeLatestCliVersion,
-  waitForProcessExit,
-  stopBridge,
-  stopOtherDaemons,
-  buildBridgeForkStdio,
-  getFollowReadDelayMs,
-  resolveSlugSelection,
-  buildDaemonForkStdio,
-  parsePositiveIntegerOption,
-  parseBridgeMode,
-  shouldRestartDaemonForCliUpgrade,
-  messageContainsPong,
-  getPublicUrl,
-  pickReusableLive,
-  readLogTail,
-  formatApiError,
-  cleanupLiveOnStartFailure,
-  resolveActiveSlug,
-  waitForDaemonReady,
-  waitForAgentOffer,
-  ensureBridgeReady
-};