openclaw-bridge 0.3.2 → 0.4.0

package/src/manager/hub-client.ts

@@ -1,114 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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

@@ -1,184 +0,0 @@
-import WebSocket from 'ws';
-import type { PluginLogger, MessageRelayConfig } from './types.js';
-
-type MessageHandler = (msg: any) => void;
-
-export class MessageRelayClient {
-  private ws: WebSocket | null = null;
-  private agentId: string;
-  private config: MessageRelayConfig;
-  private logger: PluginLogger;
-  private handlers = new Map<string, MessageHandler[]>();
-  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;
-    timer: ReturnType<typeof setTimeout>;
-  }>();
-
-  constructor(agentId: string, config: MessageRelayConfig, logger: PluginLogger) {
-    this.agentId = agentId;
-    this.config = config;
-    this.logger = logger;
-  }
-
-  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.ws!.send(JSON.stringify({
-            type: 'auth',
-            agentId: this.agentId,
-            apiKey: this.config.apiKey,
-          }));
-        });
-
-        this.ws.on('message', (data) => {
-          let msg: any;
-          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');
-            settle(resolve);
-            return;
-          }
-
-          if (msg.type === 'auth_error') {
-            clearTimeout(authTimer);
-            this.logger.error(`Auth failed: ${msg.reason}`);
-            settle(reject, new Error(msg.reason));
-            return;
-          }
-
-          // 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(callbackKey);
-            cb.resolve(msg);
-            return;
-          }
-
-          // Dispatch to type-based handlers
-          const handlers = this.handlers.get(msg.type) || [];
-          for (const handler of handlers) {
-            try { handler(msg); } catch (e: any) {
-              this.logger.error(`Handler error for ${msg.type}: ${e.message}`);
-            }
-          }
-        });
-
-        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();
-          }
-        });
-
-        this.ws.on('error', (err) => {
-          this.logger.error(`WebSocket error: ${err.message}`);
-          // Don't settle here — let 'close' event handle it
-        });
-      } catch (err: any) {
-        settle(reject, err);
-      }
-    });
-  }
-
-  private scheduleReconnect(): void {
-    // Prevent multiple reconnect timers
-    if (this.reconnectTimer) return;
-    this.logger.info(`Reconnecting in ${this.reconnectDelay}ms...`);
-    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);
-  }
-
-  on(type: string, handler: MessageHandler): void {
-    const existing = this.handlers.get(type) || [];
-    existing.push(handler);
-    this.handlers.set(type, existing);
-  }
-
-  send(msg: any): void {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN && this.authenticated) {
-      this.ws.send(JSON.stringify(msg));
-    }
-  }
-
-  async sendAndWait(msg: any, timeoutMs = 60_000): Promise<any> {
-    return new Promise((resolve, reject) => {
-      const id = msg.id || msg.sessionId;
-      const timer = setTimeout(() => {
-        this.pendingCallbacks.delete(id);
-        reject(new Error(`Timeout waiting for reply to ${id}`));
-      }, timeoutMs);
-
-      this.pendingCallbacks.set(id, { resolve, reject, timer });
-      this.send(msg);
-    });
-  }
-
-  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'));
-    }
-    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 && this.authenticated;
-  }
-}

package/src/permissions.ts

@@ -1,18 +0,0 @@
-import type { BridgeConfig } from "./types.js";
-
-const PUBLIC_ACTIONS = new Set(["discover", "whois", "send_file"]);
-const SUPERUSER_ACTIONS = new Set(["read_file", "write_file", "restart"]);
-
-export function checkPermission(action: string, config: BridgeConfig): boolean {
-  if (PUBLIC_ACTIONS.has(action)) return true;
-  if (SUPERUSER_ACTIONS.has(action)) return config.role === "superuser";
-  return false;
-}
-
-export function assertPermission(action: string, config: BridgeConfig): void {
-  if (!checkPermission(action, config)) {
-    throw new Error(
-      `openclaw-bridge: permission denied — "${action}" requires superuser role, current role is "${config.role}"`,
-    );
-  }
-}

package/src/registry.ts

@@ -1,107 +0,0 @@
-import type { BridgeConfig, RegistryEntry, PluginLogger } from "./types.js";
-
-export class BridgeRegistry {
-  private baseUrl: string;
-  private apiKey: string | undefined;
-  private logger: PluginLogger;
-
-  constructor(config: BridgeConfig, logger: PluginLogger) {
-    // Use fileRelay URL for registry (not OpenViking)
-    if (!config.fileRelay?.baseUrl) {
-      throw new Error("openclaw-bridge: fileRelay.baseUrl is required for registry");
-    }
-    this.baseUrl = config.fileRelay.baseUrl.replace(/\/+$/, "");
-    this.apiKey = config.fileRelay.apiKey;
-    this.logger = logger;
-  }
-
-  private headers(): Record<string, string> {
-    const h: Record<string, string> = { "Content-Type": "application/json" };
-    if (this.apiKey) h["X-API-Key"] = this.apiKey;
-    return h;
-  }
-
-  async register(entry: RegistryEntry): Promise<void> {
-    try {
-      const res = await fetch(`${this.baseUrl}/api/v1/registry/register`, {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(entry),
-      });
-      if (!res.ok) {
-        throw new Error(`HTTP ${res.status}`);
-      }
-      this.logger.info(`openclaw-bridge: registered ${entry.agentId} to registry`);
-    } catch (err) {
-      this.logger.error(`openclaw-bridge: registration failed: ${String(err)}`);
-      throw err;
-    }
-  }
-
-  async update(entry: RegistryEntry): Promise<void> {
-    try {
-      const res = await fetch(`${this.baseUrl}/api/v1/registry/heartbeat`, {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(entry),
-      });
-      if (!res.ok) {
-        // Re-register if heartbeat fails
-        await this.register(entry);
-      }
-    } catch (err) {
-      this.logger.warn(`openclaw-bridge: heartbeat failed, re-registering: ${String(err)}`);
-      await this.register(entry);
-    }
-  }
-
-  async deregister(agentId: string): Promise<void> {
-    try {
-      await fetch(`${this.baseUrl}/api/v1/registry/${agentId}`, {
-        method: "DELETE",
-        headers: this.headers(),
-      });
-      this.logger.info(`openclaw-bridge: deregistered ${agentId}`);
-    } catch (err) {
-      this.logger.warn(`openclaw-bridge: deregistration failed: ${String(err)}`);
-    }
-  }
-
-  async discover(offlineThresholdMs: number): Promise<RegistryEntry[]> {
-    try {
-      const res = await fetch(`${this.baseUrl}/api/v1/registry/discover`, {
-        headers: this.headers(),
-      });
-      if (!res.ok) return [];
-
-      const data = (await res.json()) as { agents?: RegistryEntry[] };
-      const now = Date.now();
-
-      return (data.agents ?? []).map((entry) => {
-        const lastBeat = new Date(entry.lastHeartbeat).getTime();
-        entry.status = (now - lastBeat > offlineThresholdMs) ? "offline" : "online";
-        return entry;
-      });
-    } catch (err) {
-      this.logger.error(`openclaw-bridge: discover failed: ${String(err)}`);
-      return [];
-    }
-  }
-
-  async findAgent(agentId: string, offlineThresholdMs: number): Promise<RegistryEntry | null> {
-    try {
-      const res = await fetch(`${this.baseUrl}/api/v1/registry/whois/${agentId}`, {
-        headers: this.headers(),
-      });
-      if (!res.ok) return null;
-
-      const entry = (await res.json()) as RegistryEntry;
-      const now = Date.now();
-      const lastBeat = new Date(entry.lastHeartbeat).getTime();
-      entry.status = (now - lastBeat > offlineThresholdMs) ? "offline" : "online";
-      return entry;
-    } catch {
-      return null;
-    }
-  }
-}