@relaymessenger/openclaw-plugin 0.3.3 → 0.4.0-staging.0

package/dist/src/inbound-dedupe.js

@@ -1,175 +0,0 @@
-// Relay inbound replay protection. The long-poll cursor acknowledges batches,
-// so a crash between dispatch and cursor advance
-// replays events. Each (canonical origin, agent, event) is claimed, safely
-// preflighted, and durably committed immediately before agent dispatch. That
-// gives engine/tool side effects at-most-once semantics:
-// an interrupted turn may need the user to resend, but it is never silently
-// executed twice.
-import { createHash } from "node:crypto";
-import { assertRelayStateDocument, emptyRelayStateDocument, openRelayStateDocument, } from "./state-files.js";
-// One shared namespace with stable Relay identity baked into each key so local
-// account renames cannot reset safety state or partition the row budget.
-const RELAY_INBOUND_DEDUPE_SCOPE = "global";
-// 30d window: a long outage can replay a deep cursor backlog.
-export const RELAY_INBOUND_DEDUPE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
-export const RELAY_INBOUND_DEDUPE_STATE_MAX_ENTRIES = 20_000;
-export function buildRelayInboundDedupeKey(params) {
-    const eventId = params.eventId.trim();
-    if (!eventId) {
-        return null;
-    }
-    // NUL separator: event ids are opaque strings, so a printable separator
-    // could collide two distinct (account, event) pairs.
-    return `${new URL(params.baseUrl).origin}\0${params.agentId}\0${eventId}`;
-}
-export function createRelayInboundDeduper(params) {
-    const namespace = RELAY_INBOUND_DEDUPE_SCOPE;
-    return {
-        claimEvent: async (eventId) => {
-            const key = buildRelayInboundDedupeKey({ baseUrl: params.baseUrl, agentId: params.agentId, eventId });
-            if (!key) {
-                // Fail closed: an event without a durable identity cannot safely
-                // cross the at-most-once agent/tool side-effect boundary.
-                return false;
-            }
-            return (await params.guard.claim(key, { namespace })).kind === "claimed";
-        },
-        commitEvent: async (eventId) => {
-            const key = buildRelayInboundDedupeKey({ baseUrl: params.baseUrl, agentId: params.agentId, eventId });
-            if (!key) {
-                return;
-            }
-            await params.guard.commit(key, { namespace });
-        },
-        releaseEvent: (eventId) => {
-            const key = buildRelayInboundDedupeKey({ baseUrl: params.baseUrl, agentId: params.agentId, eventId });
-            if (key) {
-                params.guard.release(key, { namespace });
-            }
-        },
-    };
-}
-function durableAttemptKey(key, namespace) {
-    return createHash("sha256").update(`${namespace}\0${key}`).digest("hex");
-}
-/**
- * Strict Relay-owned guard used by the channel runtime. Unlike a normal
- * message dedupe cache, persistence is not best effort: a failed attempt write
- * must stop before agent dispatch or a crash could execute local tools twice.
- */
-export function createRelayInboundDedupeGuard(params) {
-    const now = params?.now ?? Date.now;
-    const ttlMs = params?.ttlMs ?? RELAY_INBOUND_DEDUPE_TTL_MS;
-    const maxEntries = params?.maxEntries ?? RELAY_INBOUND_DEDUPE_STATE_MAX_ENTRIES;
-    if (!Number.isSafeInteger(ttlMs) || ttlMs < 1) {
-        throw new Error("relay inbound dedupe ttlMs must be a positive safe integer");
-    }
-    if (!Number.isSafeInteger(maxEntries) || maxEntries < 1) {
-        throw new Error("relay inbound dedupe maxEntries must be a positive safe integer");
-    }
-    const readNow = () => {
-        const timestamp = now();
-        if (!Number.isSafeInteger(timestamp) || timestamp < 0) {
-            throw new Error("relay inbound dedupe clock returned an invalid timestamp");
-        }
-        return timestamp;
-    };
-    const isPersistedAttempt = (key, value) => {
-        if (!/^[a-f0-9]{64}$/u.test(key) || !value || typeof value !== "object")
-            return false;
-        const entry = value;
-        return (typeof entry.attemptedAt === "number" &&
-            Number.isSafeInteger(entry.attemptedAt) &&
-            entry.attemptedAt >= 0 &&
-            typeof entry.expiresAt === "number" &&
-            Number.isSafeInteger(entry.expiresAt) &&
-            entry.expiresAt > entry.attemptedAt);
-    };
-    const state = params?.store
-        ? undefined
-        : openRelayStateDocument({
-            fileName: "inbound-attempts.json",
-            ...(params?.env ? { env: params.env } : {}),
-        });
-    const store = params?.store ??
-        {
-            lookup: async (key) => {
-                const current = await state.read();
-                if (current === undefined)
-                    return undefined;
-                assertRelayStateDocument(current, "inbound attempt", isPersistedAttempt);
-                const entry = current.entries[key];
-                if (!entry || entry.expiresAt <= readNow())
-                    return undefined;
-                return { attemptedAt: entry.attemptedAt };
-            },
-            register: async (key, value, opts) => {
-                await state.updateOr(emptyRelayStateDocument(), (current) => {
-                    assertRelayStateDocument(current, "inbound attempt", isPersistedAttempt);
-                    const timestamp = readNow();
-                    const entryTtlMs = opts?.ttlMs ?? ttlMs;
-                    if (!Number.isSafeInteger(entryTtlMs) || entryTtlMs < 1) {
-                        throw new Error("relay inbound dedupe ttlMs must be a positive safe integer");
-                    }
-                    const expiresAt = value.attemptedAt + entryTtlMs;
-                    if (!Number.isSafeInteger(expiresAt)) {
-                        throw new Error("relay inbound dedupe expiration exceeds safe integer range");
-                    }
-                    const liveEntries = Object.fromEntries(Object.entries(current.entries).filter(([, entry]) => entry.expiresAt > timestamp));
-                    liveEntries[key] = {
-                        attemptedAt: value.attemptedAt,
-                        expiresAt,
-                    };
-                    const ordered = Object.entries(liveEntries).sort(([leftKey, left], [rightKey, right]) => left.attemptedAt - right.attemptedAt || leftKey.localeCompare(rightKey));
-                    const retained = ordered.slice(Math.max(ordered.length - maxEntries, 0));
-                    return {
-                        version: current.version,
-                        entries: Object.fromEntries(retained),
-                    };
-                });
-            },
-        };
-    const inflight = new Set();
-    const claiming = new Set();
-    const withDiskError = async (operation) => {
-        try {
-            return await operation();
-        }
-        catch (error) {
-            params?.onDiskError?.(error);
-            throw error;
-        }
-    };
-    return {
-        claim: async (key, opts) => {
-            const storageKey = durableAttemptKey(key, opts.namespace);
-            if (inflight.has(storageKey) || claiming.has(storageKey)) {
-                return { kind: "inflight" };
-            }
-            claiming.add(storageKey);
-            try {
-                if ((await withDiskError(() => store.lookup(storageKey))) !== undefined) {
-                    return { kind: "duplicate" };
-                }
-                inflight.add(storageKey);
-                return { kind: "claimed" };
-            }
-            finally {
-                claiming.delete(storageKey);
-            }
-        },
-        commit: async (key, opts) => {
-            const storageKey = durableAttemptKey(key, opts.namespace);
-            try {
-                await withDiskError(() => store.register(storageKey, { attemptedAt: readNow() }, { ttlMs }));
-                return true;
-            }
-            finally {
-                inflight.delete(storageKey);
-            }
-        },
-        release: (key, opts) => {
-            inflight.delete(durableAttemptKey(key, opts.namespace));
-        },
-    };
-}

package/dist/src/lifecycle.js

@@ -1,35 +0,0 @@
-/** Owns exactly one abortable long-poll lifecycle per configured account. */
-export function createRelayAccountLifecycleRegistry() {
-    const controllers = new Map();
-    return {
-        acquire(accountId, parentSignal) {
-            if (controllers.has(accountId)) {
-                throw new Error(`relay: account "${accountId}" already has an active consumer`);
-            }
-            const controller = new AbortController();
-            controllers.set(accountId, controller);
-            const signal = AbortSignal.any([parentSignal, controller.signal]);
-            let released = false;
-            return {
-                signal,
-                release: () => {
-                    if (released) {
-                        return;
-                    }
-                    released = true;
-                    if (controllers.get(accountId) === controller) {
-                        controllers.delete(accountId);
-                    }
-                },
-            };
-        },
-        stop(accountId) {
-            const controller = controllers.get(accountId);
-            if (!controller) {
-                return false;
-            }
-            controller.abort();
-            return true;
-        },
-    };
-}

package/dist/src/poll-loop.js

@@ -1,125 +0,0 @@
-// startAccount receive engine: abort-aware long poll over GET /v1/events with
-// claim -> durable attempt commit -> dispatch per event and the cursor advanced
-// only after the batch's commits. The supervisor owns restart/backoff: this loop settles
-// (throws) on terminal auth failure and consumer conflicts, and only sleeps
-// in-loop for transient errors.
-import { RelayApiError, isAbortError } from "./client.js";
-const TRANSIENT_BASE_DELAY_MS = 500;
-const TRANSIENT_MAX_DELAY_MS = 30_000;
-function defaultSleep(ms, signal) {
-    return new Promise((resolve) => {
-        if (signal.aborted) {
-            resolve();
-            return;
-        }
-        const timer = setTimeout(() => {
-            signal.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        const onAbort = () => {
-            clearTimeout(timer);
-            resolve();
-        };
-        signal.addEventListener("abort", onAbort, { once: true });
-    });
-}
-export async function runRelayPollLoop(params) {
-    const sleep = params.sleep ?? defaultSleep;
-    const random = params.random ?? Math.random;
-    const log = params.log ?? (() => { });
-    let transientAttempts = 0;
-    const transientDelayMs = () => {
-        const backoff = Math.min(TRANSIENT_MAX_DELAY_MS, TRANSIENT_BASE_DELAY_MS * 2 ** Math.min(transientAttempts, 6));
-        return backoff + Math.floor(random() * 250);
-    };
-    while (!params.abortSignal.aborted) {
-        let page;
-        try {
-            page = await params.client.pollEvents({
-                cursor: params.cursorStore.current(),
-                timeoutSeconds: params.timeoutSeconds ?? 30,
-                ...(params.limit === undefined ? {} : { limit: params.limit }),
-                signal: params.abortSignal,
-            });
-        }
-        catch (error) {
-            if (params.abortSignal.aborted || isAbortError(error)) {
-                return;
-            }
-            if (error instanceof RelayApiError && error.kind === "auth") {
-                // Token revoked: settle so the supervisor applies terminalDisconnect
-                // (server-channels.ts:718) — an operator has to fix the token.
-                throw error;
-            }
-            if (error instanceof RelayApiError && error.kind === "conflict") {
-                // Another consumer took the long poll. Settle and let the
-                // supervisor's backoff arbitrate.
-                log(`[relay] long poll terminated by another consumer: ${error.message}`);
-                throw error;
-            }
-            transientAttempts += 1;
-            log(`[relay] transient poll error (attempt ${transientAttempts}): ${String(error)}`);
-            await sleep(transientDelayMs(), params.abortSignal);
-            continue;
-        }
-        transientAttempts = 0;
-        if (page.events.length > 0) {
-            params.onBatch?.(page.events);
-        }
-        let batchFailed = false;
-        for (const event of page.events) {
-            if (params.abortSignal.aborted) {
-                batchFailed = true;
-                break;
-            }
-            if (params.shouldProcess && !params.shouldProcess(event)) {
-                // Bookkeeping events (receipts, reactions, echoes) never dispatch, so
-                // they are acked by the batch cursor without a dedupe row.
-                continue;
-            }
-            const claimed = await params.deduper.claimEvent(event.event_id);
-            if (claimed) {
-                let attempted = false;
-                const markAttempt = async () => {
-                    if (attempted)
-                        return;
-                    await params.deduper.commitEvent(event.event_id);
-                    attempted = true;
-                    if (params.abortSignal.aborted)
-                        throw new Error("aborted after durable attempt");
-                };
-                try {
-                    await params.handleEvent(event, markAttempt);
-                }
-                catch (error) {
-                    if (!attempted) {
-                        params.deduper.releaseEvent(event.event_id);
-                        log(`[relay] event ${event.event_id} safe preflight failed, will replay: ${String(error)}`);
-                        batchFailed = true;
-                        break;
-                    }
-                    log(`[relay] event ${event.event_id} dispatch failed after its attempt was committed; ` +
-                        `will not replay possible tool side effects: ${String(error)}`);
-                }
-                if (!attempted) {
-                    // Admission/preflight intentionally consumed no side effect; release
-                    // the claim and allow the page cursor to acknowledge it.
-                    params.deduper.releaseEvent(event.event_id);
-                }
-                if (params.abortSignal.aborted) {
-                    batchFailed = true;
-                    break;
-                }
-            }
-        }
-        // The server's next_cursor covers the whole page (cursor N acks <= N), so
-        // only a batch with durable attempt markers may ack it. A marker-write
-        // failure acks nothing and committed predecessors absorb the replay.
-        if (!batchFailed) {
-            await params.cursorStore.advance(page.nextCursor);
-        }
-        else {
-            await sleep(transientDelayMs(), params.abortSignal);
-        }
-    }
-}

package/dist/src/responding.js

@@ -1,13 +0,0 @@
-/**
- * The receipt must commit before OpenClaw can run an agent or tool. A rejected
- * receipt leaves the durable attempt marker untouched, so the poll loop can
- * replay the event safely instead of hiding the failure after execution.
- */
-export async function markRespondingBeforeAttempt(params) {
-    await params.client.setResponding({
-        conversationId: params.conversationId,
-        messageId: params.messageId,
-        label: params.label,
-    });
-    await params.markAttempt();
-}

package/dist/src/security.js

@@ -1,26 +0,0 @@
-function normalizeSenderId(value) {
-    const normalized = String(value).trim();
-    return normalized ? normalized : null;
-}
-/**
- * Build the only identities allowed to start an OpenClaw turn. The Relay
- * account owner is pinned from the authenticated agent profile; operators can
- * deliberately extend that set with `allowFrom`. No wildcard is accepted.
- */
-export function resolveRelayAllowedSenderIds(params) {
-    const allowed = new Set();
-    const owner = params.profile.owner_user_id?.trim();
-    if (owner) {
-        allowed.add(owner);
-    }
-    for (const entry of params.allowFrom ?? []) {
-        const normalized = normalizeSenderId(entry);
-        if (normalized && normalized !== "*") {
-            allowed.add(normalized);
-        }
-    }
-    return [...allowed];
-}
-export function relaySenderIsAllowed(allowedSenderIds, senderId) {
-    return allowedSenderIds.includes(senderId);
-}

package/dist/src/state-files.js

@@ -1,167 +0,0 @@
-import { jsonStore } from "@openclaw/fs-safe/store";
-import { withFileLock } from "@openclaw/fs-safe/file-lock";
-import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
-import { chmodSync, lstatSync, mkdirSync } from "node:fs";
-import { hostname } from "node:os";
-import { basename, join } from "node:path";
-const RELAY_STATE_DOCUMENT_VERSION = 1;
-const RELAY_STATE_LOCK_VERSION = 1;
-const RELAY_STATE_LOCK_TIMEOUT_MS = 30_000;
-export function emptyRelayStateDocument() {
-    return { version: RELAY_STATE_DOCUMENT_VERSION, entries: {} };
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-export function assertRelayStateDocument(value, label, validateEntry) {
-    if (!isRecord(value) ||
-        value.version !== RELAY_STATE_DOCUMENT_VERSION ||
-        !isRecord(value.entries)) {
-        throw new Error(`relay ${label} state is corrupt`);
-    }
-    for (const [key, entry] of Object.entries(value.entries)) {
-        if (!validateEntry(key, entry)) {
-            throw new Error(`relay ${label} state is corrupt`);
-        }
-    }
-}
-function isRelayStateLockOwner(value) {
-    if (!isRecord(value))
-        return false;
-    return (value.version === RELAY_STATE_LOCK_VERSION &&
-        value.kind === "relay-state" &&
-        Number.isSafeInteger(value.pid) &&
-        value.pid > 0 &&
-        typeof value.host === "string" &&
-        value.host.length > 0 &&
-        typeof value.createdAt === "string" &&
-        Number.isFinite(Date.parse(value.createdAt)));
-}
-function localProcessIsLive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        // EPERM proves the process exists but is owned by another user. Unknown
-        // failures also fail closed; only ESRCH proves this host no longer has it.
-        return !(error instanceof Error && "code" in error && error.code === "ESRCH");
-    }
-}
-/**
- * Windows opens the sidecar lock with an openat-style
- * `O_CREAT | O_EXCL` beneath a parent handle. While a just-released lock file
- * is still delete-pending, that create returns `ACCESS_DENIED` instead of the
- * `already exists` fs-safe retries on, so contention escapes the acquire loop
- * as a hard `EACCES`. Retry those on Windows only, bounded by the caller's lock
- * timeout: a genuine permission failure simply reproduces until the deadline
- * and then surfaces unchanged.
- */
-function isWindowsLockAcquisitionContention(error) {
-    if (process.platform !== "win32")
-        return false;
-    const code = error?.code;
-    return code === "EACCES" || code === "EPERM";
-}
-function lockRetryDelayMs(attempt, remainingMs) {
-    const backoff = Math.min(25 * 2 ** attempt, 250);
-    return Math.max(1, Math.min(backoff * (0.5 + Math.random() / 2), remainingMs));
-}
-function canRecoverRelayStateLock(value) {
-    return (isRelayStateLockOwner(value) &&
-        value.host === hostname() &&
-        !localProcessIsLive(value.pid));
-}
-function ensurePrivateStateDirectory(path) {
-    mkdirSync(path, { recursive: true, mode: 0o700 });
-    const stat = lstatSync(path);
-    if (stat.isSymbolicLink() || !stat.isDirectory()) {
-        throw new Error(`relay state path is not a private directory: ${path}`);
-    }
-    try {
-        chmodSync(path, 0o700);
-    }
-    catch {
-        // POSIX modes are not fully implemented on Windows. fs-safe's private
-        // write path still owns the platform-specific file guarantees.
-    }
-}
-/**
- * Relay owns these files rather than requesting OpenClaw's privileged host
- * SQLite. jsonStore gives every mutation a private atomic replacement. An
- * fs-safe sidecar lock serializes cross-process mutations and is recovered
- * only when its valid Relay owner names this host and its PID is provably dead.
- */
-export function openRelayStateDocument(params) {
-    if (!params.fileName || basename(params.fileName) !== params.fileName) {
-        throw new Error("relay state fileName must be one file name");
-    }
-    const lockTimeoutMs = params.lockTimeoutMs ?? RELAY_STATE_LOCK_TIMEOUT_MS;
-    if (!Number.isSafeInteger(lockTimeoutMs) || lockTimeoutMs < 1) {
-        throw new Error("relay state lockTimeoutMs must be a positive safe integer");
-    }
-    const stateRoot = resolveStateDir(params.env ?? process.env);
-    const relayRoot = join(stateRoot, "relay");
-    const relayStateRoot = join(relayRoot, "state");
-    ensurePrivateStateDirectory(relayRoot);
-    ensurePrivateStateDirectory(relayStateRoot);
-    const store = jsonStore({
-        filePath: join(relayStateRoot, params.fileName),
-        dirMode: 0o700,
-        mode: 0o600,
-    });
-    const withMutationLock = async (run) => {
-        const deadline = Date.now() + lockTimeoutMs;
-        for (let attempt = 0;; attempt += 1) {
-            // Only acquisition is retried. Once the mutation itself has started it has
-            // observed state under the lock, so replaying it could double-apply.
-            let mutationStarted = false;
-            try {
-                return await withFileLock(store.filePath, {
-                    managerKey: `relay-state:${store.filePath}`,
-                    staleMs: RELAY_STATE_LOCK_TIMEOUT_MS,
-                    timeoutMs: Math.max(1, deadline - Date.now()),
-                    staleRecovery: "remove-if-unchanged",
-                    retry: {
-                        retries: 300,
-                        minTimeout: 25,
-                        maxTimeout: 250,
-                        randomize: true,
-                    },
-                    payload: () => ({
-                        version: RELAY_STATE_LOCK_VERSION,
-                        kind: "relay-state",
-                        pid: process.pid,
-                        host: hostname(),
-                        createdAt: new Date().toISOString(),
-                    }),
-                    shouldReclaim: ({ payload }) => canRecoverRelayStateLock(payload),
-                    shouldRemoveStaleLock: ({ payload }) => canRecoverRelayStateLock(payload),
-                }, async () => {
-                    mutationStarted = true;
-                    return await run();
-                });
-            }
-            catch (error) {
-                const remaining = deadline - Date.now();
-                if (mutationStarted ||
-                    remaining <= 0 ||
-                    !isWindowsLockAcquisitionContention(error)) {
-                    throw error;
-                }
-                await new Promise((resolve) => setTimeout(resolve, lockRetryDelayMs(attempt, remaining)));
-            }
-        }
-    };
-    return {
-        filePath: store.filePath,
-        read: store.read,
-        readOr: store.readOr,
-        readRequired: store.readRequired,
-        write: async (value) => {
-            await withMutationLock(async () => await store.write(value));
-        },
-        update: async (run) => await withMutationLock(async () => await store.update(run)),
-        updateOr: async (fallback, run) => await withMutationLock(async () => await store.updateOr(fallback, run)),
-    };
-}

package/src/account-lock.ts

@@ -1,108 +0,0 @@
-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;
-  }
-}