openclaw-bridge 0.2.2 → 0.3.0

package/src/config.ts

@@ -55,6 +55,15 @@ export function parseConfig(raw: unknown): BridgeConfig {
       typeof obj.offlineThresholdMs === "number"
         ? obj.offlineThresholdMs
         : DEFAULTS.offlineThresholdMs,
+    description: typeof obj.description === "string" ? obj.description : undefined,
+    supportsVision: typeof obj.supportsVision === "boolean" ? obj.supportsVision : undefined,
+    localManager: obj.localManager
+      ? {
+          enabled: !!(obj.localManager as Record<string, unknown>).enabled,
+          hubUrl: (obj.localManager as Record<string, unknown>).hubUrl as string,
+          managerPass: (obj.localManager as Record<string, unknown>).managerPass as string,
+        }
+      : undefined,
   };
 }
 

package/src/heartbeat.ts

@@ -73,6 +73,8 @@ export class BridgeHeartbeat {
     await this.detectConfigChanges();
 
     this.entry.lastHeartbeat = new Date().toISOString();
+    this.entry.memMB = Math.round(process.memoryUsage().rss / 1024 / 1024);
+    this.entry.supportsVision = this.detectVisionSupport();
 
     const currentHash = this.computeEntryHash();
     if (currentHash !== this.lastConfigHash) {
@@ -87,6 +89,30 @@ export class BridgeHeartbeat {
     await this.fileOps.processPendingCommands();
   }
 
+  private detectVisionSupport(): boolean {
+    if (this.config.supportsVision !== undefined) {
+      return this.config.supportsVision;
+    }
+    if (!this.configPath) return false;
+    try {
+      const raw = readFileSync(this.configPath, "utf-8");
+      const config = JSON.parse(raw) as {
+        models?: {
+          default?: string;
+          list?: Array<{ id?: string; name?: string }>;
+        };
+      };
+      const defaultModel = config.models?.default ?? "";
+      const visionPatterns = [
+        "gpt-4o", "gpt-4-vision", "claude-3", "claude-sonnet", "claude-opus",
+        "gemini", "gemini-pro", "gemini-2", "pixtral", "llava",
+      ];
+      return visionPatterns.some((p) => defaultModel.toLowerCase().includes(p));
+    } catch {
+      return false;
+    }
+  }
+
   private async detectConfigChanges(): Promise<void> {
     if (!this.configPath) return;
 

package/src/index.ts

@@ -9,6 +9,7 @@ import { assertPermission } from "./permissions.js";
 import { discoverAll, whois } from "./discovery.js";
 import { MessageRelayClient } from "./message-relay.js";
 import * as proxySession from "./session.js";
+import { LocalManager } from "./manager/local-manager.js";
 import type { OpenClawPluginApi, RegistryEntry } from "./types.js";
 
 function resolveWorkspacePath(agentId: string): string {
@@ -136,10 +137,21 @@ const bridgePlugin = {
       registeredAt: new Date().toISOString(),
       lastHeartbeat: new Date().toISOString(),
       status: "online",
+      description: config.description,
+      supportsVision: config.supportsVision,
     };
 
     const heartbeat = new BridgeHeartbeat(config, registry, fileOps, entry, api.logger);
 
+    let localManager: LocalManager | null = null;
+    if (config.localManager?.enabled) {
+      localManager = new LocalManager(
+        config.localManager,
+        config.fileRelay?.apiKey ?? "",
+        api.logger,
+      );
+    }
+
     // Cache for context injection (refreshed every heartbeat)
     let cachedAgentList = "";
     let lastDiscoverTime = 0;
@@ -223,6 +235,9 @@ ${nameMapping}
       id: "openclaw-bridge",
       async start() {
         await heartbeat.start();
+        if (localManager) {
+          await localManager.start();
+        }
         await refreshAgentContext();
 
         // Initialize Message Relay if configured
@@ -244,6 +259,23 @@ ${nameMapping}
               gatewayToken = raw.gateway?.auth?.token || '';
             } catch { /* no token */ }
 
+            // Check if payload is multimodal JSON (from Hub chat with image)
+            let messages: any[];
+            try {
+              const parsed = JSON.parse(payload);
+              if (parsed.text && parsed.image) {
+                // Multimodal: text + image
+                messages = [{ role: 'user', content: [
+                  { type: 'text', text: parsed.text },
+                  { type: 'image_url', image_url: { url: parsed.image } },
+                ]}];
+              } else {
+                messages = [{ role: 'user', content: payload }];
+              }
+            } catch {
+              messages = [{ role: 'user', content: payload }];
+            }
+
             const url = `http://127.0.0.1:${entry.port}/v1/chat/completions`;
             const res = await fetch(url, {
               method: 'POST',
@@ -253,7 +285,7 @@ ${nameMapping}
               },
               body: JSON.stringify({
                 model: 'openclaw/default',
-                messages: [{ role: 'user', content: payload }],
+                messages,
               }),
               signal: AbortSignal.timeout(55_000),
             });
@@ -349,6 +381,9 @@ ${nameMapping}
         api.logger.info(`openclaw-bridge: initialized (${config.agentId}, role=${config.role})`);
       },
       async stop() {
+        if (localManager) {
+          await localManager.stop();
+        }
         if (relayClient) {
           await relayClient.disconnect();
         }

package/src/manager/hub-client.ts

@@ -0,0 +1,114 @@
+import WebSocket from "ws";
+import { hostname } from "node:os";
+import type { PluginLogger } from "../types.js";
+
+export class ManagerHubClient {
+  private hubUrl: string;
+  private apiKey: string;
+  private managerPass: string;
+  private machineId: string;
+  private ws: WebSocket | null = null;
+  private _connected = false;
+  private reconnectDelay = 1000;
+  private logger: PluginLogger;
+  onCommand: ((msg: any) => void) | null = null;
+
+  constructor(
+    hubUrl: string,
+    apiKey: string,
+    managerPass: string,
+    logger: PluginLogger,
+  ) {
+    this.hubUrl = hubUrl;
+    this.apiKey = apiKey;
+    this.managerPass = managerPass;
+    this.machineId = hostname();
+    this.logger = logger;
+  }
+
+  get connected(): boolean {
+    return this._connected;
+  }
+
+  async connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const wsUrl = this.hubUrl.replace(/^http/, "ws") + "/ws/manager";
+      this.ws = new WebSocket(wsUrl);
+
+      this.ws.on("open", () => {
+        this.ws!.send(
+          JSON.stringify({
+            type: "auth",
+            role: "manager",
+            machineId: this.machineId,
+            apiKey: this.apiKey,
+            managerPass: this.managerPass,
+          }),
+        );
+      });
+
+      this.ws.on("message", (data) => {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === "auth_ok") {
+          this._connected = true;
+          this.reconnectDelay = 1000;
+          this.logger.info(
+            `[local-manager] Hub connected as ${this.machineId}`,
+          );
+          resolve();
+          return;
+        }
+        if (msg.type === "auth_error") {
+          reject(new Error(msg.reason));
+          return;
+        }
+        if (msg.type === "manager_command" && this.onCommand) {
+          this.onCommand(msg);
+        }
+      });
+
+      this.ws.on("close", () => {
+        this._connected = false;
+        this.logger.warn(
+          `[local-manager] Hub disconnected, reconnecting in ${this.reconnectDelay}ms...`,
+        );
+        setTimeout(() => {
+          this.connect().catch(() => {
+            this.reconnectDelay = Math.min(this.reconnectDelay * 2, 30_000);
+          });
+        }, this.reconnectDelay);
+      });
+
+      this.ws.on("error", (err) => {
+        this.logger.error(`[local-manager] Hub error: ${err.message}`);
+      });
+    });
+  }
+
+  sendStatus(agents: any[], logs?: Record<string, string>): void {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(
+        JSON.stringify({
+          type: "manager_status",
+          machineId: this.machineId,
+          agents,
+          logs,
+        }),
+      );
+    }
+  }
+
+  sendResult(action: string, target: string, success: boolean): void {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify({ type: "manager_result", action, target, success }));
+    }
+  }
+
+  disconnect(): void {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+      this._connected = false;
+    }
+  }
+}

package/src/manager/local-manager.ts

@@ -0,0 +1,121 @@
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { PluginLogger, LocalManagerConfig } from "../types.js";
+import { ManagerHubClient } from "./hub-client.js";
+import {
+  listProcesses,
+  getProcessLogs,
+  restartProcess,
+  stopProcess,
+  startProcess,
+  stopAll,
+} from "./pm2-bridge.js";
+
+const LOCK_FILE = join(tmpdir(), "openclaw-local-manager.lock");
+
+function acquireLock(): boolean {
+  if (existsSync(LOCK_FILE)) {
+    try {
+      const pid = parseInt(readFileSync(LOCK_FILE, "utf-8").trim(), 10);
+      process.kill(pid, 0);
+      return false;
+    } catch {
+      // Process is dead, steal the lock
+    }
+  }
+  writeFileSync(LOCK_FILE, String(process.pid));
+  return true;
+}
+
+function releaseLock(): void {
+  try { unlinkSync(LOCK_FILE); } catch {}
+}
+
+export class LocalManager {
+  private config: LocalManagerConfig;
+  private apiKey: string;
+  private logger: PluginLogger;
+  private hubClient: ManagerHubClient | null = null;
+  private statusTimer: ReturnType<typeof setInterval> | null = null;
+  private hasLock = false;
+
+  constructor(config: LocalManagerConfig, apiKey: string, logger: PluginLogger) {
+    this.config = config;
+    this.apiKey = apiKey;
+    this.logger = logger;
+  }
+
+  async start(): Promise<void> {
+    if (!this.config.enabled) return;
+
+    this.hasLock = acquireLock();
+    if (!this.hasLock) {
+      this.logger.info("[local-manager] Another instance is already managing this machine, skipping");
+      return;
+    }
+
+    this.hubClient = new ManagerHubClient(
+      this.config.hubUrl, this.apiKey, this.config.managerPass, this.logger,
+    );
+
+    this.hubClient.onCommand = async (msg: any) => {
+      const processes = await listProcesses();
+      let target = msg.target;
+
+      if (msg.action !== "restart-all" && msg.action !== "stop-all") {
+        const match = processes.find((p) => p.agentId === msg.target || p.name === msg.target);
+        if (match) {
+          target = match.name;
+        } else {
+          this.logger.error(`[local-manager] No PM2 process found for: ${msg.target}`);
+          this.hubClient!.sendResult(msg.action, msg.target, false);
+          return;
+        }
+      }
+
+      this.logger.info(`[local-manager] ${msg.action} ${target}`);
+      try {
+        if (msg.action === "restart") await restartProcess(target);
+        else if (msg.action === "stop") await stopProcess(target);
+        else if (msg.action === "start") await startProcess(target);
+        else if (msg.action === "restart-all") await stopAll();
+        else if (msg.action === "stop-all") await stopAll();
+        this.hubClient!.sendResult(msg.action, msg.target, true);
+      } catch (err: any) {
+        this.logger.error(`[local-manager] Failed: ${err.message}`);
+        this.hubClient!.sendResult(msg.action, msg.target, false);
+      }
+    };
+
+    try {
+      await this.hubClient.connect();
+    } catch (err: any) {
+      this.logger.warn(`[local-manager] Hub connect failed: ${err.message}. Will retry.`);
+    }
+
+    this.statusTimer = setInterval(async () => {
+      try {
+        const processes = await listProcesses();
+        const logs: Record<string, string> = {};
+        for (const proc of processes) {
+          logs[proc.name] = await getProcessLogs(proc.name);
+        }
+        if (this.hubClient?.connected) {
+          this.hubClient.sendStatus(processes, logs);
+        }
+      } catch (err: any) {
+        this.logger.warn(`[local-manager] Status tick failed: ${err.message}`);
+      }
+    }, 30_000);
+
+    this.logger.info("[local-manager] Started (reporting every 30s)");
+  }
+
+  async stop(): Promise<void> {
+    if (this.statusTimer) { clearInterval(this.statusTimer); this.statusTimer = null; }
+    if (this.hubClient) { this.hubClient.disconnect(); this.hubClient = null; }
+    if (this.hasLock) releaseLock();
+    this.logger.info("[local-manager] Stopped");
+  }
+}

package/src/manager/pm2-bridge.ts

@@ -0,0 +1,125 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { platform } from "node:os";
+
+const _exec = promisify(exec);
+const execAsync = (cmd: string, opts?: Record<string, unknown>) =>
+  _exec(cmd, { windowsHide: true, encoding: "utf-8", ...opts } as any);
+const IS_WIN = platform() === "win32";
+
+export interface PM2Process {
+  name: string;
+  agentId: string;
+  pid: number;
+  status: string;
+  memory: number;
+  cpu: number;
+  restarts: number;
+  uptime: number;
+}
+
+async function killPort(port: number): Promise<void> {
+  if (!port) return;
+  try {
+    if (IS_WIN) {
+      const { stdout } = await execAsync(
+        `netstat -ano | findstr :${port} | findstr LISTENING`,
+      );
+      const pids = new Set<string>();
+      stdout.split("\n").forEach((line: string) => {
+        const pid = line.trim().split(/\s+/).pop();
+        if (pid && /^\d+$/.test(pid) && pid !== "0") pids.add(pid);
+      });
+      for (const pid of pids) {
+        await execAsync(`taskkill /F /PID ${pid}`).catch(() => {});
+      }
+    } else {
+      await execAsync(`lsof -ti:${port} | xargs kill -9`).catch(() => {});
+    }
+  } catch {
+    // No process on port
+  }
+}
+
+async function getProcessPort(name: string): Promise<number | null> {
+  try {
+    const { stdout } = await execAsync("pm2 jlist");
+    const apps = JSON.parse(stdout);
+    const app = apps.find((a: any) => a.name === name);
+    if (app?.pm2_env?.env?.OPENCLAW_GATEWAY_PORT) {
+      return parseInt(app.pm2_env.env.OPENCLAW_GATEWAY_PORT, 10);
+    }
+    if (app?.pm2_env?.pm_exec_path) {
+      const { readFileSync } = await import("node:fs");
+      const dir = app.pm2_env.pm_exec_path.replace(/[/\\]run\.sh$/, "");
+      const script = readFileSync(dir + "/run.sh", "utf-8");
+      const match = script.match(/OPENCLAW_GATEWAY_PORT="?(\d+)/);
+      if (match) return parseInt(match[1], 10);
+    }
+  } catch {}
+  return null;
+}
+
+export async function listProcesses(): Promise<PM2Process[]> {
+  try {
+    const { stdout } = await execAsync("pm2 jlist");
+    const apps = JSON.parse(stdout);
+    return apps.map((p: any) => ({
+      name: p.name,
+      agentId: p.name.replace(/^gw-/, ""),
+      pid: p.pid,
+      status: p.pm2_env?.status || "unknown",
+      memory: p.monit?.memory || 0,
+      cpu: p.monit?.cpu || 0,
+      restarts: p.pm2_env?.restart_time || 0,
+      uptime: p.pm2_env?.pm_uptime ? Date.now() - p.pm2_env.pm_uptime : 0,
+    }));
+  } catch (err: any) {
+    return [];
+  }
+}
+
+export async function getProcessLogs(name: string): Promise<string> {
+  try {
+    const { stdout } = await execAsync(
+      `pm2 logs ${name} --nostream --lines 100`,
+      { timeout: 10_000 },
+    );
+    return stdout;
+  } catch {
+    return "(logs unavailable)";
+  }
+}
+
+export async function restartProcess(name: string): Promise<void> {
+  await execAsync("pm2 stop " + name).catch(() => {});
+  const port = await getProcessPort(name);
+  if (port) await killPort(port);
+  await new Promise((r) => setTimeout(r, 1000));
+  await execAsync("pm2 restart " + name);
+}
+
+export async function stopProcess(name: string): Promise<void> {
+  await execAsync("pm2 stop " + name);
+  const port = await getProcessPort(name);
+  if (port) await killPort(port);
+}
+
+export async function startProcess(name: string): Promise<void> {
+  const port = await getProcessPort(name);
+  if (port) await killPort(port);
+  await execAsync("pm2 restart " + name);
+}
+
+export async function stopAll(): Promise<void> {
+  const procs = await listProcesses();
+  await execAsync("pm2 stop all");
+  for (const proc of procs) {
+    const port = await getProcessPort(proc.name);
+    if (port) await killPort(port);
+  }
+}
+
+export async function startAll(ecosystemPath: string): Promise<void> {
+  await execAsync("pm2 start " + ecosystemPath);
+}

package/src/message-relay.ts

@@ -12,6 +12,8 @@ export class MessageRelayClient {
   private reconnectDelay = 1000;
   private maxReconnectDelay = 30000;
   private shouldReconnect = true;
+  private authenticated = false;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
   private pendingCallbacks = new Map<string, {
     resolve: (msg: any) => void;
     reject: (err: Error) => void;
@@ -25,14 +27,30 @@ export class MessageRelayClient {
   }
 
   async connect(): Promise<void> {
+    // Clean up any existing connection
+    if (this.ws) {
+      try { this.ws.removeAllListeners(); this.ws.close(); } catch {}
+      this.ws = null;
+    }
+    this.authenticated = false;
+
     return new Promise((resolve, reject) => {
+      let settled = false;
+      const settle = (fn: Function, arg?: any) => {
+        if (!settled) { settled = true; fn(arg); }
+      };
+
       try {
         this.ws = new WebSocket(this.config.url);
 
+        // Auth timeout — if no auth_ok within 10s, fail
+        const authTimer = setTimeout(() => {
+          settle(reject, new Error('Auth timeout'));
+          if (this.ws) { try { this.ws.close(); } catch {} }
+        }, 10_000);
+
         this.ws.on('open', () => {
           this.logger.info('Connected to Message Relay Hub');
-          this.reconnectDelay = 1000;
-
           this.ws!.send(JSON.stringify({
             type: 'auth',
             agentId: this.agentId,
@@ -42,38 +60,30 @@ export class MessageRelayClient {
 
         this.ws.on('message', (data) => {
           let msg: any;
-          try {
-            msg = JSON.parse(data.toString());
-          } catch {
-            return;
-          }
+          try { msg = JSON.parse(data.toString()); } catch { return; }
 
           if (msg.type === 'auth_ok') {
+            clearTimeout(authTimer);
+            this.authenticated = true;
+            this.reconnectDelay = 1000; // Reset on success
             this.logger.info('Authenticated with Message Relay Hub');
-            resolve();
+            settle(resolve);
             return;
           }
 
           if (msg.type === 'auth_error') {
+            clearTimeout(authTimer);
             this.logger.error(`Auth failed: ${msg.reason}`);
-            reject(new Error(msg.reason));
+            settle(reject, new Error(msg.reason));
             return;
           }
 
-          // Check for pending request callbacks
-          if (msg.replyTo && this.pendingCallbacks.has(msg.replyTo)) {
-            const cb = this.pendingCallbacks.get(msg.replyTo)!;
+          // Check for pending request callbacks (replyTo or sessionId)
+          const callbackKey = msg.replyTo || msg.sessionId;
+          if (callbackKey && this.pendingCallbacks.has(callbackKey)) {
+            const cb = this.pendingCallbacks.get(callbackKey)!;
             clearTimeout(cb.timer);
-            this.pendingCallbacks.delete(msg.replyTo);
-            cb.resolve(msg);
-            return;
-          }
-
-          // Also check sessionId for handoff ack
-          if (msg.sessionId && this.pendingCallbacks.has(msg.sessionId)) {
-            const cb = this.pendingCallbacks.get(msg.sessionId)!;
-            clearTimeout(cb.timer);
-            this.pendingCallbacks.delete(msg.sessionId);
+            this.pendingCallbacks.delete(callbackKey);
             cb.resolve(msg);
             return;
           }
@@ -81,12 +91,17 @@ export class MessageRelayClient {
           // Dispatch to type-based handlers
           const handlers = this.handlers.get(msg.type) || [];
           for (const handler of handlers) {
-            handler(msg);
+            try { handler(msg); } catch (e: any) {
+              this.logger.error(`Handler error for ${msg.type}: ${e.message}`);
+            }
           }
         });
 
-        this.ws.on('close', () => {
-          this.logger.info('Disconnected from Message Relay Hub');
+        this.ws.on('close', (code) => {
+          clearTimeout(authTimer);
+          this.authenticated = false;
+          this.logger.info(`Disconnected from Hub (code: ${code})`);
+          settle(reject, new Error('Connection closed'));
           if (this.shouldReconnect) {
             this.scheduleReconnect();
           }
@@ -94,19 +109,27 @@ export class MessageRelayClient {
 
         this.ws.on('error', (err) => {
           this.logger.error(`WebSocket error: ${err.message}`);
+          // Don't settle here — let 'close' event handle it
         });
       } catch (err: any) {
-        reject(err);
+        settle(reject, err);
       }
     });
   }
 
   private scheduleReconnect(): void {
+    // Prevent multiple reconnect timers
+    if (this.reconnectTimer) return;
     this.logger.info(`Reconnecting in ${this.reconnectDelay}ms...`);
-    setTimeout(() => {
-      this.connect().catch(() => {
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      try {
+        await this.connect();
+        this.logger.info('Reconnected to Message Relay Hub');
+      } catch {
         this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
-      });
+        // connect() failure triggers 'close' which calls scheduleReconnect again
+      }
     }, this.reconnectDelay);
   }
 
@@ -117,7 +140,7 @@ export class MessageRelayClient {
   }
 
   send(msg: any): void {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN && this.authenticated) {
       this.ws.send(JSON.stringify(msg));
     }
   }
@@ -137,6 +160,10 @@ export class MessageRelayClient {
 
   async disconnect(): Promise<void> {
     this.shouldReconnect = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
     for (const [id, cb] of this.pendingCallbacks.entries()) {
       clearTimeout(cb.timer);
       cb.reject(new Error('Disconnecting'));
@@ -144,12 +171,14 @@ export class MessageRelayClient {
     this.pendingCallbacks.clear();
 
     if (this.ws) {
+      this.ws.removeAllListeners();
       this.ws.close(1000, 'plugin deactivated');
       this.ws = null;
     }
+    this.authenticated = false;
   }
 
   get isConnected(): boolean {
-    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN && this.authenticated;
   }
 }