pubblue 0.4.12 → 0.6.1

package/dist/tunnel-daemon-BR5XKNEA.js

@@ -0,0 +1,7 @@
+import {
+  startDaemon
+} from "./chunk-WXNNDR4T.js";
+import "./chunk-BBJOOZHS.js";
+export {
+  startDaemon
+};

package/dist/tunnel-daemon-entry.js

@@ -1,25 +1,27 @@
 import {
   startDaemon
-} from "./chunk-UW7JILRJ.js";
+} from "./chunk-WXNNDR4T.js";
 import {
-  TunnelApiClient
-} from "./chunk-7NFHPJ76.js";
-import "./chunk-4YTJ2WKF.js";
+  PubApiClient
+} from "./chunk-BBJOOZHS.js";
 
 // src/tunnel-daemon-entry.ts
-var tunnelId = process.env.PUBBLUE_DAEMON_TUNNEL_ID;
 var baseUrl = process.env.PUBBLUE_DAEMON_BASE_URL;
 var apiKey = process.env.PUBBLUE_DAEMON_API_KEY;
 var socketPath = process.env.PUBBLUE_DAEMON_SOCKET;
 var infoPath = process.env.PUBBLUE_DAEMON_INFO;
 var cliVersion = process.env.PUBBLUE_CLI_VERSION;
-if (!tunnelId || !baseUrl || !apiKey || !socketPath || !infoPath) {
+var agentName = process.env.PUBBLUE_DAEMON_AGENT_NAME;
+var bridgeMode = process.env.PUBBLUE_DAEMON_BRIDGE_MODE || "openclaw";
+if (!baseUrl || !apiKey || !socketPath || !infoPath) {
   console.error("Missing required env vars for daemon.");
   process.exit(1);
 }
-var apiClient = new TunnelApiClient(baseUrl, apiKey);
-void startDaemon({ tunnelId, apiClient, socketPath, infoPath, cliVersion }).catch((error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  console.error(`Tunnel daemon failed to start: ${message}`);
-  process.exit(1);
-});
+var apiClient = new PubApiClient(baseUrl, apiKey);
+void startDaemon({ apiClient, socketPath, infoPath, cliVersion, bridgeMode, agentName }).catch(
+  (error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Daemon failed to start: ${message}`);
+    process.exit(1);
+  }
+);

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "pubblue",
-  "version": "0.4.12",
-  "description": "CLI tool for publishing static content via pub.blue",
+  "version": "0.6.1",
+  "description": "CLI tool for publishing content and running interactive sessions via pub.blue",
   "type": "module",
   "bin": {
     "pubblue": "./dist/index.js"
   },
   "scripts": {
-    "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",
+    "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",
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "tsc --noEmit"

package/dist/chunk-4YTJ2WKF.js

@@ -1,60 +0,0 @@
-// ../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;
-}
-var MAX_TUNNEL_EXPIRY_MS = 7 * 24 * 60 * 60 * 1e3;
-var DEFAULT_TUNNEL_EXPIRY_MS = 24 * 60 * 60 * 1e3;
-
-export {
-  CONTROL_CHANNEL,
-  CHANNELS,
-  generateMessageId,
-  encodeMessage,
-  decodeMessage,
-  makeAckMessage,
-  parseAckMessage,
-  shouldAcknowledgeMessage
-};

package/dist/chunk-7NFHPJ76.js

@@ -1,79 +0,0 @@
-// src/lib/tunnel-api.ts
-var TunnelApiError = class extends Error {
-  constructor(message, status, retryAfterSeconds) {
-    super(message);
-    this.status = status;
-    this.retryAfterSeconds = retryAfterSeconds;
-    this.name = "TunnelApiError";
-  }
-};
-var TunnelApiClient = class {
-  constructor(baseUrl, apiKey) {
-    this.baseUrl = baseUrl;
-    this.apiKey = apiKey;
-  }
-  async request(path, options = {}) {
-    const url = new URL(path, 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 TunnelApiError(
-          `Rate limit exceeded.${retrySuffix}`,
-          res.status,
-          retryAfterSeconds
-        );
-      }
-      throw new TunnelApiError(data.error || `Request failed: ${res.status}`, res.status);
-    }
-    return data;
-  }
-  async create(opts) {
-    return this.request("/api/v1/tunnels", {
-      method: "POST",
-      body: JSON.stringify(opts)
-    });
-  }
-  async get(tunnelId) {
-    const data = await this.request(
-      `/api/v1/tunnels/${encodeURIComponent(tunnelId)}`
-    );
-    return data.tunnel;
-  }
-  async list() {
-    const data = await this.request("/api/v1/tunnels/");
-    return data.tunnels;
-  }
-  async signal(tunnelId, opts) {
-    await this.request(`/api/v1/tunnels/${encodeURIComponent(tunnelId)}/signal`, {
-      method: "PATCH",
-      body: JSON.stringify(opts)
-    });
-  }
-  async close(tunnelId) {
-    await this.request(`/api/v1/tunnels/${encodeURIComponent(tunnelId)}`, {
-      method: "DELETE"
-    });
-  }
-};
-
-export {
-  TunnelApiError,
-  TunnelApiClient
-};

package/dist/chunk-HJ5LTUHS.js

@@ -1,56 +0,0 @@
-// src/lib/tunnel-ipc.ts
-import * as net from "net";
-function getSocketPath(tunnelId) {
-  return `/tmp/pubblue-${tunnelId}.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. Is the tunnel still active?")));
-      } 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);
-  });
-}
-
-export {
-  getSocketPath,
-  ipcCall
-};