@relaymessenger/openclaw-plugin 0.3.4 → 0.4.0-staging.1

package/dist/src/outbound.js

@@ -1,119 +1,56 @@
-// Durable outbound sends: every logical send carries an
-// Idempotency-Key; internal retries and unknown-send reconciliation replay
-// the same key, so a retry can never duplicate a visible message
-// (server contract: commitMessage.ts idempotent replay).
-import { createHash } from "node:crypto";
-import { RelayApiError } from "./client.js";
-/**
- * Per-part text ceiling declared to core's renderer so long agent replies are
- * split into multiple messages instead of truncated. Server caps a text part at 8 KiB UTF-8
- * (server/src/domain/commitMessage.ts MAX_TEXT_BYTES); 2000 chars is safe for
- * any UTF-8 content (4 bytes/char worst case).
- */
-export const RELAY_TEXT_CHUNK_LIMIT = 2_000;
-const IDEMPOTENCY_KEY_MAX = 255;
-/**
- * Idempotency key for one logical send. When core supplies a durable delivery
- * queue id, the key is a stable function of (queueId, part) so internal
- * retries and reconciliation replay the exact same key. Without a queue id a
- * fresh key is minted: identical intentional sends must remain distinct.
- *
- * The part term names WHICH piece of one delivery this is. Core supplies
- * `deliveryPartIndex` from 2026.7.2-beta.5 onward and that is authoritative.
- * Older cores do not: they call `enqueueDelivery` once, mint ONE queue id, and
- * then hand the channel each chunk of a long reply under it. Defaulting the
- * missing index to 0 would key every chunk to `...:0`, so the server would
- * replay the first chunk for each of the rest and the person would receive a
- * long answer truncated to its opening chunk with no error anywhere.
- *
- * So when core cannot say which part this is, the part term is a digest of the
- * part's own text. Sibling chunks differ, so each commits; a retry reproduces
- * the same text, so it replays. This is not the content-in-the-key mistake
- * that defeats conflict detection: the digest stands in FOR the position core
- * did not give us, it does not replace it. Two byte-identical chunks in one
- * delivery do collapse to one message, which is the residual cost of an
- * unindexed core and is bounded to a repeat the reader would see twice.
- */
+import { createHash, randomUUID } from "node:crypto";
+import { Relay, RelayAPIError, } from "@relaymessenger/sdk";
+export const RELAY_TEXT_CHUNK_LIMIT = 10_000;
+const IDEMPOTENCY_KEY_MAX_LENGTH = 255;
+export function createRelaySdkClient(account) {
+    return new Relay({
+        apiKey: account.token,
+        baseURL: account.baseUrl,
+    });
+}
 export function deriveRelayIdempotencyKey(params) {
     const queueId = params.deliveryQueueId?.trim();
-    const part = params.deliveryPartIndex ?? (params.partText === undefined
-        ? 0
-        : `t${createHash("sha256").update(params.partText).digest("hex").slice(0, 16)}`);
-    const key = queueId
-        ? `relay-send:${queueId}:${part}`
-        : `relay-send:${(params.random ?? (() => crypto.randomUUID()))()}`;
-    // Server accepts 8-255 chars; the prefix guarantees the minimum.
-    if (key.length <= IDEMPOTENCY_KEY_MAX) {
-        return key;
-    }
-    // Preserve uniqueness when an opaque core queue id is unusually long; a
-    // simple prefix slice could erase the part index and collapse two chunks.
-    return `relay-send:h:${createHash("sha256").update(key).digest("hex")}`;
+    const raw = queueId
+        ? `relay-openclaw:${queueId}:${params.deliveryPartIndex ?? 0}`
+        : `relay-openclaw:${(params.random ?? randomUUID)()}`;
+    return raw.length <= IDEMPOTENCY_KEY_MAX_LENGTH
+        ? raw
+        : `relay-openclaw:sha256:${createHash("sha256").update(raw).digest("hex")}`;
 }
 export async function sendRelayText(params) {
-    let lastError;
-    for (let attempt = 0; attempt < 3; attempt += 1) {
-        try {
-            const result = await params.client.sendMessage({
-                conversationId: params.conversationId,
-                parts: [{ type: "text", text: params.text }],
-                ...(params.replyToId ? { replyTo: { message_id: params.replyToId } } : {}),
-                ...(params.invocationId ? { invocationId: params.invocationId } : {}),
-                idempotencyKey: params.idempotencyKey,
-                ...(params.signal ? { signal: params.signal } : {}),
-            });
-            const first = result.messages[0];
-            if (!first) {
-                throw new RelayApiError("relay: 202 carried no messages", { kind: "retryable" });
-            }
-            return { messageId: first.id, messages: result.messages };
-        }
-        catch (error) {
-            lastError = error;
-            if (!(error instanceof RelayApiError) || !error.retryable || params.signal?.aborted) {
-                throw error;
-            }
-        }
-    }
-    throw lastError;
+    await params.onPlatformSendDispatch?.();
+    return await params.relay.chats.messages.send(params.chatId, {
+        message: {
+            parts: [{ type: "text", value: params.text }],
+            idempotency_key: params.idempotencyKey,
+            ...(params.replyToId
+                ? { reply_to: { message_id: params.replyToId } }
+                : {}),
+        },
+    }, params.signal ? { signal: params.signal } : undefined);
 }
-/**
- * Reconcile a send whose platform outcome is unknown: replay the POST with the
- * same idempotency key and body. By server contract the replay either performs
- * the send exactly once or returns the originally committed messages — either
- * way the visible outcome is the one set of messages the key names, never a
- * duplicate.
- */
-export async function reconcileRelayUnknownSend(params) {
-    try {
-        const result = await sendRelayText({
-            client: params.client,
-            conversationId: params.conversationId,
-            text: params.text,
-            replyToId: params.replyToId ?? null,
-            ...(params.invocationId ? { invocationId: params.invocationId } : {}),
-            idempotencyKey: params.idempotencyKey,
-        });
-        return { status: "sent", messageId: result.messageId, messages: result.messages };
+export function classifyUnknownRelaySend(error) {
+    if (!(error instanceof RelayAPIError)) {
+        return {
+            status: "unresolved",
+            error: error instanceof Error ? error.message : String(error),
+            retryable: true,
+        };
+    }
+    if (error.retryable) {
+        return {
+            status: "unresolved",
+            error: error.message,
+            retryable: true,
+        };
     }
-    catch (error) {
-        if (error instanceof RelayApiError) {
-            if (error.kind === "conflict") {
-                // Key already used with a different request body: the original send
-                // reached the server but we cannot recover its receipt. Do not retry —
-                // a retry with a fresh key would duplicate the visible message.
-                return { status: "unresolved", error: error.message, retryable: false };
-            }
-            if (error.retryable) {
-                return { status: "unresolved", error: error.message, retryable: true };
-            }
-            if (error.kind === "auth") {
-                return { status: "unresolved", error: error.message, retryable: false };
-            }
-            // Deterministic rejection (403/404/422): the original request would have
-            // been rejected identically, so nothing reached the conversation.
-            return { status: "not_sent" };
-        }
-        return { status: "unresolved", error: String(error), retryable: true };
+    if (error.status === 409) {
+        return {
+            status: "unresolved",
+            error: error.message,
+            retryable: false,
+        };
     }
+    return { status: "not_sent" };
 }
+//# sourceMappingURL=outbound.js.map

package/dist/src/runtime.js

@@ -1,8 +1,7 @@
-// Injected plugin runtime store (qa-channel pattern): defineChannelPluginEntry
-// calls setRelayRuntime, and gateway/inbound code reads it lazily.
-import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
+import { createPluginRuntimeStore, } from "openclaw/plugin-sdk/runtime-store";
 const { setRuntime: setRelayRuntime, getRuntime: getRelayRuntime } = createPluginRuntimeStore({
     pluginId: "relay",
     errorMessage: "Relay runtime not initialized",
 });
 export { getRelayRuntime, setRelayRuntime };
+//# sourceMappingURL=runtime.js.map

package/dist/src/state.js

@@ -0,0 +1,492 @@
+import { createHash, randomUUID } from "node:crypto";
+import { chmodSync, mkdirSync, } from "node:fs";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+const databases = new Map();
+function ensurePrivateDirectory(path) {
+    mkdirSync(path, { recursive: true, mode: 0o700 });
+    try {
+        chmodSync(path, 0o700);
+    }
+    catch {
+        // Windows does not implement POSIX modes completely.
+    }
+}
+function openDatabase(path) {
+    const existing = databases.get(path);
+    if (existing)
+        return existing;
+    const db = new DatabaseSync(path);
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA synchronous = FULL");
+    db.exec("PRAGMA busy_timeout = 30000");
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS relay_ingress (
+      event_id TEXT PRIMARY KEY,
+      status TEXT NOT NULL CHECK (status IN ('pending','claimed','completed','failed')),
+      payload_json TEXT NOT NULL,
+      metadata_json TEXT,
+      lane_key TEXT,
+      received_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      attempts INTEGER NOT NULL DEFAULT 0,
+      last_attempt_at INTEGER,
+      last_error TEXT,
+      claim_token TEXT,
+      claim_owner TEXT,
+      claimed_at INTEGER,
+      completed_at INTEGER,
+      completed_metadata_json TEXT,
+      failed_at INTEGER,
+      failed_reason TEXT
+    );
+    CREATE INDEX IF NOT EXISTS relay_ingress_pending_order
+      ON relay_ingress(status, received_at, event_id);
+    CREATE INDEX IF NOT EXISTS relay_ingress_claimed_order
+      ON relay_ingress(status, claimed_at, event_id);
+    CREATE TABLE IF NOT EXISTS relay_snapshot (
+      singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+      snapshot_json TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+  `);
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        // Windows does not implement POSIX modes completely.
+    }
+    databases.set(path, db);
+    return db;
+}
+function transaction(db, operation) {
+    db.exec("BEGIN IMMEDIATE");
+    try {
+        const value = operation();
+        db.exec("COMMIT");
+        return value;
+    }
+    catch (error) {
+        try {
+            db.exec("ROLLBACK");
+        }
+        catch {
+            // Preserve the operation error.
+        }
+        throw error;
+    }
+}
+function parseJson(value) {
+    if (value === null)
+        return undefined;
+    return JSON.parse(value);
+}
+function queueRecord(row, accountId) {
+    return {
+        id: row.event_id,
+        channelId: "relay",
+        accountId,
+        queueName: JSON.stringify(["relay", accountId]),
+        payload: parseJson(row.payload_json) ?? {
+            version: 1,
+            rawEvent: "",
+        },
+        ...(row.metadata_json === null
+            ? {}
+            : { metadata: parseJson(row.metadata_json) }),
+        receivedAt: row.received_at,
+        updatedAt: row.updated_at,
+        ...(row.lane_key === null ? {} : { laneKey: row.lane_key }),
+        attempts: row.attempts,
+        ...(row.last_attempt_at === null ? {} : { lastAttemptAt: row.last_attempt_at }),
+        ...(row.last_error === null ? {} : { lastError: row.last_error }),
+    };
+}
+function claimedRecord(row, accountId) {
+    if (row.status !== "claimed" ||
+        !row.claim_token ||
+        !row.claim_owner ||
+        row.claimed_at === null) {
+        return null;
+    }
+    return {
+        ...queueRecord(row, accountId),
+        claim: {
+            token: row.claim_token,
+            ownerId: row.claim_owner,
+            claimedAt: row.claimed_at,
+        },
+    };
+}
+function completedRecord(row, accountId) {
+    return {
+        id: row.event_id,
+        channelId: "relay",
+        accountId,
+        queueName: JSON.stringify(["relay", accountId]),
+        completedAt: row.completed_at ?? row.updated_at,
+        ...(row.completed_metadata_json === null
+            ? {}
+            : { metadata: parseJson(row.completed_metadata_json) }),
+    };
+}
+function failedRecord(row, accountId) {
+    return {
+        id: row.event_id,
+        channelId: "relay",
+        accountId,
+        queueName: JSON.stringify(["relay", accountId]),
+        failedAt: row.failed_at ?? row.updated_at,
+        reason: row.failed_reason ?? "failed",
+        ...(row.last_error === null ? {} : { message: row.last_error }),
+    };
+}
+function selectRow(db, id) {
+    return db
+        .prepare("SELECT * FROM relay_ingress WHERE event_id = ?")
+        .get(id);
+}
+function claimToken(value) {
+    return typeof value === "string" ? null : value.claim.token;
+}
+function entryId(value) {
+    const id = (typeof value === "string" ? value : value.id).trim();
+    if (!id)
+        throw new Error("relay: ingress event id cannot be empty");
+    return id;
+}
+function placeholders(values) {
+    return values.map(() => "?").join(",");
+}
+function createRelayIngressQueue(db, accountId, now) {
+    const queue = {
+        enqueue: async (id, payload, options) => transaction(db, () => {
+            const eventId = entryId(id);
+            const receivedAt = options?.receivedAt ?? now();
+            const updatedAt = now();
+            const inserted = db.prepare(`
+          INSERT INTO relay_ingress (
+            event_id, status, payload_json, metadata_json, lane_key,
+            received_at, updated_at, attempts
+          ) VALUES (?, 'pending', ?, ?, ?, ?, ?, 0)
+          ON CONFLICT(event_id) DO NOTHING
+        `).run(eventId, JSON.stringify(payload), options?.metadata === undefined ? null : JSON.stringify(options.metadata), options?.laneKey ?? null, receivedAt, updatedAt);
+            const row = selectRow(db, eventId);
+            if (!row)
+                throw new Error(`relay: failed to read ingress event ${eventId}`);
+            if (Number(inserted.changes) > 0) {
+                return {
+                    kind: "accepted",
+                    duplicate: false,
+                    record: queueRecord(row, accountId),
+                };
+            }
+            if (row.status === "claimed") {
+                const record = claimedRecord(row, accountId);
+                if (!record)
+                    throw new Error(`relay: corrupt claimed ingress event ${eventId}`);
+                return { kind: "claimed", duplicate: true, record };
+            }
+            if (row.status === "completed") {
+                return {
+                    kind: "completed",
+                    duplicate: true,
+                    record: completedRecord(row, accountId),
+                };
+            }
+            if (row.status === "failed") {
+                return {
+                    kind: "failed",
+                    duplicate: true,
+                    record: failedRecord(row, accountId),
+                };
+            }
+            return {
+                kind: "pending",
+                duplicate: true,
+                record: queueRecord(row, accountId),
+            };
+        }),
+        listPending: async (options) => {
+            const order = options?.orderBy === "id"
+                ? "event_id ASC"
+                : "received_at ASC, event_id ASC";
+            const limit = options?.limit === "all"
+                ? Number.MAX_SAFE_INTEGER
+                : Math.max(1, Math.floor(options?.limit ?? 100));
+            const rows = db
+                .prepare(`SELECT * FROM relay_ingress WHERE status = 'pending' ORDER BY ${order} LIMIT ?`)
+                .all(limit);
+            return rows.map((row) => queueRecord(row, accountId));
+        },
+        listClaims: async () => {
+            const rows = db
+                .prepare(`
+          SELECT * FROM relay_ingress
+          WHERE status = 'claimed'
+          ORDER BY claimed_at ASC, received_at ASC, event_id ASC
+        `)
+                .all();
+            return rows
+                .map((row) => claimedRecord(row, accountId))
+                .filter((row) => row !== null);
+        },
+        claimNext: async (options) => {
+            if (options?.staleMs !== undefined) {
+                await queue.recoverStaleClaims({ staleMs: options.staleMs });
+            }
+            const blocked = new Set([...(options?.blockedLaneKeys ?? [])]
+                .map((value) => value.trim())
+                .filter(Boolean));
+            const candidateIds = options?.candidateIds === undefined
+                ? undefined
+                : new Set([...options.candidateIds]
+                    .map((value) => value.trim())
+                    .filter(Boolean));
+            if (candidateIds?.size === 0)
+                return null;
+            return transaction(db, () => {
+                const order = options?.orderBy === "id"
+                    ? "event_id ASC"
+                    : "received_at ASC, event_id ASC";
+                const scanLimit = Math.max(1, Math.floor(options?.scanLimit ?? 100));
+                const rows = db
+                    .prepare(`SELECT * FROM relay_ingress WHERE status = 'pending' ORDER BY ${order} LIMIT ?`)
+                    .all(scanLimit);
+                let selected;
+                for (const row of rows) {
+                    if (candidateIds && !candidateIds.has(row.event_id))
+                        continue;
+                    const record = queueRecord(row, accountId);
+                    let laneKey = record.laneKey;
+                    const derived = options?.deriveLaneKey?.(record);
+                    if (!laneKey) {
+                        laneKey = derived;
+                    }
+                    else if (derived &&
+                        derived !== laneKey &&
+                        options?.reconcileStoredLaneKey?.(record, laneKey, derived)) {
+                        laneKey = derived;
+                    }
+                    if (laneKey && blocked.has(laneKey))
+                        continue;
+                    selected = { row, ...(laneKey ? { laneKey } : {}) };
+                    break;
+                }
+                if (!selected)
+                    return null;
+                const claimedAt = now();
+                const token = randomUUID();
+                const ownerId = options?.ownerId?.trim() || String(process.pid);
+                const result = db.prepare(`
+          UPDATE relay_ingress
+          SET status = 'claimed', claim_token = ?, claim_owner = ?,
+              claimed_at = ?, updated_at = ?, lane_key = COALESCE(?, lane_key)
+          WHERE event_id = ? AND status = 'pending'
+        `).run(token, ownerId, claimedAt, claimedAt, selected.laneKey ?? null, selected.row.event_id);
+                if (Number(result.changes) === 0)
+                    return null;
+                const row = selectRow(db, selected.row.event_id);
+                return row ? claimedRecord(row, accountId) : null;
+            });
+        },
+        claim: async (id, options) => transaction(db, () => {
+            const eventId = entryId(id);
+            const claimedAt = now();
+            const token = randomUUID();
+            const ownerId = options?.ownerId?.trim() || String(process.pid);
+            const result = db.prepare(`
+          UPDATE relay_ingress
+          SET status = 'claimed', claim_token = ?, claim_owner = ?,
+              claimed_at = ?, updated_at = ?
+          WHERE event_id = ? AND status = 'pending'
+        `).run(token, ownerId, claimedAt, claimedAt, eventId);
+            if (Number(result.changes) === 0)
+                return null;
+            const row = selectRow(db, eventId);
+            return row ? claimedRecord(row, accountId) : null;
+        }),
+        refreshClaim: async (claim, options) => {
+            const refreshedAt = options?.refreshedAt ?? now();
+            const result = db.prepare(`
+        UPDATE relay_ingress
+        SET claimed_at = ?, updated_at = ?
+        WHERE event_id = ? AND status = 'claimed' AND claim_token = ?
+      `).run(refreshedAt, refreshedAt, entryId(claim), claim.claim.token);
+            return Number(result.changes) > 0;
+        },
+        complete: async (idOrClaim, options) => transaction(db, () => {
+            const id = entryId(idOrClaim);
+            const token = claimToken(idOrClaim);
+            const completedAt = options?.completedAt ?? now();
+            const where = token === null
+                ? "event_id = ? AND status = 'pending'"
+                : "event_id = ? AND status = 'claimed' AND claim_token = ?";
+            const values = token === null ? [id] : [id, token];
+            const result = db.prepare(`
+          UPDATE relay_ingress
+          SET status = 'completed', payload_json = 'null', metadata_json = NULL,
+              claim_token = NULL, claim_owner = NULL, claimed_at = NULL,
+              completed_at = ?, completed_metadata_json = ?,
+              last_attempt_at = NULL, last_error = NULL, updated_at = ?
+          WHERE ${where}
+        `).run(completedAt, options?.metadata === undefined ? null : JSON.stringify(options.metadata), completedAt, ...values);
+            if (Number(result.changes) > 0)
+                return true;
+            if (token !== null)
+                return false;
+            const inserted = db.prepare(`
+          INSERT INTO relay_ingress (
+            event_id, status, payload_json, received_at, updated_at,
+            attempts, completed_at, completed_metadata_json
+          ) VALUES (?, 'completed', 'null', ?, ?, 0, ?, ?)
+          ON CONFLICT(event_id) DO NOTHING
+        `).run(id, completedAt, completedAt, completedAt, options?.metadata === undefined ? null : JSON.stringify(options.metadata));
+            return Number(inserted.changes) > 0;
+        }),
+        release: async (idOrClaim, options) => {
+            const id = entryId(idOrClaim);
+            const token = claimToken(idOrClaim);
+            const releasedAt = options?.releasedAt ?? now();
+            const where = token === null
+                ? "event_id = ? AND status = 'pending'"
+                : "event_id = ? AND status = 'claimed' AND claim_token = ?";
+            const values = token === null ? [id] : [id, token];
+            const result = db.prepare(`
+        UPDATE relay_ingress
+        SET status = 'pending', claim_token = NULL, claim_owner = NULL,
+            claimed_at = NULL,
+            attempts = attempts + ?,
+            last_attempt_at = CASE WHEN ? = 1 THEN ? ELSE last_attempt_at END,
+            last_error = COALESCE(?, last_error), updated_at = ?
+        WHERE ${where}
+      `).run(options?.recordAttempt === false ? 0 : 1, options?.recordAttempt === false ? 0 : 1, releasedAt, options?.lastError ?? null, releasedAt, ...values);
+            return Number(result.changes) > 0;
+        },
+        fail: async (idOrClaim, options) => {
+            const id = entryId(idOrClaim);
+            const token = claimToken(idOrClaim);
+            const failedAt = options.failedAt ?? now();
+            const where = token === null
+                ? "event_id = ? AND status = 'pending'"
+                : "event_id = ? AND status = 'claimed' AND claim_token = ?";
+            const values = token === null ? [id] : [id, token];
+            const result = db.prepare(`
+        UPDATE relay_ingress
+        SET status = 'failed', claim_token = NULL, claim_owner = NULL,
+            claimed_at = NULL, failed_at = ?, failed_reason = ?,
+            last_error = ?, updated_at = ?
+        WHERE ${where}
+      `).run(failedAt, options.reason, options.message ?? null, failedAt, ...values);
+            return Number(result.changes) > 0;
+        },
+        delete: async (idOrRecord) => {
+            const id = entryId(idOrRecord);
+            const token = typeof idOrRecord === "string" || !("claim" in idOrRecord)
+                ? null
+                : idOrRecord.claim.token;
+            const result = token === null
+                ? db.prepare("DELETE FROM relay_ingress WHERE event_id = ?").run(id)
+                : db
+                    .prepare(`
+              DELETE FROM relay_ingress
+              WHERE event_id = ? AND status = 'claimed' AND claim_token = ?
+            `)
+                    .run(id, token);
+            return Number(result.changes) > 0;
+        },
+        recoverStaleClaims: async (options) => {
+            const current = options?.now ?? now();
+            const staleMs = Math.max(0, options?.staleMs ?? 5 * 60_000);
+            const cutoff = current - staleMs;
+            const claims = await queue.listClaims();
+            let recovered = 0;
+            for (const claim of claims) {
+                if (claim.claim.claimedAt > cutoff)
+                    continue;
+                if (options?.shouldRecover && !(await options.shouldRecover(claim)))
+                    continue;
+                const result = db.prepare(`
+          UPDATE relay_ingress
+          SET status = 'pending', claim_token = NULL, claim_owner = NULL,
+              claimed_at = NULL, attempts = attempts + 1,
+              last_attempt_at = ?, updated_at = ?
+          WHERE event_id = ? AND status = 'claimed' AND claim_token = ?
+            AND claimed_at <= ?
+        `).run(current, current, claim.id, claim.claim.token, cutoff);
+                recovered += Number(result.changes);
+            }
+            return recovered;
+        },
+        prune: async (options) => transaction(db, () => {
+            const current = options?.now ?? now();
+            const protectedIds = new Set(options?.protectIds ?? []);
+            let removed = 0;
+            for (const [status, ttl, maxEntries] of [
+                ["pending", options?.pendingTtlMs, options?.pendingMaxEntries],
+                ["completed", options?.completedTtlMs, options?.completedMaxEntries],
+                ["failed", options?.failedTtlMs, options?.failedMaxEntries],
+            ]) {
+                const rows = db
+                    .prepare(`
+              SELECT event_id, updated_at FROM relay_ingress
+              WHERE status = ? ORDER BY updated_at ASC, event_id ASC
+            `)
+                    .all(status);
+                const expired = ttl === undefined
+                    ? []
+                    : rows.filter((row) => row.updated_at <= current - ttl);
+                const live = rows.filter((row) => !expired.includes(row));
+                const overflow = maxEntries === undefined
+                    ? []
+                    : live.slice(0, Math.max(0, live.length - Math.max(0, maxEntries)));
+                const ids = [...new Set([...expired, ...overflow].map((row) => row.event_id))]
+                    .filter((id) => !protectedIds.has(id));
+                if (ids.length === 0)
+                    continue;
+                const result = db
+                    .prepare(`
+              DELETE FROM relay_ingress
+              WHERE status = ? AND event_id IN (${placeholders(ids)})
+            `)
+                    .run(status, ...ids);
+                removed += Number(result.changes);
+            }
+            return removed;
+        }),
+    };
+    return queue;
+}
+export function openRelayStateStore(params) {
+    const root = join(params.stateDir, "relay");
+    ensurePrivateDirectory(root);
+    const accountHash = createHash("sha256")
+        .update(params.accountId)
+        .digest("hex")
+        .slice(0, 24);
+    const path = join(root, `account-${accountHash}.sqlite`);
+    const db = openDatabase(path);
+    const now = params.now ?? Date.now;
+    return {
+        path,
+        ingressQueue: createRelayIngressQueue(db, params.accountId, now),
+        replaceSnapshot: async (snapshot) => {
+            transaction(db, () => {
+                db.prepare(`
+          INSERT INTO relay_snapshot(singleton, snapshot_json, updated_at)
+          VALUES (1, ?, ?)
+          ON CONFLICT(singleton) DO UPDATE
+          SET snapshot_json = excluded.snapshot_json,
+              updated_at = excluded.updated_at
+        `).run(JSON.stringify(snapshot), now());
+            });
+        },
+        readSnapshot: async () => {
+            const row = db
+                .prepare("SELECT snapshot_json FROM relay_snapshot WHERE singleton = 1")
+                .get();
+            return row ? parseJson(row.snapshot_json) : undefined;
+        },
+    };
+}
+//# sourceMappingURL=state.js.map

package/dist/src/types.js

@@ -1,4 +1,2 @@
-// Relay wire types plus the plugin's config and resolved-account shapes. The
-// long-poll receive contract is GET /v1/events?cursor&timeout&limit ->
-// { events, next_cursor }, cursor N acknowledges everything <= N.
 export {};
+//# sourceMappingURL=types.js.map