pubblue 0.4.5 → 0.4.10

package/dist/tunnel-bridge-entry.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/tunnel-bridge-entry.js

@@ -0,0 +1,305 @@
+import {
+  ipcCall
+} from "./chunk-HJ5LTUHS.js";
+import {
+  CHANNELS,
+  generateMessageId
+} from "./chunk-MW35LBNH.js";
+
+// src/lib/tunnel-bridge-openclaw.ts
+import { execFile, execFileSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var OPENCLAW_DISCOVERY_PATHS = [
+  "/app/dist/index.js",
+  join(homedir(), "openclaw", "dist", "index.js"),
+  join(homedir(), ".openclaw", "openclaw"),
+  "/usr/local/bin/openclaw",
+  "/opt/homebrew/bin/openclaw"
+];
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function readSessionIdFromOpenClaw(threadId) {
+  try {
+    const sessionsPath = join(
+      homedir(),
+      ".openclaw",
+      "agents",
+      "main",
+      "sessions",
+      "sessions.json"
+    );
+    const sessions = JSON.parse(readFileSync(sessionsPath, "utf-8"));
+    if (threadId && threadId.length > 0) {
+      const byThread = sessions[`agent:main:main:thread:${threadId}`];
+      if (typeof byThread?.sessionId === "string" && byThread.sessionId.length > 0) {
+        return byThread.sessionId;
+      }
+    }
+    const main = sessions["agent:main:main"];
+    if (typeof main?.sessionId === "string" && main.sessionId.length > 0) {
+      return main.sessionId;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function resolveOpenClawPath() {
+  const configuredPath = process.env.OPENCLAW_PATH;
+  if (configuredPath) {
+    if (!existsSync(configuredPath)) {
+      throw new Error(`OPENCLAW_PATH does not exist: ${configuredPath}`);
+    }
+    return configuredPath;
+  }
+  try {
+    const which = execFileSync("which", ["openclaw"], { timeout: 5e3 }).toString().trim();
+    if (which.length > 0 && existsSync(which)) {
+      return which;
+    }
+  } catch {
+  }
+  for (const candidate of OPENCLAW_DISCOVERY_PATHS) {
+    if (existsSync(candidate)) return candidate;
+  }
+  throw new Error(
+    [
+      "OpenClaw executable was not found.",
+      "Configure it with: pubblue configure --set openclaw.path=/absolute/path/to/openclaw",
+      "Or set OPENCLAW_PATH in environment.",
+      `Checked: ${OPENCLAW_DISCOVERY_PATHS.join(", ")}`
+    ].join(" ")
+  );
+}
+function getOpenClawInvocation(openclawPath, args) {
+  if (openclawPath.endsWith(".js")) {
+    return { cmd: process.execPath, args: [openclawPath, ...args] };
+  }
+  return { cmd: openclawPath, args };
+}
+function formatExecFailure(prefix, error) {
+  if (!(error instanceof Error)) {
+    return new Error(`${prefix}: ${String(error)}`);
+  }
+  const withOutput = error;
+  const stderr = typeof withOutput.stderr === "string" ? withOutput.stderr.trim() : Buffer.isBuffer(withOutput.stderr) ? withOutput.stderr.toString("utf-8").trim() : "";
+  const stdout = typeof withOutput.stdout === "string" ? withOutput.stdout.trim() : Buffer.isBuffer(withOutput.stdout) ? withOutput.stdout.toString("utf-8").trim() : "";
+  const detail = stderr || stdout || error.message;
+  return new Error(`${prefix}: ${detail}`);
+}
+function buildInboundPrompt(tunnelId2, userText) {
+  return [
+    `[Pubblue Tunnel ${tunnelId2}] Incoming user message:`,
+    "",
+    userText,
+    "",
+    "---",
+    `Reply with: pubblue tunnel write --tunnel ${tunnelId2} "<your reply>"`,
+    `Canvas update: pubblue tunnel write --tunnel ${tunnelId2} -c canvas -f /path/to/file.html`
+  ].join("\n");
+}
+function readTextChatMessage(entry) {
+  if (!entry || typeof entry !== "object") return null;
+  const outer = entry;
+  if (outer.channel !== CHANNELS.CHAT || !outer.msg || typeof outer.msg !== "object") return null;
+  const msg = outer.msg;
+  if (msg.type !== "text" || typeof msg.data !== "string" || typeof msg.id !== "string")
+    return null;
+  return { id: msg.id, text: msg.data };
+}
+function writeBridgeInfo(infoPath2, patch) {
+  const payload = {
+    ...patch,
+    updatedAt: patch.updatedAt ?? Date.now()
+  };
+  writeFileSync(infoPath2, JSON.stringify(payload));
+}
+async function runOpenClawPreflight(openclawPath) {
+  const invocation = getOpenClawInvocation(openclawPath, ["agent", "--help"]);
+  try {
+    await execFileAsync(invocation.cmd, invocation.args, {
+      timeout: 1e4
+    });
+  } catch (error) {
+    throw formatExecFailure("OpenClaw preflight failed", error);
+  }
+}
+async function deliverMessageToOpenClaw(params) {
+  const deliverText = buildInboundPrompt(params.tunnelId, params.text);
+  const timeoutMs = Number.parseInt(process.env.OPENCLAW_DELIVER_TIMEOUT_MS || "120000", 10);
+  const effectiveTimeoutMs = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : 12e4;
+  const args = ["agent", "--local", "--session-id", params.sessionId, "-m", deliverText];
+  const shouldDeliver = process.env.OPENCLAW_DELIVER === "1" || Boolean(process.env.OPENCLAW_DELIVER_CHANNEL) || Boolean(process.env.OPENCLAW_REPLY_TO);
+  if (shouldDeliver) args.push("--deliver");
+  if (process.env.OPENCLAW_DELIVER_CHANNEL) {
+    args.push("--channel", process.env.OPENCLAW_DELIVER_CHANNEL);
+  }
+  if (process.env.OPENCLAW_REPLY_TO) {
+    args.push("--reply-to", process.env.OPENCLAW_REPLY_TO);
+  }
+  const invocation = getOpenClawInvocation(params.openclawPath, args);
+  try {
+    await execFileAsync(invocation.cmd, invocation.args, {
+      timeout: effectiveTimeoutMs
+    });
+  } catch (error) {
+    throw formatExecFailure("OpenClaw delivery failed", error);
+  }
+}
+async function startOpenClawBridge(params) {
+  const startedAt = Date.now();
+  const baseInfo = {
+    pid: process.pid,
+    tunnelId: params.tunnelId,
+    mode: "openclaw",
+    startedAt
+  };
+  let shuttingDown = false;
+  const shutdown = () => {
+    shuttingDown = true;
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  writeBridgeInfo(params.infoPath, {
+    ...baseInfo,
+    status: "starting"
+  });
+  try {
+    const openclawPath = resolveOpenClawPath();
+    const sessionId = process.env.OPENCLAW_SESSION_ID || readSessionIdFromOpenClaw(process.env.OPENCLAW_THREAD_ID) || "";
+    if (sessionId.length === 0) {
+      throw new Error(
+        [
+          "OpenClaw session could not be resolved.",
+          "Configure one of:",
+          "  pubblue configure --set openclaw.sessionId=<session-id>",
+          "  pubblue configure --set openclaw.threadId=<thread-id>",
+          "Or set OPENCLAW_SESSION_ID / OPENCLAW_THREAD_ID in environment."
+        ].join("\n")
+      );
+    }
+    await runOpenClawPreflight(openclawPath);
+    try {
+      const daemonStatus = await ipcCall(params.socketPath, { method: "status", params: {} });
+      if (!daemonStatus.ok) {
+        throw new Error(String(daemonStatus.error || "daemon status request failed"));
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to connect to local tunnel daemon socket (${params.socketPath}): ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    writeBridgeInfo(params.infoPath, {
+      ...baseInfo,
+      sessionId,
+      status: "ready"
+    });
+    const seenIds = /* @__PURE__ */ new Set();
+    let consecutiveReadFailures = 0;
+    while (!shuttingDown) {
+      let messages = [];
+      try {
+        const response = await ipcCall(params.socketPath, {
+          method: "read",
+          params: { channel: CHANNELS.CHAT }
+        });
+        if (!response.ok) {
+          throw new Error(String(response.error || "daemon read failed"));
+        }
+        messages = Array.isArray(response.messages) ? response.messages : [];
+        consecutiveReadFailures = 0;
+      } catch (error) {
+        consecutiveReadFailures += 1;
+        writeBridgeInfo(params.infoPath, {
+          ...baseInfo,
+          sessionId,
+          status: "waiting-daemon",
+          lastError: error instanceof Error ? error.message : String(error)
+        });
+        const delayMs = Math.min(5e3, 500 * 2 ** Math.min(consecutiveReadFailures, 4));
+        await sleep(delayMs);
+        continue;
+      }
+      if (messages.length === 0) {
+        await sleep(400);
+        continue;
+      }
+      for (const entry of messages) {
+        const chat = readTextChatMessage(entry);
+        if (!chat || seenIds.has(chat.id)) continue;
+        await deliverMessageToOpenClaw({
+          openclawPath,
+          sessionId,
+          text: chat.text,
+          tunnelId: params.tunnelId
+        });
+        seenIds.add(chat.id);
+      }
+      writeBridgeInfo(params.infoPath, {
+        ...baseInfo,
+        sessionId,
+        status: "ready"
+      });
+    }
+    writeBridgeInfo(params.infoPath, {
+      ...baseInfo,
+      sessionId,
+      status: "stopped"
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    writeBridgeInfo(params.infoPath, {
+      ...baseInfo,
+      status: "error",
+      lastError: message
+    });
+    try {
+      await ipcCall(params.socketPath, {
+        method: "write",
+        params: {
+          channel: CHANNELS.CHAT,
+          msg: {
+            id: generateMessageId(),
+            type: "text",
+            data: `Bridge error: ${message}`
+          }
+        }
+      });
+    } catch {
+    }
+    throw error;
+  } finally {
+    process.off("SIGINT", shutdown);
+    process.off("SIGTERM", shutdown);
+  }
+}
+
+// src/tunnel-bridge-entry.ts
+var mode = process.env.PUBBLUE_BRIDGE_MODE;
+var tunnelId = process.env.PUBBLUE_BRIDGE_TUNNEL_ID;
+var socketPath = process.env.PUBBLUE_BRIDGE_SOCKET;
+var infoPath = process.env.PUBBLUE_BRIDGE_INFO;
+if (!mode || !tunnelId || !socketPath || !infoPath) {
+  console.error("Missing required env vars for bridge process.");
+  process.exit(1);
+}
+if (mode !== "openclaw") {
+  console.error(`Unsupported bridge mode: ${mode}. Supported values: openclaw`);
+  process.exit(1);
+}
+void startOpenClawBridge({
+  tunnelId,
+  socketPath,
+  infoPath
+}).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Tunnel bridge failed: ${message}`);
+  process.exit(1);
+});

package/dist/{tunnel-daemon-DR4A65ME.js → tunnel-daemon-4LV6HLYN.js}

@@ -2,7 +2,7 @@ import {
   getTunnelWriteReadinessError,
   shouldRecoverForBrowserAnswerChange,
   startDaemon
-} from "./chunk-AIEPM67G.js";
+} from "./chunk-HOHLQGQT.js";
 import "./chunk-MW35LBNH.js";
 export {
   getTunnelWriteReadinessError,

package/dist/tunnel-daemon-entry.js

@@ -1,9 +1,9 @@
 import {
   TunnelApiClient
-} from "./chunk-BV423NLA.js";
+} from "./chunk-7NFHPJ76.js";
 import {
   startDaemon
-} from "./chunk-AIEPM67G.js";
+} from "./chunk-HOHLQGQT.js";
 import "./chunk-MW35LBNH.js";
 
 // src/tunnel-daemon-entry.ts

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "pubblue",
-  "version": "0.4.5",
+  "version": "0.4.10",
   "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 --format esm --dts --clean",
-    "dev": "tsup src/index.ts src/tunnel-daemon-entry.ts --format esm --watch",
+    "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"