openclaw-bridge 0.3.2 → 0.4.1

package/dist/config.d.ts

@@ -0,0 +1,3 @@
+import type { BridgeConfig } from "./types.js";
+export declare function parseConfig(raw: unknown): BridgeConfig;
+export declare function getMachineId(): string;

package/dist/config.js

@@ -0,0 +1,64 @@
+import { hostname } from "node:os";
+const DEFAULTS = {
+    heartbeatIntervalMs: 30_000,
+    offlineThresholdMs: 120_000,
+};
+export function parseConfig(raw) {
+    if (!raw || typeof raw !== "object") {
+        throw new Error("openclaw-bridge: missing plugin config");
+    }
+    const obj = raw;
+    if (!obj.role || (obj.role !== "normal" && obj.role !== "superuser")) {
+        throw new Error('openclaw-bridge: config.role must be "normal" or "superuser"');
+    }
+    if (!obj.agentId || typeof obj.agentId !== "string") {
+        throw new Error("openclaw-bridge: config.agentId is required");
+    }
+    if (!obj.agentName || typeof obj.agentName !== "string") {
+        throw new Error("openclaw-bridge: config.agentName is required");
+    }
+    const registry = obj.registry;
+    if (!registry || !registry.baseUrl || typeof registry.baseUrl !== "string") {
+        throw new Error("openclaw-bridge: config.registry.baseUrl is required");
+    }
+    return {
+        role: obj.role,
+        agentId: obj.agentId,
+        agentName: obj.agentName,
+        registry: {
+            provider: registry.provider ?? "openviking",
+            baseUrl: registry.baseUrl,
+            apiKey: registry.apiKey,
+        },
+        fileRelay: obj.fileRelay
+            ? {
+                baseUrl: obj.fileRelay.baseUrl,
+                apiKey: obj.fileRelay.apiKey,
+            }
+            : undefined,
+        messageRelay: obj.messageRelay
+            ? {
+                url: obj.messageRelay.url,
+                apiKey: obj.messageRelay.apiKey,
+            }
+            : undefined,
+        heartbeatIntervalMs: typeof obj.heartbeatIntervalMs === "number"
+            ? obj.heartbeatIntervalMs
+            : DEFAULTS.heartbeatIntervalMs,
+        offlineThresholdMs: 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.enabled,
+                hubUrl: obj.localManager.hubUrl,
+                managerPass: obj.localManager.managerPass,
+            }
+            : undefined,
+    };
+}
+export function getMachineId() {
+    return hostname();
+}

package/dist/discovery.d.ts

@@ -0,0 +1,4 @@
+import type { RegistryEntry } from "./types.js";
+import type { BridgeRegistry } from "./registry.js";
+export declare function discoverAll(registry: BridgeRegistry, offlineThresholdMs: number): Promise<RegistryEntry[]>;
+export declare function whois(registry: BridgeRegistry, agentId: string, offlineThresholdMs: number): Promise<RegistryEntry | null>;

package/dist/discovery.js

@@ -0,0 +1,6 @@
+export async function discoverAll(registry, offlineThresholdMs) {
+    return registry.discover(offlineThresholdMs);
+}
+export async function whois(registry, agentId, offlineThresholdMs) {
+    return registry.findAgent(agentId, offlineThresholdMs);
+}

package/dist/file-ops.d.ts

@@ -0,0 +1,22 @@
+import type { BridgeConfig, RegistryEntry, PluginLogger } from "./types.js";
+export declare class BridgeFileOps {
+    private config;
+    private machineId;
+    private workspacePath;
+    private logger;
+    constructor(config: BridgeConfig, machineId: string, workspacePath: string, logger: PluginLogger);
+    private isSameMachine;
+    private validatePathWithinWorkspace;
+    private fileRelayHeaders;
+    private fileRelayUrl;
+    sendFile(target: RegistryEntry, localRelativePath: string): Promise<{
+        delivered: boolean;
+        message: string;
+        filename?: string;
+        renamed?: boolean;
+    }>;
+    readRemoteFile(target: RegistryEntry, relativePath: string): Promise<string>;
+    writeRemoteFile(target: RegistryEntry, relativePath: string, content: string): Promise<void>;
+    processPendingFiles(): Promise<number>;
+    processPendingCommands(): Promise<number>;
+}

package/dist/file-ops.js

@@ -0,0 +1,253 @@
+import { readFile, writeFile, copyFile, mkdir, access } from "node:fs/promises";
+import { join, resolve, dirname, basename, extname } from "node:path";
+/** If dest exists, append _1, _2, etc. before the extension */
+async function deduplicatePath(destPath) {
+    let candidate = destPath;
+    let counter = 0;
+    const ext = extname(destPath);
+    const base = destPath.slice(0, destPath.length - ext.length);
+    while (true) {
+        try {
+            await access(candidate);
+            counter++;
+            candidate = `${base}_${counter}${ext}`;
+        }
+        catch {
+            return candidate; // File doesn't exist, use this path
+        }
+    }
+}
+export class BridgeFileOps {
+    config;
+    machineId;
+    workspacePath;
+    logger;
+    constructor(config, machineId, workspacePath, logger) {
+        this.config = config;
+        this.machineId = machineId;
+        this.workspacePath = workspacePath;
+        this.logger = logger;
+    }
+    isSameMachine(target) {
+        return target.machineId === this.machineId;
+    }
+    validatePathWithinWorkspace(filePath, workspace) {
+        const resolved = resolve(workspace, filePath);
+        if (!resolved.startsWith(resolve(workspace))) {
+            throw new Error(`openclaw-bridge: path escapes workspace: ${filePath}`);
+        }
+        return resolved;
+    }
+    fileRelayHeaders() {
+        const h = { "Content-Type": "application/json" };
+        if (this.config.fileRelay?.apiKey)
+            h["X-API-Key"] = this.config.fileRelay.apiKey;
+        return h;
+    }
+    fileRelayUrl(path) {
+        if (!this.config.fileRelay?.baseUrl) {
+            throw new Error("openclaw-bridge: fileRelay.baseUrl not configured");
+        }
+        return `${this.config.fileRelay.baseUrl.replace(/\/+$/, "")}${path}`;
+    }
+    async sendFile(target, localRelativePath) {
+        const sourcePath = this.validatePathWithinWorkspace(localRelativePath, this.workspacePath);
+        if (this.isSameMachine(target)) {
+            const destDir = join(target.workspacePath, "_inbox", this.config.agentId);
+            await mkdir(destDir, { recursive: true });
+            const originalFilename = localRelativePath.split(/[\\/]/).pop();
+            const rawDestPath = join(destDir, originalFilename);
+            const destPath = await deduplicatePath(rawDestPath);
+            await copyFile(sourcePath, destPath);
+            const actualFilename = basename(destPath);
+            const renamed = actualFilename !== originalFilename;
+            this.logger.info(`openclaw-bridge: sent ${localRelativePath} to ${target.agentId} (local)${renamed ? ` (renamed to ${actualFilename})` : ""}`);
+            return {
+                delivered: true,
+                message: renamed
+                    ? `File copied to ${target.agentId}/_inbox/ (renamed to ${actualFilename} because a file with the same name already existed)`
+                    : `File copied to ${target.agentId}/_inbox/`,
+                filename: actualFilename,
+                renamed,
+            };
+        }
+        const content = await readFile(sourcePath);
+        const res = await fetch(this.fileRelayUrl("/api/v1/files/upload"), {
+            method: "POST",
+            headers: this.fileRelayHeaders(),
+            body: JSON.stringify({
+                fromAgent: this.config.agentId,
+                toAgent: target.agentId,
+                filename: localRelativePath.split(/[\\/]/).pop(),
+                content: content.toString("base64"),
+                metadata: {},
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`openclaw-bridge: FileRelay upload failed: ${res.status}`);
+        }
+        this.logger.info(`openclaw-bridge: sent ${localRelativePath} to ${target.agentId} (FileRelay)`);
+        return { delivered: false, message: `File uploaded to FileRelay for ${target.agentId}` };
+    }
+    async readRemoteFile(target, relativePath) {
+        if (this.isSameMachine(target)) {
+            const fullPath = this.validatePathWithinWorkspace(relativePath, target.workspacePath);
+            return await readFile(fullPath, "utf-8");
+        }
+        const enqueueRes = await fetch(this.fileRelayUrl("/api/v1/commands/enqueue"), {
+            method: "POST",
+            headers: this.fileRelayHeaders(),
+            body: JSON.stringify({
+                fromAgent: this.config.agentId,
+                toAgent: target.agentId,
+                type: "read_file",
+                payload: { path: relativePath },
+            }),
+        });
+        if (!enqueueRes.ok) {
+            throw new Error(`openclaw-bridge: command enqueue failed: ${enqueueRes.status}`);
+        }
+        const { id: cmdId } = (await enqueueRes.json());
+        const deadline = Date.now() + 90_000;
+        while (Date.now() < deadline) {
+            await new Promise((r) => setTimeout(r, 5_000));
+            const resultRes = await fetch(this.fileRelayUrl(`/api/v1/commands/result/${cmdId}`), {
+                headers: this.fileRelayHeaders(),
+            });
+            if (!resultRes.ok)
+                continue;
+            const result = (await resultRes.json());
+            if (result.status === "ok" && result.payload?.content) {
+                return Buffer.from(result.payload.content, "base64").toString("utf-8");
+            }
+            if (result.status === "error") {
+                throw new Error(`openclaw-bridge: remote read failed`);
+            }
+        }
+        throw new Error("openclaw-bridge: remote read timed out (90s)");
+    }
+    async writeRemoteFile(target, relativePath, content) {
+        if (this.isSameMachine(target)) {
+            const fullPath = this.validatePathWithinWorkspace(relativePath, target.workspacePath);
+            await mkdir(dirname(fullPath), { recursive: true });
+            await writeFile(fullPath, content, "utf-8");
+            this.logger.info(`openclaw-bridge: wrote ${relativePath} to ${target.agentId} workspace`);
+            return;
+        }
+        const res = await fetch(this.fileRelayUrl("/api/v1/files/upload"), {
+            method: "POST",
+            headers: this.fileRelayHeaders(),
+            body: JSON.stringify({
+                fromAgent: this.config.agentId,
+                toAgent: target.agentId,
+                filename: relativePath.split(/[\\/]/).pop(),
+                content: Buffer.from(content).toString("base64"),
+                metadata: { writeToPath: relativePath },
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`openclaw-bridge: FileRelay write-upload failed: ${res.status}`);
+        }
+    }
+    async processPendingFiles() {
+        if (!this.config.fileRelay?.baseUrl)
+            return 0;
+        try {
+            const res = await fetch(this.fileRelayUrl(`/api/v1/files/pending?agent=${this.config.agentId}`), { headers: this.fileRelayHeaders() });
+            if (!res.ok)
+                return 0;
+            const data = (await res.json());
+            let count = 0;
+            for (const file of data.files) {
+                const dlRes = await fetch(this.fileRelayUrl(`/api/v1/files/download/${file.id}`), {
+                    headers: this.fileRelayHeaders(),
+                });
+                if (!dlRes.ok)
+                    continue;
+                const dlData = (await dlRes.json());
+                const fileContent = Buffer.from(dlData.content, "base64");
+                let destPath;
+                if (file.metadata?.writeToPath) {
+                    destPath = this.validatePathWithinWorkspace(file.metadata.writeToPath, this.workspacePath);
+                }
+                else {
+                    const inboxDir = join(this.workspacePath, "_inbox", file.fromAgent);
+                    await mkdir(inboxDir, { recursive: true });
+                    destPath = await deduplicatePath(join(inboxDir, file.filename));
+                }
+                await mkdir(dirname(destPath), { recursive: true });
+                await writeFile(destPath, fileContent);
+                await fetch(this.fileRelayUrl(`/api/v1/files/ack/${file.id}`), {
+                    method: "POST",
+                    headers: this.fileRelayHeaders(),
+                });
+                count++;
+            }
+            if (count > 0) {
+                this.logger.info(`openclaw-bridge: processed ${count} pending file(s) from FileRelay`);
+            }
+            return count;
+        }
+        catch (err) {
+            this.logger.warn(`openclaw-bridge: FileRelay file poll failed: ${String(err)}`);
+            return 0;
+        }
+    }
+    async processPendingCommands() {
+        if (!this.config.fileRelay?.baseUrl)
+            return 0;
+        try {
+            const res = await fetch(this.fileRelayUrl(`/api/v1/commands/pending?agent=${this.config.agentId}`), { headers: this.fileRelayHeaders() });
+            if (!res.ok)
+                return 0;
+            const data = (await res.json());
+            let count = 0;
+            for (const cmd of data.commands) {
+                try {
+                    if (cmd.type === "read_file") {
+                        const path = cmd.payload.path;
+                        const fullPath = this.validatePathWithinWorkspace(path, this.workspacePath);
+                        const content = await readFile(fullPath);
+                        await fetch(this.fileRelayUrl(`/api/v1/commands/respond/${cmd.id}`), {
+                            method: "POST",
+                            headers: this.fileRelayHeaders(),
+                            body: JSON.stringify({
+                                status: "ok",
+                                payload: { content: content.toString("base64") },
+                            }),
+                        });
+                    }
+                    else if (cmd.type === "restart") {
+                        // Acknowledge the command first
+                        await fetch(this.fileRelayUrl(`/api/v1/commands/respond/${cmd.id}`), {
+                            method: "POST",
+                            headers: this.fileRelayHeaders(),
+                            body: JSON.stringify({ status: "ok", payload: {} }),
+                        });
+                        // Schedule self-restart after responding
+                        setTimeout(() => {
+                            this.logger.info("openclaw-bridge: executing remote restart command");
+                            process.exit(0); // PM2 or run.ps1 will restart the process
+                        }, 1_000);
+                    }
+                    count++;
+                }
+                catch (err) {
+                    await fetch(this.fileRelayUrl(`/api/v1/commands/respond/${cmd.id}`), {
+                        method: "POST",
+                        headers: this.fileRelayHeaders(),
+                        body: JSON.stringify({ status: "error", payload: { error: String(err) } }),
+                    });
+                }
+            }
+            if (count > 0) {
+                this.logger.info(`openclaw-bridge: processed ${count} pending command(s) from FileRelay`);
+            }
+            return count;
+        }
+        catch (err) {
+            this.logger.warn(`openclaw-bridge: FileRelay command poll failed: ${String(err)}`);
+            return 0;
+        }
+    }
+}

package/dist/heartbeat.d.ts

@@ -0,0 +1,21 @@
+import type { BridgeConfig, RegistryEntry, PluginLogger } from "./types.js";
+import type { BridgeRegistry } from "./registry.js";
+import type { BridgeFileOps } from "./file-ops.js";
+export declare class BridgeHeartbeat {
+    private config;
+    private registry;
+    private fileOps;
+    private logger;
+    private entry;
+    private timer;
+    private lastConfigHash;
+    private configPath;
+    constructor(config: BridgeConfig, registry: BridgeRegistry, fileOps: BridgeFileOps, entry: RegistryEntry, logger: PluginLogger);
+    private computeEntryHash;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private tick;
+    private detectVisionSupport;
+    private detectConfigChanges;
+    private extractChannels;
+}

package/dist/heartbeat.js

@@ -0,0 +1,152 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+export class BridgeHeartbeat {
+    config;
+    registry;
+    fileOps;
+    logger;
+    entry;
+    timer = null;
+    lastConfigHash = "";
+    configPath;
+    constructor(config, registry, fileOps, entry, logger) {
+        this.config = config;
+        this.registry = registry;
+        this.fileOps = fileOps;
+        this.entry = entry;
+        this.logger = logger;
+        this.configPath = process.env.OPENCLAW_CONFIG_PATH;
+        this.lastConfigHash = this.computeEntryHash();
+    }
+    computeEntryHash() {
+        const data = {
+            agentId: this.entry.agentId,
+            agentName: this.entry.agentName,
+            port: this.entry.port,
+            workspacePath: this.entry.workspacePath,
+            discordId: this.entry.discordId,
+            role: this.entry.role,
+            capabilities: this.entry.capabilities,
+        };
+        return createHash("md5").update(JSON.stringify(data)).digest("hex");
+    }
+    async start() {
+        await this.registry.register(this.entry);
+        this.lastConfigHash = this.computeEntryHash();
+        const intervalMs = this.config.heartbeatIntervalMs ?? 30_000;
+        this.timer = setInterval(() => {
+            this.tick().catch((err) => this.logger.warn(`openclaw-bridge: heartbeat tick failed: ${String(err)}`));
+        }, intervalMs);
+        this.logger.info(`openclaw-bridge: heartbeat started (${intervalMs / 1000}s interval)`);
+    }
+    async stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        await this.registry.deregister(this.entry.agentId);
+        this.logger.info("openclaw-bridge: heartbeat stopped, deregistered");
+    }
+    async tick() {
+        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) {
+            this.logger.info("openclaw-bridge: config change detected, updating registry");
+            await this.registry.update(this.entry);
+            this.lastConfigHash = currentHash;
+        }
+        else {
+            await this.registry.update(this.entry);
+        }
+        await this.fileOps.processPendingFiles();
+        await this.fileOps.processPendingCommands();
+    }
+    detectVisionSupport() {
+        // Explicit config override takes priority
+        if (this.config.supportsVision !== undefined) {
+            return this.config.supportsVision;
+        }
+        if (!this.configPath)
+            return true; // Default to true — most models support vision
+        try {
+            const raw = readFileSync(this.configPath, "utf-8");
+            const config = JSON.parse(raw);
+            const defaultModel = (config.models?.default ?? "").toLowerCase();
+            if (!defaultModel)
+                return true;
+            // Known text-only models that do NOT support vision
+            const textOnlyPatterns = [
+                "minimax", "m2.7", "deepseek-r1", "deepseek-v2", "qwen-turbo",
+                "yi-lightning", "glm-3", "glm-4-flash", "mistral-small",
+                "codestral", "command-r", "phi-3-mini", "phi-3-small",
+            ];
+            return !textOnlyPatterns.some((p) => defaultModel.includes(p));
+        }
+        catch {
+            return true;
+        }
+    }
+    async detectConfigChanges() {
+        if (!this.configPath)
+            return;
+        try {
+            const raw = await readFile(this.configPath, "utf-8");
+            const config = JSON.parse(raw);
+            // Find this agent's Discord binding
+            const binding = config.bindings?.find((b) => b.agentId === this.entry.agentId && b.match.channel === "discord");
+            if (!binding)
+                return;
+            const accountId = binding.match.accountId;
+            const token = config.channels?.discord?.accounts?.[accountId]?.token;
+            if (!token)
+                return;
+            // Extract Discord user ID from token (first segment is base64-encoded user ID)
+            const firstSegment = token.split(".")[0];
+            try {
+                const decoded = Buffer.from(firstSegment, "base64").toString("utf-8");
+                if (/^\d+$/.test(decoded) && decoded !== this.entry.discordId) {
+                    this.entry.discordId = decoded;
+                    this.logger.info(`openclaw-bridge: discordId detected: ${decoded}`);
+                }
+            }
+            catch {
+                // Token decode failed — skip
+            }
+            this.entry.discordConnected = !!this.entry.discordId;
+            const channels = this.extractChannels(this.configPath);
+            this.entry.channels = channels;
+        }
+        catch {
+            // Config read failed — skip this cycle
+        }
+    }
+    extractChannels(configPath) {
+        try {
+            const raw = readFileSync(configPath, "utf-8");
+            const config = JSON.parse(raw);
+            const accounts = config.channels?.discord?.accounts;
+            if (!Array.isArray(accounts))
+                return [];
+            const result = [];
+            for (const account of accounts) {
+                if (!Array.isArray(account.channels))
+                    continue;
+                for (const ch of account.channels) {
+                    const channelId = ch.channelId ?? ch.id ?? "";
+                    const name = ch.name ?? channelId;
+                    if (channelId) {
+                        result.push({ type: "discord", channelId, name });
+                    }
+                }
+            }
+            return result;
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import type { OpenClawPluginApi } from "./types.js";
+declare const bridgePlugin: {
+    id: string;
+    name: string;
+    description: string;
+    kind: "extension";
+    register(api: OpenClawPluginApi): void;
+};
+export default bridgePlugin;