pubblue 0.5.0 → 0.6.1

package/dist/{chunk-YI45G6AG.js → chunk-BBJOOZHS.js}

@@ -1,7 +1,3 @@
-import {
-  ipcCall
-} from "./chunk-PFZT7M3E.js";
-
 // src/lib/cli-error.ts
 import { CommanderError } from "commander";
 var CliError = class extends Error {
@@ -124,35 +120,90 @@ var PubApiClient = class {
       method: "DELETE"
     });
   }
-  // -- Live management -----------------------------------------------------
-  async openLive(slug, opts = {}) {
-    return this.request(`/api/v1/pubs/${encodeURIComponent(slug)}/live`, {
-      method: "POST",
+  // -- Agent presence -------------------------------------------------------
+  async goOnline() {
+    await this.request("/api/v1/agent/online", { method: "POST" });
+  }
+  async heartbeat() {
+    await this.request("/api/v1/agent/heartbeat", { method: "POST" });
+  }
+  async goOffline() {
+    await this.request("/api/v1/agent/offline", { method: "POST" });
+  }
+  // -- Agent live management ------------------------------------------------
+  async getPendingLive() {
+    const data = await this.request("/api/v1/agent/live");
+    return data.live;
+  }
+  async signalAnswer(opts) {
+    await this.request("/api/v1/agent/live/signal", {
+      method: "PATCH",
       body: JSON.stringify(opts)
     });
   }
+  async closeActiveLive() {
+    await this.request("/api/v1/agent/live", { method: "DELETE" });
+  }
+  // -- Per-slug live info ---------------------------------------------------
   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"
-    });
-  }
 };
 
+// ../shared/bridge-protocol-core.ts
+var CONTROL_CHANNEL = "_control";
+var CHANNELS = {
+  CHAT: "chat",
+  CANVAS: "canvas",
+  AUDIO: "audio",
+  MEDIA: "media",
+  FILE: "file"
+};
+var idCounter = 0;
+function generateMessageId() {
+  const ts = Date.now().toString(36);
+  const seq = (idCounter++).toString(36);
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `${ts}-${seq}-${rand}`;
+}
+function encodeMessage(msg) {
+  return JSON.stringify(msg);
+}
+function decodeMessage(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed.id === "string" && typeof parsed.type === "string") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function makeEventMessage(event, meta) {
+  return { id: generateMessageId(), type: "event", data: event, meta };
+}
+function makeAckMessage(messageId, channel) {
+  return makeEventMessage("ack", { messageId, channel, receivedAt: Date.now() });
+}
+function parseAckMessage(msg) {
+  if (msg.type !== "event" || msg.data !== "ack" || !msg.meta) return null;
+  const messageId = typeof msg.meta.messageId === "string" ? msg.meta.messageId : null;
+  const channel = typeof msg.meta.channel === "string" ? msg.meta.channel : null;
+  if (!messageId || !channel) return null;
+  const receivedAt = typeof msg.meta.receivedAt === "number" ? msg.meta.receivedAt : void 0;
+  return { messageId, channel, receivedAt };
+}
+function shouldAcknowledgeMessage(channel, msg) {
+  return channel !== CONTROL_CHANNEL && parseAckMessage(msg) === null;
+}
+
 // src/commands/tunnel-helpers.ts
-import { fork } from "child_process";
 import * as fs2 from "fs";
+import { homedir as homedir2 } from "os";
 import * as path2 from "path";
 
 // src/lib/config.ts
@@ -215,6 +266,58 @@ function getTelegramMiniAppUrl(slug) {
   return `https://t.me/${saved.telegram.botUsername}?startapp=${slug}`;
 }
 
+// src/lib/tunnel-ipc.ts
+import * as net from "net";
+function getAgentSocketPath() {
+  return "/tmp/pubblue-agent.sock";
+}
+async function ipcCall(socketPath, request) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timeoutId = null;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      fn();
+    };
+    const client = net.createConnection(socketPath, () => {
+      client.write(`${JSON.stringify(request)}
+`);
+    });
+    let data = "";
+    client.on("data", (chunk) => {
+      data += chunk.toString();
+      const newlineIdx = data.indexOf("\n");
+      if (newlineIdx !== -1) {
+        const line = data.slice(0, newlineIdx);
+        client.end();
+        try {
+          finish(() => resolve(JSON.parse(line)));
+        } catch {
+          finish(() => reject(new Error("Invalid response from daemon")));
+        }
+      }
+    });
+    client.on("error", (err) => {
+      if (err.code === "ECONNREFUSED" || err.code === "ENOENT") {
+        finish(() => reject(new Error("Daemon not running.")));
+      } else {
+        finish(() => reject(err));
+      }
+    });
+    client.on("end", () => {
+      if (!data.includes("\n")) {
+        finish(() => reject(new Error("Daemon closed connection unexpectedly")));
+      }
+    });
+    timeoutId = setTimeout(() => {
+      client.destroy();
+      finish(() => reject(new Error("Daemon request timed out")));
+    }, 1e4);
+  });
+}
+
 // src/commands/tunnel-helpers.ts
 var TEXT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".txt",
@@ -280,12 +383,6 @@ function liveInfoPath(slug) {
 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);
@@ -293,31 +390,27 @@ function createApiClient(configOverride) {
 function buildBridgeProcessEnv(bridgeConfig) {
   const env = { ...process.env };
   const setIfMissing = (key, value) => {
-    if (value === void 0 || value === null) return;
+    if (value === void 0) return;
     const current = env[key];
     if (typeof current === "string" && current.length > 0) return;
     env[key] = String(value);
   };
   setIfMissing("PUBBLUE_PROJECT_ROOT", process.cwd());
+  setIfMissing("OPENCLAW_HOME", homedir2());
   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_CANVAS_REMINDER_EVERY", bridgeConfig.canvasReminderEvery);
+  setIfMissing(
+    "OPENCLAW_DELIVER",
+    bridgeConfig.deliver === void 0 ? void 0 : bridgeConfig.deliver ? "1" : "0"
+  );
   setIfMissing("OPENCLAW_DELIVER_CHANNEL", bridgeConfig.deliverChannel);
   setIfMissing("OPENCLAW_REPLY_TO", bridgeConfig.replyTo);
-  if (bridgeConfig.deliverTimeoutMs !== void 0) {
-    setIfMissing("OPENCLAW_DELIVER_TIMEOUT_MS", bridgeConfig.deliverTimeoutMs);
-  }
+  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);
-  }
+  setIfMissing("OPENCLAW_ATTACHMENT_MAX_BYTES", bridgeConfig.attachmentMaxBytes);
   return env;
 }
 async function ensureNodeDatachannelAvailable() {
@@ -343,7 +436,7 @@ function readDaemonProcessInfo(slug) {
   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);
+    if (!isProcessAlive(info.pid)) throw new Error("process not alive");
     return info;
   } catch {
     try {
@@ -353,30 +446,6 @@ function readDaemonProcessInfo(slug) {
     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");
 }
@@ -413,19 +482,6 @@ async function waitForProcessExit(pid, timeoutMs) {
   }
   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;
@@ -451,15 +507,12 @@ async function stopDaemonForLive(info) {
   if (!stopped) return `daemon ${pid}: did not exit after stop request`;
   return null;
 }
-async function stopOtherDaemons(exceptSlug) {
+async function stopOtherDaemons() {
   const dir = liveInfoDir();
-  const entries = fs2.readdirSync(dir).filter((name) => name.endsWith(".json") && !name.endsWith(".bridge.json"));
+  const entries = fs2.readdirSync(dir).filter((name) => name.endsWith(".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);
@@ -468,23 +521,17 @@ async function stopOtherDaemons(exceptSlug) {
   if (failures.length > 0) {
     throw new Error(
       [
-        "Critical: failed to stop previous live daemon/bridge processes.",
+        "Critical: failed to stop previous live daemon 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"];
 }
@@ -502,9 +549,8 @@ function parseBridgeMode(raw) {
   }
   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 resolveBridgeMode(opts) {
+  return parseBridgeMode(opts.bridge || (opts.foreground ? "none" : "openclaw"));
 }
 function messageContainsPong(payload) {
   if (!payload || typeof payload !== "object") return false;
@@ -514,14 +560,6 @@ function messageContainsPong(payload) {
   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 {
@@ -541,27 +579,18 @@ function formatApiError(error) {
   }
   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);
+  const socketPath = getAgentSocketPath();
+  let response;
+  try {
+    response = await ipcCall(socketPath, { method: "active-slug", params: {} });
+  } catch {
+    failCli("No active daemon. Run `pubblue start` first.");
   }
-  if (active.length === 0) {
-    failCli("No active lives. Run `pubblue open <slug>` first.");
+  if (response.ok && typeof response.slug === "string" && response.slug.length > 0) {
+    return response.slug;
   }
-  if (active.length === 1) return active[0];
-  failCli(`Multiple active lives: ${active.join(", ")}. Specify one with --slug.`);
+  failCli("Daemon is running but no live is active. Wait for browser to initiate live.");
 }
 function waitForDaemonReady({
   child,
@@ -603,113 +632,6 @@ function waitForDaemonReady({
     }, 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,
@@ -720,40 +642,35 @@ export {
   getTelegramMiniAppUrl,
   PubApiError,
   PubApiClient,
+  CONTROL_CHANNEL,
+  CHANNELS,
+  generateMessageId,
+  encodeMessage,
+  decodeMessage,
+  makeAckMessage,
+  parseAckMessage,
+  shouldAcknowledgeMessage,
+  getAgentSocketPath,
+  ipcCall,
   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,
+  resolveBridgeMode,
   messageContainsPong,
-  getPublicUrl,
-  pickReusableLive,
   readLogTail,
   formatApiError,
-  cleanupLiveOnStartFailure,
   resolveActiveSlug,
-  waitForDaemonReady,
-  waitForAgentOffer,
-  ensureBridgeReady
+  waitForDaemonReady
 };