openclaw-bridge 0.3.2 → 0.4.1

package/dist/registry.js

@@ -0,0 +1,103 @@
+export class BridgeRegistry {
+    baseUrl;
+    apiKey;
+    logger;
+    constructor(config, logger) {
+        // 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;
+    }
+    headers() {
+        const h = { "Content-Type": "application/json" };
+        if (this.apiKey)
+            h["X-API-Key"] = this.apiKey;
+        return h;
+    }
+    async register(entry) {
+        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) {
+        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) {
+        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) {
+        try {
+            const res = await fetch(`${this.baseUrl}/api/v1/registry/discover`, {
+                headers: this.headers(),
+            });
+            if (!res.ok)
+                return [];
+            const data = (await res.json());
+            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, offlineThresholdMs) {
+        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());
+            const now = Date.now();
+            const lastBeat = new Date(entry.lastHeartbeat).getTime();
+            entry.status = (now - lastBeat > offlineThresholdMs) ? "offline" : "online";
+            return entry;
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/restart.d.ts

@@ -0,0 +1,15 @@
+import type { BridgeConfig, RegistryEntry, PluginLogger } from "./types.js";
+import type { BridgeRegistry } from "./registry.js";
+export declare class BridgeRestart {
+    private config;
+    private machineId;
+    private registry;
+    private logger;
+    constructor(config: BridgeConfig, machineId: string, registry: BridgeRegistry, logger: PluginLogger);
+    restart(target: RegistryEntry): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    private restartLocal;
+    private restartRemote;
+}

package/dist/restart.js

@@ -0,0 +1,107 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+const execAsync = promisify(exec);
+const IS_WIN = process.platform === "win32";
+export class BridgeRestart {
+    config;
+    machineId;
+    registry;
+    logger;
+    constructor(config, machineId, registry, logger) {
+        this.config = config;
+        this.machineId = machineId;
+        this.registry = registry;
+        this.logger = logger;
+    }
+    async restart(target) {
+        if (target.machineId !== this.machineId) {
+            return this.restartRemote(target);
+        }
+        return this.restartLocal(target);
+    }
+    async restartLocal(target) {
+        this.logger.info(`openclaw-bridge: restarting ${target.agentId} on local machine`);
+        try {
+            if (IS_WIN) {
+                const { stdout } = await execAsync(`netstat -ano | findstr :${target.port} | findstr LISTENING`);
+                const lines = stdout.trim().split("\n");
+                for (const line of lines) {
+                    const pid = line.trim().split(/\s+/).pop();
+                    if (pid && /^\d+$/.test(pid)) {
+                        await execAsync(`taskkill /F /PID ${pid}`).catch(() => { });
+                    }
+                }
+            }
+            else {
+                await execAsync(`lsof -ti:${target.port} | xargs kill -9`).catch(() => { });
+            }
+            const instanceDir = target.workspacePath.replace(/[\\/]workspace[\\/]?$/, "");
+            const runScript = IS_WIN
+                ? `${instanceDir}\\run.ps1`
+                : `${instanceDir}/run.sh`;
+            if (IS_WIN) {
+                await execAsync(`powershell -Command "Start-Process powershell -ArgumentList '-File','${runScript}' -WindowStyle Hidden"`);
+            }
+            else {
+                await execAsync(`nohup bash "${runScript}" > /dev/null 2>&1 &`);
+            }
+            const deadline = Date.now() + 60_000;
+            while (Date.now() < deadline) {
+                await new Promise((r) => setTimeout(r, 3_000));
+                const found = await this.registry.findAgent(target.agentId, this.config.offlineThresholdMs ?? 120_000);
+                if (found && found.status === "online") {
+                    this.logger.info(`openclaw-bridge: ${target.agentId} restarted successfully`);
+                    return { success: true, message: `${target.agentId} restarted and back online` };
+                }
+            }
+            return {
+                success: false,
+                message: `${target.agentId} process started but did not re-register within 60s`,
+            };
+        }
+        catch (err) {
+            return { success: false, message: `Restart failed: ${String(err)}` };
+        }
+    }
+    async restartRemote(target) {
+        if (!this.config.fileRelay?.baseUrl) {
+            return {
+                success: false,
+                message: "Cannot restart remote gateway: fileRelay not configured",
+            };
+        }
+        const baseUrl = this.config.fileRelay.baseUrl.replace(/\/+$/, "");
+        const headers = { "Content-Type": "application/json" };
+        if (this.config.fileRelay.apiKey)
+            headers["X-API-Key"] = this.config.fileRelay.apiKey;
+        const res = await fetch(`${baseUrl}/api/v1/commands/enqueue`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                fromAgent: this.config.agentId,
+                toAgent: target.agentId,
+                type: "restart",
+                payload: {},
+            }),
+        });
+        if (!res.ok) {
+            return { success: false, message: `FileRelay command enqueue failed: ${res.status}` };
+        }
+        const { id: cmdId } = (await res.json());
+        const deadline = Date.now() + 90_000;
+        while (Date.now() < deadline) {
+            await new Promise((r) => setTimeout(r, 5_000));
+            const resultRes = await fetch(`${baseUrl}/api/v1/commands/result/${cmdId}`, { headers });
+            if (!resultRes.ok)
+                continue;
+            const result = (await resultRes.json());
+            if (result.status === "ok") {
+                return { success: true, message: `Restart command acknowledged by ${target.agentId}` };
+            }
+            if (result.status === "error") {
+                return { success: false, message: `Remote restart failed` };
+            }
+        }
+        return { success: false, message: "Restart command timed out (90s)" };
+    }
+}

package/dist/router.d.ts

@@ -0,0 +1,11 @@
+import type { RegistryEntry, ChannelInfo } from './types.js';
+export interface MessageContext {
+    channel: ChannelInfo;
+    isGroupChannel: boolean;
+}
+export interface RouteDecision {
+    method: 'channel_direct' | 'hub_relay';
+    channel?: ChannelInfo;
+    fallback: 'hub_relay';
+}
+export declare function decideRoute(currentContext: MessageContext, targetAgentId: string, registry: RegistryEntry[]): RouteDecision;

package/dist/router.js

@@ -0,0 +1,18 @@
+export function decideRoute(currentContext, targetAgentId, registry) {
+    const target = registry.find(a => a.agentId === targetAgentId);
+    if (!target || target.status !== 'online') {
+        return { method: 'hub_relay', fallback: 'hub_relay' };
+    }
+    if (currentContext.isGroupChannel && target.channels) {
+        const targetInSameChannel = target.channels.some(ch => ch.type === currentContext.channel.type
+            && ch.channelId === currentContext.channel.channelId);
+        if (targetInSameChannel) {
+            return {
+                method: 'channel_direct',
+                channel: currentContext.channel,
+                fallback: 'hub_relay',
+            };
+        }
+    }
+    return { method: 'hub_relay', fallback: 'hub_relay' };
+}

package/dist/session.d.ts

@@ -0,0 +1,11 @@
+export interface ProxySession {
+    sessionId: string;
+    originAgent: string;
+    currentAgent: string;
+    currentAgentName: string;
+}
+export declare function setSession(session: ProxySession): void;
+export declare function getSession(): ProxySession | null;
+export declare function clearSession(): void;
+export declare function updateCurrentAgent(agentId: string, agentName: string): void;
+export declare function isInHandoff(): boolean;

package/dist/session.js

@@ -0,0 +1,21 @@
+let activeSession = null;
+export function setSession(session) {
+    activeSession = session;
+    console.log(`[session] SET handoff: sessionId=${session.sessionId} target=${session.currentAgent}`);
+}
+export function getSession() {
+    return activeSession;
+}
+export function clearSession() {
+    console.log(`[session] CLEAR handoff (was: ${activeSession?.sessionId || 'none'})`);
+    activeSession = null;
+}
+export function updateCurrentAgent(agentId, agentName) {
+    if (activeSession) {
+        activeSession.currentAgent = agentId;
+        activeSession.currentAgentName = agentName;
+    }
+}
+export function isInHandoff() {
+    return activeSession !== null;
+}

package/dist/types.d.ts

@@ -0,0 +1,90 @@
+export interface MessageRelayConfig {
+    url: string;
+    apiKey: string;
+}
+export interface LocalManagerConfig {
+    enabled: boolean;
+    hubUrl: string;
+    managerPass: string;
+}
+export interface BridgeConfig {
+    role: "normal" | "superuser";
+    agentId: string;
+    agentName: string;
+    registry: {
+        provider?: string;
+        baseUrl: string;
+        apiKey?: string;
+    };
+    fileRelay?: {
+        baseUrl: string;
+        apiKey?: string;
+    };
+    messageRelay?: MessageRelayConfig;
+    heartbeatIntervalMs?: number;
+    offlineThresholdMs?: number;
+    description?: string;
+    supportsVision?: boolean;
+    localManager?: LocalManagerConfig;
+}
+export interface ChannelInfo {
+    type: string;
+    channelId: string;
+    name: string;
+}
+export interface RegistryEntry {
+    type: "gateway-registry";
+    agentId: string;
+    agentName: string;
+    machineId: string;
+    host: string;
+    port: number;
+    workspacePath: string;
+    discordId: string | null;
+    discordConnected?: boolean;
+    role: "normal" | "superuser";
+    capabilities: string[];
+    channels: ChannelInfo[];
+    registeredAt: string;
+    lastHeartbeat: string;
+    status: "online" | "offline";
+    memMB?: number;
+    description?: string;
+    supportsVision?: boolean;
+}
+export interface DiscoverResult {
+    agents: RegistryEntry[];
+}
+export type PluginLogger = {
+    debug?: (message: string) => void;
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+};
+export type HookAgentContext = {
+    agentId?: string;
+    sessionId?: string;
+    sessionKey?: string;
+};
+export type OpenClawPluginApi = {
+    pluginConfig?: unknown;
+    logger: PluginLogger;
+    registerTool: (tool: {
+        name: string;
+        label: string;
+        description: string;
+        parameters: unknown;
+        execute: (_toolCallId: string, params: Record<string, unknown>) => Promise<unknown>;
+    }, opts?: {
+        name?: string;
+        names?: string[];
+    }) => void;
+    registerService: (service: {
+        id: string;
+        start: (ctx?: unknown) => void | Promise<void>;
+        stop?: (ctx?: unknown) => void | Promise<void>;
+    }) => void;
+    on: (hookName: string, handler: (event: unknown, ctx?: HookAgentContext) => unknown, opts?: {
+        priority?: number;
+    }) => void;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/openclaw.plugin.json

@@ -1,101 +1,15 @@
 {
   "id": "openclaw-bridge",
-  "kind": "extension",
-  "uiHints": {
-    "role": {
-      "label": "Role",
-      "help": "normal = isolated workspace access only; superuser = cross-gateway access"
-    },
-    "agentId": {
-      "label": "Agent ID",
-      "help": "Unique identifier for this agent (e.g., pm, bot1, main)"
-    },
-    "agentName": {
-      "label": "Agent Display Name",
-      "help": "Human-readable name (e.g., PM Bot, Director Ma)"
-    },
-    "registry.baseUrl": {
-      "label": "OpenViking URL",
-      "placeholder": "http://your-server:1933",
-      "help": "OpenViking server for gateway registry"
-    },
-    "registry.apiKey": {
-      "label": "OpenViking API Key",
-      "sensitive": true
-    },
-    "fileRelay.baseUrl": {
-      "label": "FileRelay URL",
-      "placeholder": "http://your-server:3080",
-      "help": "FileRelay server for cross-machine file transfer"
-    },
-    "fileRelay.apiKey": {
-      "label": "FileRelay API Key",
-      "sensitive": true
-    },
-    "description": {
-      "label": "Agent Description",
-      "help": "Short description of what this agent does (shown on Hub dashboard)"
-    },
-    "supportsVision": {
-      "label": "Supports Vision",
-      "help": "Whether the agent's model can process images (auto-detected if not set)"
-    },
-    "localManager.enabled": {
-      "label": "Enable Local Manager",
-      "help": "Start PM2 process manager for this machine"
-    },
-    "localManager.hubUrl": {
-      "label": "Hub URL for Local Manager",
-      "placeholder": "http://your-server:3080"
-    },
-    "localManager.managerPass": {
-      "label": "Manager Password",
-      "sensitive": true
-    }
-  },
+  "name": "OpenClaw Bridge",
+  "description": "Cross-gateway communication, file transfer, message relay, session handoff, and local process management",
   "configSchema": {
     "type": "object",
-    "additionalProperties": false,
-    "required": ["role", "agentId", "agentName", "registry"],
+    "required": ["role", "agentId", "agentName"],
     "properties": {
       "role": { "type": "string", "enum": ["normal", "superuser"] },
       "agentId": { "type": "string" },
-      "agentName": { "type": "string" },
-      "registry": {
-        "type": "object",
-        "required": ["baseUrl"],
-        "properties": {
-          "provider": { "type": "string" },
-          "baseUrl": { "type": "string" },
-          "apiKey": { "type": "string" }
-        }
-      },
-      "fileRelay": {
-        "type": "object",
-        "properties": {
-          "baseUrl": { "type": "string" },
-          "apiKey": { "type": "string" }
-        }
-      },
-      "messageRelay": {
-        "type": "object",
-        "properties": {
-          "url": { "type": "string" },
-          "apiKey": { "type": "string" }
-        }
-      },
-      "heartbeatIntervalMs": { "type": "number" },
-      "offlineThresholdMs": { "type": "number" },
-      "description": { "type": "string" },
-      "supportsVision": { "type": "boolean" },
-      "localManager": {
-        "type": "object",
-        "properties": {
-          "enabled": { "type": "boolean" },
-          "hubUrl": { "type": "string" },
-          "managerPass": { "type": "string" }
-        }
-      }
-    }
+      "agentName": { "type": "string" }
+    },
+    "additionalProperties": true
   }
 }

package/package.json

@@ -1,18 +1,27 @@
 {
   "name": "openclaw-bridge",
-  "version": "0.3.2",
+  "version": "0.4.1",
   "author": "Bill Zhao (https://www.linkedin.com/in/billzhaodi/)",
-  "description": "Cross-gateway communication plugin for OpenClaw — agent discovery, file transfer, real-time messaging, and session handoff",
+  "description": "OpenClaw plugin for cross-gateway communication — agent discovery, file transfer, real-time messaging, session handoff, and local process management. Install as plugin: openclaw plugins install openclaw-bridge",
   "type": "module",
-  "main": "src/index.ts",
+  "main": "dist/index.js",
   "bin": {
-    "openclaw-bridge": "src/cli.ts"
+    "openclaw-bridge": "dist/cli.js"
   },
   "openclaw": {
     "extensions": [
-      "./src/index.ts"
+      "./dist/index.js"
     ]
   },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "openclaw.plugin.json",
+    "README.md"
+  ],
   "dependencies": {
     "@sinclair/typebox": "^0.34.0",
     "ws": "^8.20.0"
@@ -23,6 +32,7 @@
   },
   "keywords": [
     "openclaw",
+    "openclaw-plugin",
     "bridge",
     "multi-agent",
     "gateway",