@annals/agent-bridge 0.1.3 → 0.1.5

package/dist/chunk-W24WCWEC.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+// src/utils/openclaw-config.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/utils/logger.ts
+var RESET = "\x1B[0m";
+var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var BLUE = "\x1B[34m";
+var GRAY = "\x1B[90m";
+var BOLD = "\x1B[1m";
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+}
+var log = {
+  info(msg, ...args) {
+    console.log(`${GRAY}${timestamp()}${RESET} ${BLUE}INFO${RESET}  ${msg}`, ...args);
+  },
+  success(msg, ...args) {
+    console.log(`${GRAY}${timestamp()}${RESET} ${GREEN}OK${RESET}    ${msg}`, ...args);
+  },
+  warn(msg, ...args) {
+    console.warn(`${GRAY}${timestamp()}${RESET} ${YELLOW}WARN${RESET}  ${msg}`, ...args);
+  },
+  error(msg, ...args) {
+    console.error(`${GRAY}${timestamp()}${RESET} ${RED}ERROR${RESET} ${msg}`, ...args);
+  },
+  debug(msg, ...args) {
+    if (process.env.DEBUG) {
+      console.log(`${GRAY}${timestamp()} DEBUG ${msg}${RESET}`, ...args);
+    }
+  },
+  banner(text) {
+    console.log(`
+${BOLD}${text}${RESET}
+`);
+  }
+};
+
+// src/utils/openclaw-config.ts
+var OPENCLAW_CONFIG_PATH = join(homedir(), ".openclaw", "openclaw.json");
+function readOpenClawConfig(configPath) {
+  const path = configPath || OPENCLAW_CONFIG_PATH;
+  try {
+    const raw = readFileSync(path, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function isChatCompletionsEnabled(configPath) {
+  const config = readOpenClawConfig(configPath);
+  if (!config) return false;
+  try {
+    const enabled = config?.gateway?.http?.endpoints?.chatCompletions?.enabled;
+    return enabled === true;
+  } catch {
+    return false;
+  }
+}
+function readOpenClawToken(configPath) {
+  const path = configPath || OPENCLAW_CONFIG_PATH;
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const config = JSON.parse(raw);
+    const token = config?.gateway?.auth?.token;
+    if (typeof token === "string" && token.length > 0) {
+      return token;
+    }
+    log.warn("OpenClaw config found but gateway.auth.token is missing or empty");
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  log,
+  readOpenClawConfig,
+  isChatCompletionsEnabled,
+  readOpenClawToken
+};

package/dist/index.js

@@ -1,4 +1,8 @@
 #!/usr/bin/env node
+import {
+  log,
+  readOpenClawToken
+} from "./chunk-W24WCWEC.js";
 
 // src/index.ts
 import { program } from "commander";
@@ -49,44 +53,6 @@ function hasToken() {
 import { EventEmitter } from "events";
 import WebSocket from "ws";
 import { BRIDGE_PROTOCOL_VERSION } from "@annals/bridge-protocol";
-
-// src/utils/logger.ts
-var RESET = "\x1B[0m";
-var RED = "\x1B[31m";
-var GREEN = "\x1B[32m";
-var YELLOW = "\x1B[33m";
-var BLUE = "\x1B[34m";
-var GRAY = "\x1B[90m";
-var BOLD = "\x1B[1m";
-function timestamp() {
-  return (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
-}
-var log = {
-  info(msg, ...args) {
-    console.log(`${GRAY}${timestamp()}${RESET} ${BLUE}INFO${RESET}  ${msg}`, ...args);
-  },
-  success(msg, ...args) {
-    console.log(`${GRAY}${timestamp()}${RESET} ${GREEN}OK${RESET}    ${msg}`, ...args);
-  },
-  warn(msg, ...args) {
-    console.warn(`${GRAY}${timestamp()}${RESET} ${YELLOW}WARN${RESET}  ${msg}`, ...args);
-  },
-  error(msg, ...args) {
-    console.error(`${GRAY}${timestamp()}${RESET} ${RED}ERROR${RESET} ${msg}`, ...args);
-  },
-  debug(msg, ...args) {
-    if (process.env.DEBUG) {
-      console.log(`${GRAY}${timestamp()} DEBUG ${msg}${RESET}`, ...args);
-    }
-  },
-  banner(text) {
-    console.log(`
-${BOLD}${text}${RESET}
-`);
-  }
-};
-
-// src/platform/ws-client.ts
 var HEARTBEAT_INTERVAL = 3e4;
 var INITIAL_RECONNECT_DELAY = 1e3;
 var MAX_RECONNECT_DELAY = 3e4;
@@ -399,39 +365,34 @@ var BridgeManager = class {
   }
 };
 
-// src/adapters/openclaw.ts
-import WebSocket2 from "ws";
-import { randomUUID } from "crypto";
-
 // src/adapters/base.ts
 var AgentAdapter = class {
 };
 
 // src/adapters/openclaw.ts
-var DEFAULT_GATEWAY_URL = "ws://127.0.0.1:18789";
+var DEFAULT_GATEWAY_URL = "http://127.0.0.1:18789";
+function normalizeUrl(url) {
+  if (url.startsWith("wss://")) return url.replace("wss://", "https://");
+  if (url.startsWith("ws://")) return url.replace("ws://", "http://");
+  return url;
+}
 var OpenClawSession = class {
   constructor(sessionId, config) {
     this.config = config;
-    this.gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
-    this.gatewayToken = config.gatewayToken || "";
-    this.sessionKey = `bridge:${sessionId}`;
-  }
+    this.baseUrl = normalizeUrl(config.gatewayUrl || DEFAULT_GATEWAY_URL);
+    this.token = config.gatewayToken || "";
+    this.sessionKey = sessionId;
+  }
+  messages = [];
+  abortController = null;
+  baseUrl;
+  token;
+  sessionKey;
   chunkCallbacks = [];
   doneCallbacks = [];
   errorCallbacks = [];
-  fullText = "";
-  ws = null;
-  isConnected = false;
-  gatewayUrl;
-  gatewayToken;
-  sessionKey;
   send(message, _attachments) {
-    if (this.ws && this.ws.readyState === WebSocket2.OPEN && this.isConnected) {
-      this.sendAgentRequest(message);
-      return;
-    }
-    this.fullText = "";
-    this.connectAndSend(message);
+    this.sendRequest(message);
   }
   onChunk(cb) {
     this.chunkCallbacks.push(cb);
@@ -443,130 +404,78 @@ var OpenClawSession = class {
     this.errorCallbacks.push(cb);
   }
   kill() {
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-    this.isConnected = false;
-  }
-  connectAndSend(message) {
-    try {
-      this.ws = new WebSocket2(this.gatewayUrl);
-    } catch (err) {
-      this.emitError(new Error(`Failed to connect to OpenClaw: ${err}`));
-      return;
-    }
-    this.ws.on("open", () => {
-      log.debug(`OpenClaw WS connected to ${this.gatewayUrl}`);
-      const connectMsg = {
-        type: "req",
-        id: randomUUID(),
-        method: "connect",
-        params: {
-          minProtocol: 3,
-          maxProtocol: 3,
-          client: {
-            id: "gateway-client",
-            displayName: "Agent Bridge CLI",
-            version: "0.1.0",
-            platform: "node",
-            mode: "backend"
-          },
-          role: "operator",
-          scopes: ["operator.read", "operator.write"],
-          caps: [],
-          commands: [],
-          permissions: {},
-          auth: { token: this.gatewayToken }
-        }
-      };
-      this.ws.send(JSON.stringify(connectMsg));
-    });
-    this.ws.on("message", (data) => {
-      this.handleMessage(data.toString(), message);
-    });
-    this.ws.on("error", (err) => {
-      this.emitError(new Error(`OpenClaw WebSocket error: ${err.message}`));
-    });
-    this.ws.on("close", () => {
-      this.isConnected = false;
-    });
+    this.abortController?.abort();
+    this.abortController = null;
   }
-  handleMessage(raw, pendingMessage) {
-    let msg;
+  async sendRequest(message) {
+    this.messages.push({ role: "user", content: message });
+    this.abortController = new AbortController();
     try {
-      msg = JSON.parse(raw);
-    } catch {
-      return;
-    }
-    if (msg.type === "event" && msg.event !== "agent") {
-      return;
-    }
-    if (msg.type === "res" && !this.isConnected) {
-      if (msg.ok && msg.payload?.type === "hello-ok") {
-        this.isConnected = true;
-        log.debug("OpenClaw handshake complete");
-        if (pendingMessage) {
-          this.sendAgentRequest(pendingMessage);
-        }
-      } else {
-        this.emitError(
-          new Error(`OpenClaw auth failed: ${msg.error?.message || "unknown"}`)
-        );
-        this.ws?.close();
-      }
-      return;
-    }
-    if (msg.type === "event" && msg.event === "agent" && msg.payload) {
-      const { stream, data } = msg.payload;
-      if (stream === "assistant" && data?.text) {
-        const prevLen = this.fullText.length;
-        this.fullText = data.text;
-        if (this.fullText.length > prevLen) {
-          const delta = this.fullText.slice(prevLen);
-          for (const cb of this.chunkCallbacks) cb(delta);
-        }
+      const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.token}`,
+          "x-openclaw-session-key": this.sessionKey
+        },
+        body: JSON.stringify({
+          model: "openclaw:main",
+          messages: [...this.messages],
+          stream: true
+        }),
+        signal: this.abortController.signal
+      });
+      if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        this.emitError(new Error(`OpenClaw HTTP ${response.status}: ${text || response.statusText}`));
+        return;
       }
-      if (stream === "lifecycle" && data?.phase === "end") {
-        for (const cb of this.doneCallbacks) cb();
+      if (!response.body) {
+        this.emitError(new Error("OpenClaw response has no body"));
+        return;
       }
-      return;
-    }
-    if (msg.type === "res" && this.isConnected) {
-      if (msg.ok && msg.payload) {
-        if (msg.payload.status === "accepted") {
-          return;
-        }
-        if (msg.payload.response) {
-          for (const cb of this.chunkCallbacks) cb(msg.payload.response);
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let fullText = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop();
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith(":")) continue;
+          if (!trimmed.startsWith("data: ")) continue;
+          const data = trimmed.slice(6);
+          if (data === "[DONE]") {
+            if (fullText) {
+              this.messages.push({ role: "assistant", content: fullText });
+            }
+            for (const cb of this.doneCallbacks) cb();
+            return;
+          }
+          try {
+            const parsed = JSON.parse(data);
+            const content = parsed.choices?.[0]?.delta?.content;
+            if (content) {
+              fullText += content;
+              for (const cb of this.chunkCallbacks) cb(content);
+            }
+          } catch {
+          }
         }
-        for (const cb of this.doneCallbacks) cb();
-      } else {
-        this.emitError(
-          new Error(`OpenClaw error: ${msg.error?.message || "unknown"}`)
-        );
       }
-      return;
-    }
-    if (msg.type === "error") {
-      this.emitError(new Error(`OpenClaw error: ${msg.message || "unknown"}`));
-    }
-  }
-  sendAgentRequest(message) {
-    const req = {
-      type: "req",
-      id: randomUUID(),
-      method: "agent",
-      params: {
-        message,
-        sessionKey: this.sessionKey,
-        idempotencyKey: `idem-${Date.now()}-${randomUUID().slice(0, 8)}`
+      if (fullText) {
+        this.messages.push({ role: "assistant", content: fullText });
       }
-    };
-    try {
-      this.ws.send(JSON.stringify(req));
+      for (const cb of this.doneCallbacks) cb();
     } catch (err) {
-      this.emitError(new Error(`Failed to send to OpenClaw: ${err}`));
+      if (err instanceof Error && err.name === "AbortError") {
+        return;
+      }
+      this.emitError(err instanceof Error ? err : new Error(String(err)));
     }
   }
   emitError(err) {
@@ -587,30 +496,28 @@ var OpenClawAdapter = class extends AgentAdapter {
     this.config = config;
   }
   async isAvailable() {
-    const url = this.config.gatewayUrl || DEFAULT_GATEWAY_URL;
-    return new Promise((resolve) => {
-      let ws;
-      const timer = setTimeout(() => {
-        ws?.close();
-        resolve(false);
-      }, 5e3);
-      try {
-        ws = new WebSocket2(url);
-      } catch {
-        clearTimeout(timer);
-        resolve(false);
-        return;
-      }
-      ws.on("open", () => {
-        clearTimeout(timer);
-        ws.close();
-        resolve(true);
-      });
-      ws.on("error", () => {
-        clearTimeout(timer);
-        resolve(false);
+    const baseUrl = normalizeUrl(this.config.gatewayUrl || DEFAULT_GATEWAY_URL);
+    try {
+      const response = await fetch(`${baseUrl}/v1/chat/completions`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model: "openclaw:main",
+          messages: [],
+          stream: false
+        }),
+        signal: AbortSignal.timeout(5e3)
       });
-    });
+      if (response.status === 404) {
+        log.warn(
+          "OpenClaw endpoint not found. Enable chatCompletions in openclaw.json."
+        );
+        return false;
+      }
+      return true;
+    } catch {
+      return false;
+    }
   }
   createSession(id, config) {
     const merged = { ...this.config, ...config };
@@ -1112,27 +1019,6 @@ var GeminiAdapter = class extends AgentAdapter {
   }
 };
 
-// src/utils/openclaw-config.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join4 } from "path";
-import { homedir as homedir2 } from "os";
-var OPENCLAW_CONFIG_PATH = join4(homedir2(), ".openclaw", "openclaw.json");
-function readOpenClawToken(configPath) {
-  const path = configPath || OPENCLAW_CONFIG_PATH;
-  try {
-    const raw = readFileSync2(path, "utf-8");
-    const config = JSON.parse(raw);
-    const token = config?.gateway?.auth?.token;
-    if (typeof token === "string" && token.length > 0) {
-      return token;
-    }
-    log.warn("OpenClaw config found but gateway.auth.token is missing or empty");
-    return null;
-  } catch {
-    return null;
-  }
-}
-
 // src/commands/connect.ts
 var DEFAULT_BRIDGE_URL = "wss://bridge.agents.hot/ws";
 function createAdapter(type, config) {
@@ -1219,6 +1105,14 @@ function registerConnectCommand(program2) {
         log.warn("Sandbox not available on this platform, continuing without sandbox");
       }
     }
+    if (agentType === "openclaw") {
+      const { isChatCompletionsEnabled } = await import("./openclaw-config-OFFNWVDK.js");
+      if (!isChatCompletionsEnabled()) {
+        log.warn(
+          'OpenClaw chatCompletions endpoint may not be enabled.\n  Add to ~/.openclaw/openclaw.json:\n  { "gateway": { "http": { "endpoints": { "chatCompletions": { "enabled": true } } } } }\n  Continuing anyway (gateway may be on a remote host)...'
+        );
+      }
+    }
     const adapterConfig = {
       project: opts.project,
       gatewayUrl: opts.gatewayUrl || config.gatewayUrl,

package/dist/openclaw-config-OFFNWVDK.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  isChatCompletionsEnabled,
+  readOpenClawConfig,
+  readOpenClawToken
+} from "./chunk-W24WCWEC.js";
+export {
+  isChatCompletionsEnabled,
+  readOpenClawConfig,
+  readOpenClawToken
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@annals/agent-bridge",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "CLI bridge connecting local AI agents to the Agents.Hot platform",
   "type": "module",
   "bin": {