openclaw-bridge 0.3.2 → 0.4.1

package/dist/manager/hub-client.js

@@ -0,0 +1,89 @@
+import WebSocket from "ws";
+import { hostname } from "node:os";
+export class ManagerHubClient {
+    hubUrl;
+    apiKey;
+    managerPass;
+    machineId;
+    ws = null;
+    _connected = false;
+    reconnectDelay = 1000;
+    logger;
+    onCommand = null;
+    constructor(hubUrl, apiKey, managerPass, logger) {
+        this.hubUrl = hubUrl;
+        this.apiKey = apiKey;
+        this.managerPass = managerPass;
+        this.machineId = hostname();
+        this.logger = logger;
+    }
+    get connected() {
+        return this._connected;
+    }
+    async connect() {
+        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, logs) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify({
+                type: "manager_status",
+                machineId: this.machineId,
+                agents,
+                logs,
+            }));
+        }
+    }
+    sendResult(action, target, success) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify({ type: "manager_result", action, target, success }));
+        }
+    }
+    disconnect() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+            this._connected = false;
+        }
+    }
+}

package/dist/manager/local-manager.d.ts

@@ -0,0 +1,12 @@
+import type { PluginLogger, LocalManagerConfig } from "../types.js";
+export declare class LocalManager {
+    private config;
+    private apiKey;
+    private logger;
+    private hubClient;
+    private statusTimer;
+    private hasLock;
+    constructor(config: LocalManagerConfig, apiKey: string, logger: PluginLogger);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/manager/local-manager.js

@@ -0,0 +1,117 @@
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+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() {
+    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() {
+    try {
+        unlinkSync(LOCK_FILE);
+    }
+    catch { }
+}
+export class LocalManager {
+    config;
+    apiKey;
+    logger;
+    hubClient = null;
+    statusTimer = null;
+    hasLock = false;
+    constructor(config, apiKey, logger) {
+        this.config = config;
+        this.apiKey = apiKey;
+        this.logger = logger;
+    }
+    async start() {
+        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) => {
+            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) {
+                this.logger.error(`[local-manager] Failed: ${err.message}`);
+                this.hubClient.sendResult(msg.action, msg.target, false);
+            }
+        };
+        try {
+            await this.hubClient.connect();
+        }
+        catch (err) {
+            this.logger.warn(`[local-manager] Hub connect failed: ${err.message}. Will retry.`);
+        }
+        this.statusTimer = setInterval(async () => {
+            try {
+                const processes = await listProcesses();
+                const logs = {};
+                for (const proc of processes) {
+                    logs[proc.name] = await getProcessLogs(proc.name);
+                }
+                if (this.hubClient?.connected) {
+                    this.hubClient.sendStatus(processes, logs);
+                }
+            }
+            catch (err) {
+                this.logger.warn(`[local-manager] Status tick failed: ${err.message}`);
+            }
+        }, 30_000);
+        this.logger.info("[local-manager] Started (reporting every 30s)");
+    }
+    async stop() {
+        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/dist/manager/pm2-bridge.d.ts

@@ -0,0 +1,17 @@
+export interface PM2Process {
+    name: string;
+    agentId: string;
+    pid: number;
+    status: string;
+    memory: number;
+    cpu: number;
+    restarts: number;
+    uptime: number;
+}
+export declare function listProcesses(): Promise<PM2Process[]>;
+export declare function getProcessLogs(name: string): Promise<string>;
+export declare function restartProcess(name: string): Promise<void>;
+export declare function stopProcess(name: string): Promise<void>;
+export declare function startProcess(name: string): Promise<void>;
+export declare function stopAll(): Promise<void>;
+export declare function startAll(ecosystemPath: string): Promise<void>;

package/dist/manager/pm2-bridge.js

@@ -0,0 +1,113 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { platform } from "node:os";
+const _exec = promisify(exec);
+const execAsync = async (cmd, opts) => {
+    const result = await _exec(cmd, { windowsHide: true, encoding: "utf-8", ...opts });
+    return { stdout: result.stdout, stderr: result.stderr };
+};
+const IS_WIN = platform() === "win32";
+async function killPort(port) {
+    if (!port)
+        return;
+    try {
+        if (IS_WIN) {
+            const { stdout } = await execAsync(`netstat -ano | findstr :${port} | findstr LISTENING`);
+            const pids = new Set();
+            stdout.split("\n").forEach((line) => {
+                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) {
+    try {
+        const { stdout } = await execAsync("pm2 jlist");
+        const apps = JSON.parse(stdout);
+        const app = apps.find((a) => 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() {
+    try {
+        const { stdout } = await execAsync("pm2 jlist");
+        const apps = JSON.parse(stdout);
+        return apps.map((p) => ({
+            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) {
+        return [];
+    }
+}
+export async function getProcessLogs(name) {
+    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) {
+    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) {
+    await execAsync("pm2 stop " + name);
+    const port = await getProcessPort(name);
+    if (port)
+        await killPort(port);
+}
+export async function startProcess(name) {
+    const port = await getProcessPort(name);
+    if (port)
+        await killPort(port);
+    await execAsync("pm2 restart " + name);
+}
+export async function stopAll() {
+    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) {
+    await execAsync("pm2 start " + ecosystemPath);
+}

package/dist/message-relay.d.ts

@@ -0,0 +1,32 @@
+import type { PluginLogger, MessageRelayConfig } from './types.js';
+type MessageHandler = (msg: any) => void;
+export declare class MessageRelayClient {
+    private ws;
+    private agentId;
+    private config;
+    private logger;
+    private handlers;
+    private reconnectDelay;
+    private maxReconnectDelay;
+    private shouldReconnect;
+    private authenticated;
+    private reconnectTimer;
+    private pendingCallbacks;
+    private machineId;
+    private originalAgentId;
+    private originalAgentName;
+    private conflictRetries;
+    private maxConflictRetries;
+    private onConflictRename;
+    constructor(agentId: string, config: MessageRelayConfig, logger: PluginLogger, machineId: string);
+    setAgentName(name: string): void;
+    setOnConflictRename(cb: (newAgentId: string, newAgentName: string) => void): void;
+    connect(): Promise<void>;
+    private scheduleReconnect;
+    on(type: string, handler: MessageHandler): void;
+    send(msg: any): void;
+    sendAndWait(msg: any, timeoutMs?: number): Promise<any>;
+    disconnect(): Promise<void>;
+    get isConnected(): boolean;
+}
+export {};

package/dist/message-relay.js

@@ -0,0 +1,229 @@
+import WebSocket from 'ws';
+export class MessageRelayClient {
+    ws = null;
+    agentId;
+    config;
+    logger;
+    handlers = new Map();
+    reconnectDelay = 1000;
+    maxReconnectDelay = 30000;
+    shouldReconnect = true;
+    authenticated = false;
+    reconnectTimer = null;
+    pendingCallbacks = new Map();
+    machineId;
+    originalAgentId;
+    originalAgentName = '';
+    conflictRetries = 0;
+    maxConflictRetries = 5;
+    onConflictRename = null;
+    constructor(agentId, config, logger, machineId) {
+        this.agentId = agentId;
+        this.originalAgentId = agentId;
+        this.config = config;
+        this.logger = logger;
+        this.machineId = machineId;
+    }
+    setAgentName(name) {
+        if (!this.originalAgentName)
+            this.originalAgentName = name;
+    }
+    setOnConflictRename(cb) {
+        this.onConflictRename = cb;
+    }
+    async connect() {
+        // 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, arg) => {
+                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,
+                        machineId: this.machineId,
+                    }));
+                });
+                this.ws.on('message', (data) => {
+                    let msg;
+                    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;
+                    }
+                    if (msg.type === 'auth_conflict') {
+                        clearTimeout(authTimer);
+                        this.conflictRetries++;
+                        if (this.conflictRetries > this.maxConflictRetries) {
+                            this.logger.error(`agentId conflict: max retries (${this.maxConflictRetries}) exhausted, giving up`);
+                            this.shouldReconnect = false;
+                            settle(reject, new Error('agentId conflict: max retries exhausted'));
+                            return;
+                        }
+                        let newAgentId;
+                        if (this.conflictRetries === 1) {
+                            newAgentId = msg.suggestedId;
+                        }
+                        else {
+                            const base = `${this.originalAgentId}@${this.machineId}`;
+                            newAgentId = `${base}-${this.conflictRetries - 1}`;
+                        }
+                        const newAgentName = this.originalAgentName
+                            ? `${this.originalAgentName} (${this.machineId})`
+                            : newAgentId;
+                        this.logger.info(`agentId "${this.agentId}" conflicts with machine "${msg.existingMachine}", renaming to "${newAgentId}"`);
+                        this.agentId = newAgentId;
+                        if (this.onConflictRename) {
+                            this.onConflictRename(newAgentId, newAgentName);
+                        }
+                        settle(reject, new Error('auth_conflict - reconnecting with new name'));
+                        if (this.ws) {
+                            try {
+                                this.ws.close();
+                            }
+                            catch { }
+                        }
+                        this.reconnectDelay = 100;
+                        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) {
+                            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) {
+                settle(reject, err);
+            }
+        });
+    }
+    scheduleReconnect() {
+        // 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, handler) {
+        const existing = this.handlers.get(type) || [];
+        existing.push(handler);
+        this.handlers.set(type, existing);
+    }
+    send(msg) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN && this.authenticated) {
+            this.ws.send(JSON.stringify(msg));
+        }
+    }
+    async sendAndWait(msg, timeoutMs = 60_000) {
+        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() {
+        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() {
+        return this.ws !== null && this.ws.readyState === WebSocket.OPEN && this.authenticated;
+    }
+}

package/dist/permissions.d.ts

@@ -0,0 +1,3 @@
+import type { BridgeConfig } from "./types.js";
+export declare function checkPermission(action: string, config: BridgeConfig): boolean;
+export declare function assertPermission(action: string, config: BridgeConfig): void;

package/dist/permissions.js

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

package/dist/registry.d.ts

@@ -0,0 +1,13 @@
+import type { BridgeConfig, RegistryEntry, PluginLogger } from "./types.js";
+export declare class BridgeRegistry {
+    private baseUrl;
+    private apiKey;
+    private logger;
+    constructor(config: BridgeConfig, logger: PluginLogger);
+    private headers;
+    register(entry: RegistryEntry): Promise<void>;
+    update(entry: RegistryEntry): Promise<void>;
+    deregister(agentId: string): Promise<void>;
+    discover(offlineThresholdMs: number): Promise<RegistryEntry[]>;
+    findAgent(agentId: string, offlineThresholdMs: number): Promise<RegistryEntry | null>;
+}