@relaymessenger/openclaw-plugin 0.2.0

package/src/account-lock.ts

@@ -0,0 +1,108 @@
+import { createHash, randomUUID } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+interface LockOwner {
+  pid: number;
+  nonce: string;
+  account_id: string;
+  created_at: string;
+}
+
+function processIsLive(pid: number): boolean {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error: any) {
+    return error?.code === "EPERM";
+  }
+}
+
+function readOwner(path: string): LockOwner | undefined {
+  try {
+    const value = JSON.parse(readFileSync(path, "utf8")) as Partial<LockOwner>;
+    if (
+      Number.isSafeInteger(value.pid) &&
+      typeof value.nonce === "string" &&
+      typeof value.account_id === "string" &&
+      typeof value.created_at === "string"
+    ) {
+      return value as LockOwner;
+    }
+  } catch {
+    // Missing/malformed ownership is never deleted in place by a contender.
+  }
+  return undefined;
+}
+
+/** Atomic filesystem lease preventing two OpenClaw processes polling one agent. */
+export class RelayAccountLock {
+  private readonly lockPath: string;
+  private readonly ownerPath: string;
+  private readonly nonce = randomUUID();
+  private held = false;
+
+  constructor(
+    baseUrl: string,
+    agentId: string,
+    private readonly accountId: string,
+    baseDir = join(homedir(), ".openclaw", "relay", "consumer-locks"),
+  ) {
+    const key = createHash("sha256").update(`${baseUrl}\0${agentId}`).digest("hex");
+    this.lockPath = join(baseDir, key);
+    this.ownerPath = join(this.lockPath, "owner.json");
+  }
+
+  acquire(): void {
+    mkdirSync(join(this.lockPath, ".."), { recursive: true, mode: 0o700 });
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        mkdirSync(this.lockPath, { mode: 0o700 });
+        const owner: LockOwner = {
+          pid: process.pid,
+          nonce: this.nonce,
+          account_id: this.accountId,
+          created_at: new Date().toISOString(),
+        };
+        writeFileSync(this.ownerPath, `${JSON.stringify(owner)}\n`, { mode: 0o600 });
+        this.held = true;
+        return;
+      } catch (error: any) {
+        if (error?.code !== "EEXIST") throw error;
+        const owner = readOwner(this.ownerPath);
+        if (!owner || processIsLive(owner.pid)) {
+          const claimant = owner
+            ? `account "${owner.account_id}" (pid ${owner.pid})`
+            : "an existing process with unreadable ownership";
+          throw new Error(`relay: this agent already has an active consumer in ${claimant}`);
+        }
+        const stalePath = `${this.lockPath}.stale-${Date.now()}-${randomUUID()}`;
+        try {
+          renameSync(this.lockPath, stalePath);
+          rmSync(stalePath, { recursive: true, force: true });
+        } catch (renameError: any) {
+          if (renameError?.code !== "ENOENT") throw renameError;
+        }
+      }
+    }
+    throw new Error("relay: could not acquire the agent consumer lock");
+  }
+
+  release(): void {
+    if (!this.held) return;
+    const owner = readOwner(this.ownerPath);
+    if (owner?.nonce === this.nonce && existsSync(this.lockPath)) {
+      rmSync(this.lockPath, { recursive: true, force: true });
+    }
+    this.held = false;
+  }
+}

package/src/accounts.ts

@@ -0,0 +1,98 @@
+// Multi-account resolution: channels.relay.accounts.<id> with a
+// default-account fallback, so one OpenClaw can back several Relay contacts
+// (one Agent Token each). Env vars cover the single-account quickstart.
+import {
+  createAccountListHelpers,
+  resolveMergedAccountConfig,
+} from "openclaw/plugin-sdk/account-helpers";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { tryReadSecretFileSync } from "openclaw/plugin-sdk/channel-core";
+import { DEFAULT_RELAY_BASE_URL, normalizeRelayBaseUrl } from "./client.js";
+import type { RelayAccountConfig, RelayCoreConfig, ResolvedRelayAccount } from "./types.js";
+
+export const RELAY_TOKEN_ENV_VAR = "RELAY_AGENT_TOKEN";
+export const RELAY_BASE_URL_ENV_VAR = "RELAY_BASE_URL";
+
+const DEFAULT_POLL_TIMEOUT_SECONDS = 30;
+
+const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("relay", {
+  normalizeAccountId,
+  implicitDefaultAccount: {
+    channelKeys: ["token", "tokenFile"],
+    envVars: [RELAY_TOKEN_ENV_VAR],
+  },
+});
+
+export {
+  listAccountIds as listRelayAccountIds,
+  resolveDefaultAccountId as resolveDefaultRelayAccountId,
+  DEFAULT_ACCOUNT_ID,
+};
+
+function resolveMergedRelayAccountConfig(
+  cfg: RelayCoreConfig,
+  accountId: string,
+): RelayAccountConfig {
+  return resolveMergedAccountConfig<RelayAccountConfig>({
+    channelConfig: cfg.channels?.relay as RelayAccountConfig | undefined,
+    accounts: cfg.channels?.relay?.accounts,
+    accountId,
+    omitKeys: ["defaultAccount"],
+    normalizeAccountId,
+  });
+}
+
+function resolveToken(params: {
+  merged: RelayAccountConfig;
+  accountId: string;
+  env: NodeJS.ProcessEnv;
+}): string {
+  const direct = params.merged.token?.trim();
+  if (direct) {
+    return direct;
+  }
+  const fromFile = params.merged.tokenFile
+    ? tryReadSecretFileSync(params.merged.tokenFile, "relay tokenFile")?.trim()
+    : undefined;
+  if (fromFile) {
+    return fromFile;
+  }
+  // Env token applies to the default account only, so named accounts cannot
+  // silently share one token.
+  if (params.accountId === DEFAULT_ACCOUNT_ID) {
+    return params.env[RELAY_TOKEN_ENV_VAR]?.trim() ?? "";
+  }
+  return "";
+}
+
+export function resolveRelayAccount(params: {
+  cfg: RelayCoreConfig;
+  accountId?: string | null;
+  env?: NodeJS.ProcessEnv;
+}): ResolvedRelayAccount {
+  const env = params.env ?? process.env;
+  const accountId = normalizeAccountId(params.accountId);
+  const merged = resolveMergedRelayAccountConfig(params.cfg, accountId);
+  const baseEnabled = params.cfg.channels?.relay?.enabled !== false;
+  const enabled = baseEnabled && merged.enabled !== false;
+  const token = resolveToken({ merged, accountId, env });
+  const baseUrl = normalizeRelayBaseUrl(
+    merged.baseUrl?.trim() ||
+      (accountId === DEFAULT_ACCOUNT_ID ? env[RELAY_BASE_URL_ENV_VAR]?.trim() : undefined) ||
+      DEFAULT_RELAY_BASE_URL,
+  );
+  const pollTimeoutSeconds = Math.min(
+    Math.max(merged.pollTimeoutSeconds ?? DEFAULT_POLL_TIMEOUT_SECONDS, 1),
+    30,
+  );
+  return {
+    accountId,
+    enabled,
+    configured: Boolean(token),
+    ...(merged.name?.trim() ? { name: merged.name.trim() } : {}),
+    token,
+    baseUrl,
+    pollTimeoutSeconds,
+    config: merged,
+  };
+}