pubblue 0.4.12 → 0.6.1

package/dist/chunk-BBJOOZHS.js

@@ -0,0 +1,676 @@
+// 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"
+    });
+  }
+  // -- 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/tunnel-helpers.ts
+import * as fs2 from "fs";
+import { homedir as homedir2 } from "os";
+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/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",
+  ".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 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) 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);
+  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) {
+    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");
+    if (!isProcessAlive(info.pid)) throw new Error("process not alive");
+    return info;
+  } catch {
+    try {
+      fs2.unlinkSync(infoPath);
+    } catch {
+    }
+    return null;
+  }
+}
+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 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() {
+  const dir = liveInfoDir();
+  const entries = fs2.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) {
+  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 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 || !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);
+  });
+}
+
+export {
+  failCli,
+  toCliFailure,
+  loadConfig,
+  saveConfig,
+  getConfig,
+  getTelegramMiniAppUrl,
+  PubApiError,
+  PubApiClient,
+  CONTROL_CHANNEL,
+  CHANNELS,
+  generateMessageId,
+  encodeMessage,
+  decodeMessage,
+  makeAckMessage,
+  parseAckMessage,
+  shouldAcknowledgeMessage,
+  getAgentSocketPath,
+  ipcCall,
+  TEXT_FILE_EXTENSIONS,
+  getMimeType,
+  liveInfoPath,
+  liveLogPath,
+  createApiClient,
+  buildBridgeProcessEnv,
+  ensureNodeDatachannelAvailable,
+  isDaemonRunning,
+  latestCliVersionPath,
+  readLatestCliVersion,
+  writeLatestCliVersion,
+  stopOtherDaemons,
+  getFollowReadDelayMs,
+  buildDaemonForkStdio,
+  parsePositiveIntegerOption,
+  resolveBridgeMode,
+  messageContainsPong,
+  readLogTail,
+  formatApiError,
+  resolveActiveSlug,
+  waitForDaemonReady
+};