@ouro.bot/cli 0.1.0-alpha.99 → 0.1.0-alpha.991

package/dist/a2a/relay-inbox.js

@@ -0,0 +1,360 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RELAY_MAX_PER_TICK = exports.RELAY_MAX_BACKOFF_MS = exports.RELAY_POLL_INTERVAL_MS = void 0;
+exports.memoryRelayRetirements = memoryRelayRetirements;
+exports.ensureRelayRegistration = ensureRelayRegistration;
+exports.rebuildRelayedMessage = rebuildRelayedMessage;
+exports.drainRelayInbox = drainRelayInbox;
+exports.retirePreviousRegistrations = retirePreviousRegistrations;
+exports.startRelayInbox = startRelayInbox;
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../nerves/runtime");
+const relay_client_1 = require("./relay-client");
+const refusals_1 = require("./refusals");
+const seen_ledger_1 = require("./seen-ledger");
+const registrationKey = (registration) => `${registration.relayUrl}\n${registration.handle}`;
+const sameRegistration = (a, b) => registrationKey(a) === registrationKey(b);
+/** Retirement records kept in memory only (the default, and for tests). */
+function memoryRelayRetirements() {
+    const records = new Map();
+    return {
+        read: (registration) => ({ ...records.get(registrationKey(registration)) }),
+        write: (registration, record) => { records.set(registrationKey(registration), { ...record }); },
+        clear: (registration) => { records.delete(registrationKey(registration)); },
+    };
+}
+exports.RELAY_POLL_INTERVAL_MS = 30_000;
+exports.RELAY_MAX_BACKOFF_MS = 5 * 60_000;
+exports.RELAY_MAX_PER_TICK = 20;
+function errorText(error) {
+    /* v8 ignore next -- the relay client and the vault only throw Error instances @preserve */
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Make sure this agent holds a registration on the configured relay, registering when there is none, when the relay
+ * URL changed, or when the operator supplied an invite token. Returns the registration to poll, or null.
+ */
+async function ensureRelayRegistration(input) {
+    const config = await input.config.read();
+    const url = config.url;
+    const current = config.registration;
+    if (!url)
+        return null;
+    if (current && current.relayUrl === url && !config.inviteToken)
+        return current;
+    const handle = config.pendingRegistration?.relayUrl === url
+        ? config.pendingRegistration.handle
+        : current?.relayUrl === url ? current.handle : (0, node_crypto_1.randomBytes)(16).toString("hex");
+    try {
+        await input.config.write({ pendingRegistration: { relayUrl: url, handle } });
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "channels", event: "channel.a2a_relay_config_write_failed", message: "could not record the pending relay registration; a retry may pick a new handle", meta: { handle, error: errorText(error) } });
+    }
+    let grant;
+    try {
+        grant = await (0, relay_client_1.relayRegister)({ url, handle, did: input.did, agentCard: { name: input.agentName, did: input.did }, inviteToken: config.inviteToken, fetchImpl: input.fetchImpl });
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "channels", event: "channel.a2a_relay_register_failed", message: "relay registration failed; offline messages wait until it succeeds", meta: { relayUrl: url, error: errorText(error) } });
+        // Keep using a registration that still exists (the old relay, or the same relay before a rotation).
+        return current ?? null;
+    }
+    const registration = { relayUrl: url, handle, inboxAuth: grant.inboxAuth, sendCredential: grant.sendCredential };
+    const moved = current !== undefined && current.relayUrl !== url;
+    try {
+        // Re-read so an invite token the operator set meanwhile survives. A move never waits for older relays: each one
+        // moved away from joins the list and is retired on its own.
+        const latest = await input.config.read();
+        await input.config.write({
+            registration,
+            pendingRegistration: undefined,
+            ...(latest.inviteToken !== undefined && latest.inviteToken === config.inviteToken ? { inviteToken: undefined } : {}),
+            ...(moved ? { previousRegistrations: [...(latest.previousRegistrations ?? []).filter((r) => !sameRegistration(r, current)), current] } : {}),
+        });
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "channels", event: "channel.a2a_relay_config_write_failed", message: "registered at the relay but could not save the credentials; they last only until this process stops", meta: { relayUrl: url, handle, error: errorText(error) } });
+    }
+    return registration;
+}
+/** The single DataPart of a queued message, rebuilt into a fresh message so nothing else the relay added survives. */
+function rebuildRelayedMessage(queued) {
+    const raw = queued;
+    if (!raw || typeof raw !== "object" || typeof raw.messageId !== "string" || !Array.isArray(raw.parts) || raw.parts.length !== 1)
+        return null;
+    const part = raw.parts[0];
+    if (!part || part.kind !== "data" || !part.data || typeof part.data !== "object")
+        return null;
+    const nonce = part.data.sealed?.n;
+    return {
+        message: { kind: "message", role: "agent", messageId: raw.messageId, parts: [{ kind: "data", data: part.data }] },
+        ...(typeof nonce === "string" ? { nonce } : {}),
+    };
+}
+/**
+ * Pull up to `RELAY_MAX_PER_TICK` queued messages and run each through `handle`, one at a time. A message is acked
+ * once handled or refused for good; it stays queued after a retryable refusal, and after a throw that came before
+ * friends verified it (its seal nonce is not in the seen ledger). A throw ends the pass and asks for back-off.
+ */
+async function drainRelayInbox(input) {
+    const { registration } = input;
+    const call = { url: registration.relayUrl, handle: registration.handle, inboxAuth: registration.inboxAuth, fetchImpl: input.fetchImpl };
+    let queued;
+    try {
+        queued = await (0, relay_client_1.relayPull)(call);
+    }
+    catch (error) {
+        if (error instanceof relay_client_1.RelayHttpError && error.status === 401) {
+            (0, runtime_1.emitNervesEvent)({ level: "error", component: "channels", event: "channel.a2a_relay_unauthorized", message: "the relay no longer accepts this agent's inbox credential; polling stopped. To register again, set a new a2a.relay.inviteToken and restart the A2A sense", meta: { relayUrl: registration.relayUrl } });
+            return "stop";
+        }
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "channels", event: "channel.a2a_relay_pull_failed", message: "could not pull the relay inbox", meta: { relayUrl: registration.relayUrl, error: errorText(error) } });
+        return "backoff";
+    }
+    try {
+        return await deliverQueued(call, queued, input);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "channels", event: "channel.a2a_relay_ack_failed", message: "could not ack a relayed message; it may be delivered again and is then refused as a replay", meta: { relayUrl: registration.relayUrl, error: errorText(error) } });
+        return "backoff";
+    }
+}
+/** Run up to `RELAY_MAX_PER_TICK` pulled messages through `handle`, acking each one done. A failed ack throws. */
+async function deliverQueued(call, queued, input) {
+    for (const item of queued.slice(0, exports.RELAY_MAX_PER_TICK)) {
+        const rebuilt = rebuildRelayedMessage(item.message);
+        if (!rebuilt) {
+            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "channels", event: "channel.a2a_relay_message_dropped", message: "dropped a relayed message that is not a single sealed data part", meta: { queueId: item.queueId } });
+            await (0, relay_client_1.relayAck)({ ...call, queueId: item.queueId });
+            continue;
+        }
+        let response;
+        try {
+            response = await input.handle({ jsonrpc: "2.0", id: item.queueId, method: "message/send", params: { message: rebuilt.message } });
+        }
+        catch (error) {
+            const verified = rebuilt.nonce !== undefined && input.seen(rebuilt.nonce);
+            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "channels", event: "channel.a2a_relay_message_failed", message: verified ? "a relayed message failed after it was verified; it cannot run again, so it is acked" : "a relayed message failed before it was verified; it stays queued", meta: { queueId: item.queueId, error: errorText(error) } });
+            if (verified)
+                await (0, relay_client_1.relayAck)({ ...call, queueId: item.queueId });
+            return "backoff";
+        }
+        const refusal = "error" in response ? response.error.message : undefined;
+        // A receive refusal that can pass on a later try (refusals.ts marks it retry: a copy being handled right now) stays
+        // queued. Any other answer is final and is acked, including errors that merely carry `retry` (a delegated-command
+        // refusal is already marked seen, so a retry could only come back as a replay).
+        if ("error" in response && (0, refusals_1.isRetryableReceiveRefusal)(response.error.data)) {
+            (0, runtime_1.emitNervesEvent)({ component: "channels", event: "channel.a2a_relay_message_deferred", message: "a relayed message was refused for now; it stays queued", meta: { queueId: item.queueId, refusal } });
+            continue;
+        }
+        await (0, relay_client_1.relayAck)({ ...call, queueId: item.queueId });
+        (0, runtime_1.emitNervesEvent)({ component: "channels", event: "channel.a2a_relay_message_delivered", message: refusal ? "a relayed message was refused and acked" : "delivered a relayed message", meta: { queueId: item.queueId, ...(refusal ? { refusal } : {}) } });
+    }
+    return "ok";
+}
+/** The relay itself (its own JSON error) says it does not know this registration: it was deregistered or lost. */
+function forgottenByRelay(error) {
+    return error instanceof relay_client_1.RelayHttpError && error.fromRelay && (error.status === 401 || error.status === 404);
+}
+function attempt(what, fn) {
+    try {
+        fn();
+        return true;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "channels", event: "channel.a2a_relay_retirement_record_failed", message: `could not ${what} the local record of a relay retirement`, meta: { error: errorText(error) } });
+        return false;
+    }
+}
+const ENVELOPE_MAX_AGE_DAYS = seen_ledger_1.MAX_ENVELOPE_AGE_MS / (24 * 60 * 60 * 1000);
+async function tellOwnerLost(previous, why, input) {
+    if (!input.notifyOwner)
+        return;
+    const noticeId = `a2a-relay-gone-${(0, node_crypto_1.createHash)("sha256").update(registrationKey(previous)).digest("hex").slice(0, 16)}`;
+    const text = `I moved to a new relay for messages that arrive while I'm offline, but ${why}, so any messages still waiting there are lost. Anyone who sent one will need to send it again; new messages reach me through the new relay or directly.`;
+    await input.notifyOwner({ noticeId, text }).catch((error) => {
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "channels", event: "channel.a2a_relay_owner_notice_failed", message: "could not tell the owner that the previous relay was gone", meta: { relayUrl: previous.relayUrl, error: errorText(error) } });
+    });
+}
+/**
+ * One previous registration at its relay: drain the old inbox until a pull comes back empty, then deregister
+ * (deregistering deletes whatever is still queued). Returns "retired" once that is done or the relay is gone, and
+ * "kept" to try again at the next start.
+ *
+ * Gone means either the relay's own JSON 401 or 404 (it no longer knows this registration), or attempts failing in any
+ * other way (refused connection, DNS, 5xx, TLS, timeout, an answer that is not the relay's) with no successful pull or
+ * deregistration for longer than `MAX_ENVELOPE_AGE_MS`: anything queued there that long could no longer be accepted
+ * anyway. A successful pull or deregistration restarts that clock. The owner is told messages were lost only when
+ * this run saw the old inbox holding messages it could not drain, or the relay stayed unreachable past the window.
+ */
+async function retireAtRelay(previous, input, retirements, now) {
+    let record = {};
+    attempt("read", () => { record = retirements.read(previous); });
+    if (record.retired)
+        return "retired";
+    const save = (next) => {
+        record = next;
+        attempt("save", () => retirements.write(previous, next));
+    };
+    const inbox = { url: previous.relayUrl, handle: previous.handle, inboxAuth: previous.inboxAuth, fetchImpl: input.fetchImpl, timeoutMs: input.relayTimeoutMs };
+    const progressed = () => { if (record.firstFailedAt !== undefined)
+        save({}); };
+    let holding = false;
+    try {
+        let queued = await (0, relay_client_1.relayPull)(inbox);
+        progressed();
+        while (queued.length > 0) {
+            holding = true;
+            if (await deliverQueued(inbox, queued, input) === "backoff")
+                return "kept";
+            const after = await (0, relay_client_1.relayPull)(inbox);
+            if (after.length >= queued.length) {
+                (0, runtime_1.emitNervesEvent)({ level: "warn", component: "channels", event: "channel.a2a_relay_previous_kept", message: "the previous relay still holds messages this agent cannot handle yet; it is kept and tried again at the next start", meta: { relayUrl: previous.relayUrl, queued: after.length } });
+                return "kept";
+            }
+            queued = after;
+        }
+        holding = false;
+        await (0, relay_client_1.relayDeregister)(inbox);
+        save({ retired: true });
+        return "retired";
+    }
+    catch (error) {
+        if (forgottenByRelay(error)) {
+            // Recorded before the owner is told, so a crash after the notice does not send it twice.
+            save({ retired: true });
+            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "channels", event: "channel.a2a_relay_previous_gone", message: "the previous relay no longer knows this agent; its registration is retired", meta: { relayUrl: previous.relayUrl, reason: error.message, lost: holding } });
+            if (holding)
+                await tellOwnerLost(previous, `my old relay (${new URL(previous.relayUrl).host}) no longer knows me`, input);
+            return "retired";
+        }
+        const firstFailedAt = record.firstFailedAt ?? now;
+        if (record.firstFailedAt === undefined)
+            save({ firstFailedAt });
+        if (now - firstFailedAt > seen_ledger_1.MAX_ENVELOPE_AGE_MS) {
+            save({ retired: true });
+            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "channels", event: "channel.a2a_relay_previous_gone", message: `the previous relay has failed every attempt for more than ${ENVELOPE_MAX_AGE_DAYS} days; its registration is retired, and anything still queued there is lost`, meta: { relayUrl: previous.relayUrl, reason: errorText(error), lost: true, firstFailedAt: new Date(firstFailedAt).toISOString() } });
+            await tellOwnerLost(previous, `my old relay (${new URL(previous.relayUrl).host}) couldn't be reached for more than ${ENVELOPE_MAX_AGE_DAYS} days`, input);
+            return "retired";
+        }
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "channels", event: "channel.a2a_relay_previous_retire_failed", message: `could not retire the registration on the previous relay this time; it is tried again at each start, and retired anyway once attempts have failed for more than ${ENVELOPE_MAX_AGE_DAYS} days in a row`, meta: { relayUrl: previous.relayUrl, error: errorText(error), firstFailedAt: new Date(firstFailedAt).toISOString() } });
+        return "kept";
+    }
+}
+/**
+ * Retire each registration on a relay the operator moved away from (see `retireAtRelay`), then remove the retired ones
+ * from the vault. Returns "pending" when that vault write failed (the records say they are retired, so the next try
+ * repeats only the write), "kept" when some registration is still waiting, "retired" when all are gone from the vault,
+ * and "none" when there were none. `finishOnly` skips the relays and repeats only the vault write. Never throws.
+ */
+async function retirePreviousRegistrations(input) {
+    const retirements = input.retirements ?? memoryRelayRetirements();
+    let previous;
+    try {
+        previous = (await input.config.read()).previousRegistrations ?? [];
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "channels", event: "channel.a2a_relay_previous_read_failed", message: "could not read the relay settings, so previous relays are not retired this time; the relay inbox keeps running, and retiring is tried again at the next start", meta: { error: errorText(error) } });
+        return "kept";
+    }
+    if (previous.length === 0)
+        return "none";
+    const now = (input.now ?? Date.now)();
+    const done = [];
+    for (const registration of previous) {
+        let finished = false;
+        if (input.finishOnly)
+            attempt("read", () => { finished = retirements.read(registration).retired === true; });
+        else
+            finished = await retireAtRelay(registration, input, retirements, now) === "retired";
+        if (finished)
+            done.push(registration);
+    }
+    if (done.length === 0)
+        return "kept";
+    try {
+        const latest = (await input.config.read()).previousRegistrations ?? [];
+        const remaining = latest.filter((registration) => !done.some((gone) => sameRegistration(gone, registration)));
+        await input.config.write({ previousRegistrations: remaining.length > 0 ? remaining : undefined });
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "channels", event: "channel.a2a_relay_previous_retire_pending", message: "a previous relay registration is retired, but removing it from the vault failed; the vault write is tried again at the next poll and at each start", meta: { relayUrls: done.map((registration) => registration.relayUrl), error: errorText(error) } });
+        return "pending";
+    }
+    for (const registration of done) {
+        attempt("remove", () => retirements.clear(registration));
+        (0, runtime_1.emitNervesEvent)({ component: "channels", event: "channel.a2a_relay_previous_retired", message: "removed the registration on a previous relay", meta: { relayUrl: registration.relayUrl } });
+    }
+    return done.length < previous.length ? "kept" : "retired";
+}
+const DEFAULT_TIMERS = {
+    set: (fn, ms) => setTimeout(fn, ms).unref(),
+    clear: (timer) => clearTimeout(timer),
+};
+/** Register (moving to a new relay when the operator set one), retire the relays moved away from, then poll every 30 s, backing off (doubling to 5 minutes) after a failure. */
+function startRelayInbox(input) {
+    const interval = input.intervalMs ?? exports.RELAY_POLL_INTERVAL_MS;
+    const timers = input.timers ?? DEFAULT_TIMERS;
+    const retirements = input.retirements ?? memoryRelayRetirements();
+    let registration = null;
+    let stopped = false;
+    let delay = interval;
+    let timer;
+    let running;
+    let retirePending = false;
+    const retire = async (finishOnly) => {
+        retirePending = await retirePreviousRegistrations({ ...input, retirements, finishOnly }) === "pending";
+    };
+    const tick = () => {
+        // One pass at a time: a manual tick during a timed pass waits for it instead of handling the same messages twice.
+        running ??= (async () => {
+            if (retirePending)
+                await retire(true);
+            if (!registration)
+                return "stop";
+            const result = await drainRelayInbox({ registration, handle: input.handle, seen: input.seen, fetchImpl: input.fetchImpl });
+            if (result === "stop")
+                registration = null;
+            return result;
+        })().finally(() => { running = undefined; });
+        return running;
+    };
+    const schedule = () => {
+        if (stopped || !registration)
+            return;
+        timer = timers.set(() => {
+            void tick().then((result) => {
+                delay = result === "backoff" ? Math.min(Math.max(delay, interval) * 2, exports.RELAY_MAX_BACKOFF_MS) : interval;
+                schedule();
+            });
+        }, delay);
+    };
+    const ready = (async () => {
+        // Register first: a move never waits for the relays before it, which are then retired, each on its own clock.
+        try {
+            registration = await ensureRelayRegistration(input);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "channels", event: "channel.a2a_relay_start_failed", message: "could not read the relay configuration; the relay inbox is off", meta: { error: errorText(error) } });
+            registration = null;
+        }
+        await retire(false);
+        if (!registration || stopped)
+            return;
+        (0, runtime_1.emitNervesEvent)({ component: "channels", event: "channel.a2a_relay_inbox_started", message: "polling the A2A relay inbox", meta: { relayUrl: registration.relayUrl, intervalMs: interval } });
+        const first = await tick();
+        delay = first === "backoff" ? interval * 2 : interval;
+        schedule();
+    })();
+    return {
+        ready,
+        registration: () => registration,
+        tick,
+        stop: () => {
+            stopped = true;
+            if (timer !== undefined)
+                timers.clear(timer);
+        },
+    };
+}

package/dist/a2a/relay-retirements.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileRelayRetirements = fileRelayRetirements;
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+function markerKey(registration) {
+    return (0, node_crypto_1.createHash)("sha256").update(`${registration.relayUrl}\n${registration.handle}`).digest("hex");
+}
+function recordFrom(value) {
+    const raw = value;
+    return {
+        ...(typeof raw?.firstFailedAt === "number" && Number.isFinite(raw.firstFailedAt) ? { firstFailedAt: raw.firstFailedAt } : {}),
+        ...(raw?.retired === true ? { retired: true } : {}),
+    };
+}
+/**
+ * The retirement record of each previous relay registration (when attempts on it first failed, and whether it is done
+ * at the relay), kept on disk under `state/a2a/relay-retired/` so it survives a restart. A record holds no
+ * credentials, only the relay URL and handle, under a name hashed from both; it is written 0600 to a temporary name and
+ * renamed into place. Records are also kept in memory, so a failed disk write still holds until the process stops.
+ */
+function fileRelayRetirements(agentRoot) {
+    const dir = path.join(agentRoot, "state", "a2a", "relay-retired");
+    const cache = new Map();
+    const file = (key) => path.join(dir, `${key}.json`);
+    return {
+        read: (registration) => {
+            const key = markerKey(registration);
+            const cached = cache.get(key);
+            if (cached)
+                return { ...cached };
+            try {
+                return recordFrom(JSON.parse(fs.readFileSync(file(key), "utf8")));
+            }
+            catch {
+                return {};
+            }
+        },
+        write: (registration, record) => {
+            const key = markerKey(registration);
+            cache.set(key, { ...record });
+            fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+            const temp = `${file(key)}.${(0, node_crypto_1.randomBytes)(6).toString("hex")}.tmp`;
+            fs.writeFileSync(temp, `${JSON.stringify({ relayUrl: registration.relayUrl, handle: registration.handle, ...record, updatedAt: new Date().toISOString() })}\n`, { mode: 0o600 });
+            fs.renameSync(temp, file(key));
+            (0, runtime_1.emitNervesEvent)({ component: "channels", event: "channel.a2a_relay_retirement_recorded", message: record.retired ? "an old relay registration is retired" : "an old relay registration is still being retired", meta: { relayUrl: registration.relayUrl, retired: record.retired === true } });
+        },
+        clear: (registration) => {
+            const key = markerKey(registration);
+            cache.delete(key);
+            fs.rmSync(file(key), { force: true });
+        },
+    };
+}

package/dist/a2a/replay-grant-holders.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REPLAY_GRANT_HOLDERS_FILE = void 0;
+exports.isReplayGrantHolder = isReplayGrantHolder;
+const runtime_1 = require("../nerves/runtime");
+const operator_trust_1 = require("./operator-trust");
+/**
+ * The friends the replay gate provisioned as replay peers, kept by the gate itself as root inside the operator trust directory
+ * (`replay-identities.json`, `{ schemaVersion: 1, grants: { <friend id>: { who, name, did } } }`). A grant for one of them must
+ * carry an expiry (and so must every grant when this file is present but cannot be trusted), so a permanent grant can never be left behind by a replay run. This list is the authority for that rule: the
+ * bundle's own replay registry and a grant's free-text source are the agent's to edit and decide nothing here.
+ */
+exports.REPLAY_GRANT_HOLDERS_FILE = "replay-identities.json";
+function validHolder(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const holder = value;
+    return typeof holder.who === "string" && typeof holder.name === "string" && typeof holder.did === "string";
+}
+/**
+ * True when a grant with no expiry for this friend must be refused. That is the case for a friend the list names, for an entry in the list
+ * that is malformed (its id is read from the file but its content is not trusted), and for every friend when the list is present but
+ * untrusted or malformed: a list the Butler cannot rely on must never let a permanent replay grant through. A list that does not exist
+ * yet (no replay gate has run) names nobody.
+ */
+function isReplayGrantHolder(agentRoot, friendId) {
+    const view = (0, operator_trust_1.readGrantFile)(agentRoot, exports.REPLAY_GRANT_HOLDERS_FILE, validHolder);
+    if (view.state === "untrusted") {
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.a2a_replay_list_untrusted", message: "the replay list is present but cannot be trusted, so no grant without an expiry is honoured", meta: { file: exports.REPLAY_GRANT_HOLDERS_FILE } });
+        return true;
+    }
+    return Object.prototype.hasOwnProperty.call(view.grants, friendId) || view.ignored.includes(friendId);
+}