openclaw-bridge 0.3.2 → 0.4.1

package/src/config.ts

@@ -1,72 +0,0 @@
-import { hostname } from "node:os";
-import type { BridgeConfig } from "./types.js";
-
-const DEFAULTS = {
-  heartbeatIntervalMs: 30_000,
-  offlineThresholdMs: 120_000,
-} as const;
-
-export function parseConfig(raw: unknown): BridgeConfig {
-  if (!raw || typeof raw !== "object") {
-    throw new Error("openclaw-bridge: missing plugin config");
-  }
-  const obj = raw as Record<string, unknown>;
-
-  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 as Record<string, unknown> | undefined;
-  if (!registry || !registry.baseUrl || typeof registry.baseUrl !== "string") {
-    throw new Error("openclaw-bridge: config.registry.baseUrl is required");
-  }
-
-  return {
-    role: obj.role as "normal" | "superuser",
-    agentId: obj.agentId as string,
-    agentName: obj.agentName as string,
-    registry: {
-      provider: (registry.provider as string) ?? "openviking",
-      baseUrl: registry.baseUrl as string,
-      apiKey: registry.apiKey as string | undefined,
-    },
-    fileRelay: obj.fileRelay
-      ? {
-          baseUrl: (obj.fileRelay as Record<string, unknown>).baseUrl as string,
-          apiKey: (obj.fileRelay as Record<string, unknown>).apiKey as string | undefined,
-        }
-      : undefined,
-    messageRelay: obj.messageRelay
-      ? {
-          url: (obj.messageRelay as Record<string, unknown>).url as string,
-          apiKey: (obj.messageRelay as Record<string, unknown>).apiKey as string,
-        }
-      : 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 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,
-  };
-}
-
-export function getMachineId(): string {
-  return hostname();
-}

package/src/discovery.ts

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

package/src/file-ops.ts

@@ -1,320 +0,0 @@
-import { readFile, writeFile, copyFile, mkdir, access } from "node:fs/promises";
-import { join, resolve, dirname, basename, extname } from "node:path";
-import type { BridgeConfig, RegistryEntry, PluginLogger } from "./types.js";
-
-/** If dest exists, append _1, _2, etc. before the extension */
-async function deduplicatePath(destPath: string): Promise<string> {
-  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 {
-  private config: BridgeConfig;
-  private machineId: string;
-  private workspacePath: string;
-  private logger: PluginLogger;
-
-  constructor(
-    config: BridgeConfig,
-    machineId: string,
-    workspacePath: string,
-    logger: PluginLogger,
-  ) {
-    this.config = config;
-    this.machineId = machineId;
-    this.workspacePath = workspacePath;
-    this.logger = logger;
-  }
-
-  private isSameMachine(target: RegistryEntry): boolean {
-    return target.machineId === this.machineId;
-  }
-
-  private validatePathWithinWorkspace(filePath: string, workspace: string): string {
-    const resolved = resolve(workspace, filePath);
-    if (!resolved.startsWith(resolve(workspace))) {
-      throw new Error(`openclaw-bridge: path escapes workspace: ${filePath}`);
-    }
-    return resolved;
-  }
-
-  private fileRelayHeaders(): Record<string, string> {
-    const h: Record<string, string> = { "Content-Type": "application/json" };
-    if (this.config.fileRelay?.apiKey) h["X-API-Key"] = this.config.fileRelay.apiKey;
-    return h;
-  }
-
-  private fileRelayUrl(path: string): string {
-    if (!this.config.fileRelay?.baseUrl) {
-      throw new Error("openclaw-bridge: fileRelay.baseUrl not configured");
-    }
-    return `${this.config.fileRelay.baseUrl.replace(/\/+$/, "")}${path}`;
-  }
-
-  async sendFile(
-    target: RegistryEntry,
-    localRelativePath: string,
-  ): Promise<{ delivered: boolean; message: string }> {
-    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: RegistryEntry,
-    relativePath: string,
-  ): Promise<string> {
-    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()) as { id: string };
-
-    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()) as {
-        status: string;
-        payload?: { content?: string };
-      };
-      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: RegistryEntry,
-    relativePath: string,
-    content: string,
-  ): Promise<void> {
-    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(): Promise<number> {
-    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()) as {
-        files: Array<{
-          id: string;
-          fromAgent: string;
-          filename: string;
-          metadata?: { writeToPath?: string };
-        }>;
-      };
-
-      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()) as { content: string };
-        const fileContent = Buffer.from(dlData.content, "base64");
-
-        let destPath: string;
-        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(): Promise<number> {
-    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()) as {
-        commands: Array<{
-          id: string;
-          fromAgent: string;
-          type: string;
-          payload: Record<string, unknown>;
-        }>;
-      };
-
-      let count = 0;
-      for (const cmd of data.commands) {
-        try {
-          if (cmd.type === "read_file") {
-            const path = cmd.payload.path as string;
-            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/src/heartbeat.ts

@@ -1,196 +0,0 @@
-import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import type { BridgeConfig, RegistryEntry, ChannelInfo, PluginLogger } from "./types.js";
-import type { BridgeRegistry } from "./registry.js";
-import type { BridgeFileOps } from "./file-ops.js";
-
-export class BridgeHeartbeat {
-  private config: BridgeConfig;
-  private registry: BridgeRegistry;
-  private fileOps: BridgeFileOps;
-  private logger: PluginLogger;
-  private entry: RegistryEntry;
-  private timer: ReturnType<typeof setInterval> | null = null;
-  private lastConfigHash: string = "";
-  private configPath: string | undefined;
-
-  constructor(
-    config: BridgeConfig,
-    registry: BridgeRegistry,
-    fileOps: BridgeFileOps,
-    entry: RegistryEntry,
-    logger: PluginLogger,
-  ) {
-    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();
-  }
-
-  private computeEntryHash(): string {
-    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(): Promise<void> {
-    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(): Promise<void> {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-    await this.registry.deregister(this.entry.agentId);
-    this.logger.info("openclaw-bridge: heartbeat stopped, deregistered");
-  }
-
-  private async tick(): Promise<void> {
-    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();
-  }
-
-  private detectVisionSupport(): boolean {
-    // 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) as {
-        models?: {
-          default?: string;
-          list?: Array<{ id?: string; name?: string }>;
-        };
-      };
-      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;
-    }
-  }
-
-  private async detectConfigChanges(): Promise<void> {
-    if (!this.configPath) return;
-
-    try {
-      const raw = await readFile(this.configPath, "utf-8");
-      const config = JSON.parse(raw) as {
-        bindings?: Array<{ agentId: string; match: { channel: string; accountId: string } }>;
-        channels?: {
-          discord?: {
-            accounts?: Record<string, { token?: string; channels?: Array<{ id?: string; channelId?: string; name?: string }> }>;
-          };
-        };
-      };
-
-      // 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
-    }
-  }
-
-  private extractChannels(configPath: string): ChannelInfo[] {
-    try {
-      const raw = readFileSync(configPath, "utf-8");
-      const config = JSON.parse(raw) as {
-        channels?: {
-          discord?: {
-            accounts?: Array<{
-              channels?: Array<{ id?: string; channelId?: string; name?: string }>;
-            }>;
-          };
-        };
-      };
-
-      const accounts = config.channels?.discord?.accounts;
-      if (!Array.isArray(accounts)) return [];
-
-      const result: ChannelInfo[] = [];
-      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 [];
-    }
-  }
-}