pubblue 0.5.0 → 0.6.4

package/dist/chunk-JXEXE632.js

@@ -0,0 +1,608 @@
+// 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 errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function toCliFailure(error) {
+  if (error instanceof CommanderError) {
+    return {
+      exitCode: error.exitCode,
+      message: ""
+    };
+  }
+  if (error instanceof CliError) {
+    return {
+      exitCode: error.exitCode,
+      message: error.message
+    };
+  }
+  return {
+    exitCode: 1,
+    message: errorMessage(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(path2, options = {}) {
+    const url = new URL(path2, 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 deletePub(slug) {
+    await this.request(`/api/v1/pubs/${encodeURIComponent(slug)}`, {
+      method: "DELETE"
+    });
+  }
+  // -- 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;
+  }
+};
+
+// ../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/live-helpers.ts
+import * as fs from "fs";
+import { homedir } from "os";
+import * as path from "path";
+
+// src/lib/live-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/live-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"
+]);
+var MIME_BY_EXT = {
+  ".html": "text/html; charset=utf-8",
+  ".htm": "text/html; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".md": "text/markdown; charset=utf-8",
+  ".markdown": "text/markdown; charset=utf-8",
+  ".json": "application/json",
+  ".csv": "text/csv; charset=utf-8",
+  ".xml": "application/xml",
+  ".yaml": "application/x-yaml",
+  ".yml": "application/x-yaml",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".cjs": "text/javascript; charset=utf-8",
+  ".ts": "text/typescript; charset=utf-8",
+  ".tsx": "text/typescript; charset=utf-8",
+  ".jsx": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".scss": "text/x-scss; charset=utf-8",
+  ".sass": "text/x-sass; charset=utf-8",
+  ".less": "text/x-less; charset=utf-8",
+  ".log": "text/plain; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".pdf": "application/pdf",
+  ".zip": "application/zip",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".mp4": "video/mp4"
+};
+function getMimeType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return MIME_BY_EXT[ext] || "application/octet-stream";
+}
+function liveInfoDir() {
+  const dir = path.join(homedir(), ".config", "pubblue", "lives");
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function liveInfoPath(slug) {
+  return path.join(liveInfoDir(), `${slug}.json`);
+}
+function liveLogPath(slug) {
+  return path.join(liveInfoDir(), `${slug}.log`);
+}
+function buildBridgeProcessEnv(bridgeConfig) {
+  const env = { ...process.env };
+  const setIfMissing = (key, value) => {
+    if (value === void 0) return;
+    const current = env[key];
+    if (typeof current === "string" && current.length > 0) return;
+    env[key] = String(value);
+  };
+  setIfMissing("PUBBLUE_PROJECT_ROOT", process.cwd());
+  setIfMissing("OPENCLAW_HOME", homedir());
+  if (!bridgeConfig) return env;
+  setIfMissing("OPENCLAW_PATH", bridgeConfig.openclawPath);
+  setIfMissing("OPENCLAW_SESSION_ID", bridgeConfig.sessionId);
+  setIfMissing("OPENCLAW_THREAD_ID", bridgeConfig.threadId);
+  setIfMissing("OPENCLAW_CANVAS_REMINDER_EVERY", bridgeConfig.canvasReminderEvery);
+  setIfMissing(
+    "OPENCLAW_DELIVER",
+    bridgeConfig.deliver === void 0 ? void 0 : bridgeConfig.deliver ? "1" : "0"
+  );
+  setIfMissing("OPENCLAW_DELIVER_CHANNEL", bridgeConfig.deliverChannel);
+  setIfMissing("OPENCLAW_REPLY_TO", bridgeConfig.replyTo);
+  setIfMissing("OPENCLAW_DELIVER_TIMEOUT_MS", bridgeConfig.deliverTimeoutMs);
+  setIfMissing("OPENCLAW_ATTACHMENT_DIR", bridgeConfig.attachmentDir);
+  setIfMissing("OPENCLAW_ATTACHMENT_MAX_BYTES", bridgeConfig.attachmentMaxBytes);
+  return env;
+}
+async function ensureNodeDatachannelAvailable() {
+  try {
+    await import("node-datachannel");
+  } catch (error) {
+    failCli(
+      [
+        "node-datachannel native module is not available.",
+        "Run `pnpm rebuild node-datachannel` in the cli package and retry.",
+        `Details: ${errorMessage(error)}`
+      ].join("\n")
+    );
+  }
+}
+function isDaemonRunning(slug) {
+  return readDaemonProcessInfo(slug) !== null;
+}
+function readDaemonProcessInfo(slug) {
+  const infoPath = liveInfoPath(slug);
+  try {
+    const info = JSON.parse(fs.readFileSync(infoPath, "utf-8"));
+    if (!Number.isFinite(info.pid)) throw new Error("invalid daemon pid");
+    if (!isProcessAlive(info.pid)) throw new Error("process not alive");
+    return info;
+  } catch {
+    try {
+      fs.unlinkSync(infoPath);
+    } catch {
+    }
+    return null;
+  }
+}
+function latestCliVersionPath() {
+  return path.join(liveInfoDir(), "cli-version.txt");
+}
+function readLatestCliVersion(versionPath) {
+  const resolved = versionPath || latestCliVersionPath();
+  try {
+    const value = fs.readFileSync(resolved, "utf-8").trim();
+    return value.length === 0 ? null : value;
+  } catch {
+    return null;
+  }
+}
+function writeLatestCliVersion(version, versionPath) {
+  const trimmed = version.trim();
+  if (trimmed.length === 0) return;
+  const resolved = versionPath || latestCliVersionPath();
+  const dir = path.dirname(resolved);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(resolved, trimmed, "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 stopDaemonForLive(info) {
+  const pid = info.pid;
+  if (!isProcessAlive(pid)) return null;
+  const socketPath = info.socketPath;
+  if (socketPath) {
+    try {
+      await ipcCall(socketPath, { method: "close", params: {} });
+    } catch (error) {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch (killError) {
+        return `daemon ${pid}: IPC close failed (${errorMessage(error)}); SIGTERM failed (${errorMessage(killError)})`;
+      }
+    }
+  } else {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch (error) {
+      return `daemon ${pid}: no socketPath and SIGTERM failed (${errorMessage(error)})`;
+    }
+  }
+  const stopped = await waitForProcessExit(pid, 8e3);
+  if (!stopped) return `daemon ${pid}: did not exit after stop request`;
+  return null;
+}
+async function stopOtherDaemons() {
+  const dir = liveInfoDir();
+  const entries = fs.readdirSync(dir).filter((name) => name.endsWith(".json"));
+  const failures = [];
+  for (const entry of entries) {
+    const slug = entry.replace(/\.json$/, "");
+    const info = readDaemonProcessInfo(slug);
+    if (!info) continue;
+    const daemonError = await stopDaemonForLive(info);
+    if (daemonError) failures.push(`[${slug}] ${daemonError}`);
+  }
+  if (failures.length > 0) {
+    throw new Error(
+      [
+        "Critical: failed to stop previous live daemon processes.",
+        "Starting a new daemon now would leak resources and increase bandwidth usage.",
+        ...failures
+      ].join("\n")
+    );
+  }
+}
+function getFollowReadDelayMs(disconnected, consecutiveFailures) {
+  if (!disconnected) return 1e3;
+  return Math.min(5e3, 1e3 * 2 ** Math.min(consecutiveFailures, 3));
+}
+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 resolveBridgeMode(opts) {
+  return parseBridgeMode(opts.bridge || (opts.foreground ? "none" : "openclaw"));
+}
+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 readLogTail(logPath, maxChars = 4e3) {
+  try {
+    const content = fs.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 errorMessage(error);
+}
+async function resolveActiveSlug() {
+  const socketPath = getAgentSocketPath();
+  let response;
+  try {
+    response = await ipcCall(socketPath, { method: "active-slug", params: {} });
+  } catch {
+    failCli("No active daemon. Run `pubblue start` first.");
+  }
+  if (response.ok && typeof response.slug === "string" && response.slug.length > 0) {
+    return response.slug;
+  }
+  failCli("Daemon is running but no live is active. Wait for browser to initiate live.");
+}
+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 || !fs.existsSync(infoPath)) return;
+      pollInFlight = true;
+      void ipcCall(socketPath, { method: "status", params: {} }).then((status) => {
+        if (status.ok) done({ ok: true });
+      }).catch((error) => {
+        lastIpcError = errorMessage(error);
+      }).finally(() => {
+        pollInFlight = false;
+      });
+    }, 120);
+    const timeout = setTimeout(() => {
+      const reason = lastIpcError ? `timed out after ${timeoutMs}ms waiting for daemon readiness (last IPC error: ${lastIpcError})` : `timed out after ${timeoutMs}ms waiting for daemon readiness`;
+      done({ ok: false, reason });
+    }, timeoutMs);
+  });
+}
+
+export {
+  failCli,
+  errorMessage,
+  toCliFailure,
+  PubApiError,
+  PubApiClient,
+  CONTROL_CHANNEL,
+  CHANNELS,
+  generateMessageId,
+  encodeMessage,
+  decodeMessage,
+  makeAckMessage,
+  parseAckMessage,
+  shouldAcknowledgeMessage,
+  getAgentSocketPath,
+  ipcCall,
+  TEXT_FILE_EXTENSIONS,
+  getMimeType,
+  liveInfoPath,
+  liveLogPath,
+  buildBridgeProcessEnv,
+  ensureNodeDatachannelAvailable,
+  isDaemonRunning,
+  latestCliVersionPath,
+  readLatestCliVersion,
+  writeLatestCliVersion,
+  stopOtherDaemons,
+  getFollowReadDelayMs,
+  buildDaemonForkStdio,
+  parsePositiveIntegerOption,
+  resolveBridgeMode,
+  messageContainsPong,
+  readLogTail,
+  formatApiError,
+  resolveActiveSlug,
+  waitForDaemonReady
+};