@jdscript/opencode-notify 0.0.0-stage → 0.1.0

package/dist/sender.js

@@ -0,0 +1,847 @@
+import { createECDH, createHash, randomUUID } from "node:crypto";
+import { basename } from "node:path";
+import { z } from "zod";
+import { Subscribe } from "./rpc.js";
+import { decode, encrypt } from "./crypto.js";
+const StoredSubscription = z.object({
+    input: Subscribe,
+    revoked: z.boolean(),
+    unavailable: z.boolean(),
+    billingUntil: z.number().optional(),
+});
+const StoredActivity = z.object({
+    subscriptionID: z.string(),
+    activityID: z.string(),
+    sessionID: z.string(),
+    expiresAt: z.number(),
+    ended: z.boolean(),
+    unavailable: z.boolean().optional(),
+    lastTimestamp: z.number(),
+    lastSent: z.number(),
+    scope: z.enum(["session", "server", "workspace"]).optional(),
+    serverName: z.string().optional(),
+});
+const StoredJob = z.object({
+    subscriptionID: z.string(),
+    body: z.object({
+        event_id: z.string(),
+        kind: z.enum(["alert", "live_activity"]),
+        ciphertext: z.string(),
+        activity_id: z.string().optional(),
+        event: z.enum(["update", "end"]).optional(),
+        timestamp: z.number().optional(),
+        settled: z.boolean().optional(),
+    }),
+    expiresAt: z.number(),
+    attempt: z.number(),
+    next: z.number(),
+});
+export class SenderError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "MobilePushError";
+    }
+}
+/** One process-wide sender, shared by the plugin's location registrations. */
+export class Sender {
+    storage;
+    getSession;
+    waitSession;
+    subscriptions = new Map();
+    activities = new Map();
+    jobs = new Map();
+    nodes = new Map();
+    shells = new Map();
+    observedShells = new Set();
+    dirty = new Map();
+    receipts = new Map();
+    cleanedAt = 0;
+    chain = Promise.resolve();
+    timer;
+    flushing = false;
+    stopped = false;
+    workspaceKnown = false;
+    quietSince;
+    waitingForIdle = new Map();
+    waitGeneration = 0;
+    abort = new AbortController();
+    constructor(storage, getSession, waitSession) {
+        this.storage = storage;
+        this.getSession = getSession;
+        this.waitSession = waitSession;
+    }
+    async start() {
+        for (const prefix of ["sub/", "activity/", "job/", "receipt/"]) {
+            let after;
+            do {
+                const page = await this.storage.scan({ prefix, after, limit: 100 });
+                for (const row of page.entries) {
+                    if (prefix === "sub/")
+                        this.subscriptions.set(row.key.slice(4), StoredSubscription.parse(row.value));
+                    if (prefix === "activity/")
+                        this.activities.set(row.key.slice(9), StoredActivity.parse(row.value));
+                    if (prefix === "job/")
+                        this.jobs.set(row.key.slice(4), StoredJob.parse(row.value));
+                    if (prefix === "receipt/")
+                        this.receipts.set(row.key.slice(8), z.number().parse(row.value));
+                }
+                after = page.next;
+            } while (after);
+        }
+        this.schedule();
+    }
+    async stop() {
+        this.stopped = true;
+        clearTimeout(this.timer);
+        this.abort.abort();
+        await this.chain;
+    }
+    status(id) {
+        const sub = this.requireSubscription(id);
+        return {
+            subscriptionID: id,
+            revision: sub.input.revision,
+            expiresAt: sub.input.expiresAt,
+            state: sub.revoked
+                ? "revoked"
+                : sub.input.expiresAt <= now()
+                    ? "expired"
+                    : sub.unavailable
+                        ? "unavailable"
+                        : "active",
+        };
+    }
+    subscribe(input) {
+        return this.serial(async () => {
+            validateSubscription(input);
+            const old = this.subscriptions.get(input.subscriptionID);
+            if (old?.revoked)
+                throw new SenderError("subscription_revoked");
+            if (old && input.revision < old.input.revision)
+                throw new SenderError("stale_revision");
+            if (old && input.revision === old.input.revision) {
+                if (JSON.stringify(input) !== JSON.stringify(old.input))
+                    throw new SenderError("revision_conflict");
+                return this.status(input.subscriptionID);
+            }
+            if (old &&
+                ["serverID", "installationID", "recipientPublicKey", "authSecret"].some((key) => input[key] !== old.input[key])) {
+                throw new SenderError("binding_changed_use_new_subscription");
+            }
+            if (!old && this.subscriptions.size >= 128)
+                throw new SenderError("subscription_limit");
+            const sub = { input, revoked: false, unavailable: false };
+            await this.save("sub/" + input.subscriptionID, sub);
+            this.subscriptions.set(input.subscriptionID, sub);
+            this.schedule();
+            return this.status(input.subscriptionID);
+        });
+    }
+    unsubscribe(id) {
+        return this.serial(async () => {
+            const sub = this.requireSubscription(id);
+            await this.save("sub/" + id, { ...sub, revoked: true });
+            sub.revoked = true;
+            for (const [key, job] of this.jobs)
+                if (job.subscriptionID === id)
+                    await this.removeJob(key);
+            return { ok: true };
+        });
+    }
+    attach(input) {
+        return this.serial(async () => {
+            this.requireSubscription(input.subscriptionID, true);
+            if (input.expiresAt <= now() || input.expiresAt > now() + 8 * 3600)
+                throw new SenderError("invalid_activity_expiry");
+            const key = routeKey(input.subscriptionID, input.activityID);
+            const old = this.activities.get(key);
+            if (old?.ended)
+                throw new SenderError("activity_ended");
+            if (old && old.sessionID !== input.sessionID)
+                throw new SenderError("activity_binding_changed");
+            if (old && (old.scope ?? "session") !== (input.scope ?? "session"))
+                throw new SenderError("activity_binding_changed");
+            if (input.scope === "server" || input.scope === "workspace") {
+                if (input.sessionID !== "ses_workspace")
+                    throw new SenderError("invalid_workspace_binding");
+                for (const seed of input.seeds ?? []) {
+                    const node = await this.node(seed.sessionID);
+                    await this.root(node);
+                    if (node.version === 0) {
+                        if (node.working === undefined || seed.running)
+                            node.working = seed.running;
+                        node.waiting = new Set(seed.waiting);
+                    }
+                    else if (node.working === undefined)
+                        node.working = seed.running;
+                    this.watchIdle(node);
+                }
+                for (const shell of input.shells ?? []) {
+                    if (shell.sessionID)
+                        await this.root(await this.node(shell.sessionID));
+                    if (!this.observedShells.has(shell.id))
+                        this.shells.set(shell.id, shell.sessionID ?? "");
+                }
+                if (input.seedComplete === true)
+                    this.workspaceKnown = true;
+            }
+            else {
+                await this.node(input.sessionID);
+            }
+            const route = {
+                subscriptionID: input.subscriptionID, activityID: input.activityID, sessionID: input.sessionID,
+                expiresAt: input.expiresAt, scope: input.scope, serverName: input.serverName,
+                ended: false,
+                unavailable: false,
+                lastTimestamp: old?.lastTimestamp ?? 0,
+                lastSent: old?.lastSent ?? 0,
+            };
+            await this.save("activity/" + key, route);
+            this.activities.set(key, route);
+            this.dirty.set(key, true);
+            await this.queueActivity(route);
+            this.schedule();
+            return { ok: true };
+        });
+    }
+    detach(subscriptionID, activityID) {
+        return this.serial(async () => {
+            this.requireSubscription(subscriptionID);
+            const key = routeKey(subscriptionID, activityID);
+            const old = this.activities.get(key);
+            const route = old
+                ? { ...old, ended: true, expiresAt: Math.max(old.expiresAt, now() + 8 * 3600) }
+                : {
+                    subscriptionID,
+                    activityID,
+                    sessionID: "",
+                    expiresAt: now() + 8 * 3600,
+                    ended: true,
+                    lastTimestamp: 0,
+                    lastSent: 0,
+                };
+            await this.save("activity/" + key, route);
+            this.activities.set(key, route);
+            await this.removeJob("activity/" + key);
+            return { ok: true };
+        });
+    }
+    /** Semantic events only: no reasoning/text deltas, transcripts, tool arguments or outputs. */
+    onEvent(event) {
+        return this.serial(async () => {
+            if (event.type === "shell.created")
+                this.observedShells.add(event.data.info.id);
+            if (event.type === "shell.exited" || event.type === "shell.deleted")
+                this.observedShells.add(event.data.id);
+            if (event.type === "shell.created" && typeof event.data.info.metadata.sessionID !== "string") {
+                this.shells.set(event.data.info.id, "");
+                for (const [key, route] of this.activities)
+                    if (isOverview(route) && !route.ended)
+                        this.dirty.set(key, false);
+                this.schedule();
+                return;
+            }
+            if ((event.type === "shell.exited" || event.type === "shell.deleted") && this.shells.get(event.data.id) === "") {
+                this.shells.delete(event.data.id);
+                for (const [key, route] of this.activities)
+                    if (isOverview(route) && !route.ended)
+                        this.dirty.set(key, false);
+                this.schedule();
+                return;
+            }
+            const id = sessionFor(event, this.shells);
+            if (!id)
+                return;
+            if (!this.nodes.has(id) && this.nodes.size >= 4096) {
+                for (const [key, cached] of this.nodes)
+                    if (!cached.working && !cached.waiting.size)
+                        this.nodes.delete(key);
+                if (this.nodes.size >= 4096) {
+                    this.workspaceKnown = false;
+                    return;
+                }
+            }
+            const node = await this.node(id);
+            node.version += 1;
+            node.activeAt = "created" in event ? Math.floor(event.created / 1000) : now();
+            switch (event.type) {
+                case "session.renamed":
+                    node.info = { ...node.info, title: event.data.title };
+                    break;
+                case "session.execution.started":
+                    node.working = true;
+                    node.outcome = undefined;
+                    node.startedAt = Math.floor(event.created / 1000);
+                    node.notified = undefined;
+                    node.detail = "Working";
+                    break;
+                case "session.execution.succeeded":
+                    node.working = false;
+                    node.outcome = "succeeded";
+                    node.waiting.clear();
+                    break;
+                case "session.execution.failed":
+                    node.working = false;
+                    node.outcome = "failed";
+                    node.waiting.clear();
+                    break;
+                case "session.execution.interrupted":
+                    node.working = event.data.reason === "shutdown" ? undefined : false;
+                    node.outcome = event.data.reason === "shutdown" ? undefined : "interrupted";
+                    node.waiting.clear();
+                    break;
+                case "session.status":
+                    node.working = event.data.status.type !== "idle";
+                    if (node.working) {
+                        node.outcome = undefined;
+                        node.detail = event.data.status.type === "retry" ? "Retrying" : "Working";
+                    }
+                    break;
+                case "permission.asked":
+                    node.waiting.add(event.data.id);
+                    break;
+                case "permission.replied":
+                    node.waiting.delete(event.data.requestID);
+                    break;
+                case "form.created":
+                    node.waiting.add(event.data.form.id);
+                    break;
+                case "form.replied":
+                case "form.cancelled":
+                    node.waiting.delete(event.data.id);
+                    break;
+                case "session.tool.called":
+                    node.working = true;
+                    node.detail = "Using tools";
+                    break;
+                case "shell.created":
+                    this.shells.set(event.data.info.id, id);
+                    break;
+                case "shell.exited":
+                case "shell.deleted":
+                    this.shells.delete(event.data.id);
+                    break;
+                case "session.deleted":
+                    node.working = false;
+                    node.outcome = "interrupted";
+                    node.waiting.clear();
+                    break;
+            }
+            const root = await this.root(node);
+            const content = this.content(root);
+            const needs = event.type === "permission.asked" || event.type === "form.created";
+            const terminal = ["complete", "failed", "stopped"].includes(content.phase);
+            const marker = `${root.startedAt ?? 0}:${content.phase}`;
+            if (needs || (terminal && root.notified !== marker)) {
+                for (const sub of this.subscriptions.values()) {
+                    if (!usable(sub))
+                        continue;
+                    if (needs
+                        ? !sub.input.preferences.requests
+                        : content.phase === "complete"
+                            ? !sub.input.preferences.completed
+                            : content.phase === "failed"
+                                ? !sub.input.preferences.failures
+                                : true)
+                        continue;
+                    const alertContent = needs
+                        ? { ...content, phase: "attention", detail: "Needs your attention" }
+                        : content;
+                    await this.queueAlert(sub, root, alertContent, event.id);
+                }
+                if (terminal)
+                    root.notified = marker;
+            }
+            // Immediate attention/end; other changing progress coalesces at most once per 5 s.
+            for (const route of this.activities.values()) {
+                if (route.ended || (!isOverview(route) && !this.within(node, route.sessionID)))
+                    continue;
+                const followed = this.nodes.get(route.sessionID);
+                const urgent = needs || (followed !== undefined && ["complete", "failed", "stopped"].includes(this.content(followed).phase));
+                const key = routeKey(route.subscriptionID, route.activityID);
+                this.dirty.set(key, this.dirty.get(key) === true || urgent);
+                if (urgent || now() - route.lastSent >= 5)
+                    await this.queueActivity(route);
+            }
+            this.schedule();
+        });
+    }
+    async node(id) {
+        const old = this.nodes.get(id);
+        if (old && now() - old.seenAt < 3)
+            return old;
+        const info = await this.getSession(id).catch(() => old?.info);
+        if (!info)
+            throw new SenderError("session_unavailable");
+        const snapshot = {
+            id: info.id,
+            parentID: info.parentID,
+            title: info.title,
+            cost: info.cost,
+            location: info.location,
+            time: info.time,
+        };
+        if (old) {
+            old.info = snapshot;
+            old.seenAt = now();
+            return old;
+        }
+        // Historical outcome alone does not prove a currently running execution has ended.
+        const value = { info: snapshot, seenAt: now(), waiting: new Set(), detail: "Awaiting activity", version: 0 };
+        this.nodes.set(id, value);
+        return value;
+    }
+    observationUnavailable() {
+        this.workspaceKnown = false;
+        this.waitingForIdle.clear();
+        this.observedShells.clear();
+        this.shells.clear();
+        for (const node of this.nodes.values()) {
+            node.version = 0;
+            node.working = undefined;
+            node.waiting.clear();
+        }
+    }
+    async root(node) {
+        const seen = new Set();
+        while (node.info.parentID && !seen.has(node.info.id) && seen.size < 32) {
+            seen.add(node.info.id);
+            node = await this.node(node.info.parentID);
+        }
+        return node;
+    }
+    within(node, rootID) {
+        if (node.info.id === rootID)
+            return true;
+        const seen = new Set();
+        let parent = node.info.parentID;
+        while (parent && !seen.has(parent) && seen.size < 32) {
+            if (parent === rootID)
+                return true;
+            seen.add(parent);
+            parent = this.nodes.get(parent)?.info.parentID;
+        }
+        return false;
+    }
+    content(root) {
+        const descendants = [...this.nodes.values()].filter((node) => node.info.id !== root.info.id && this.within(node, root.info.id));
+        const ids = new Set([root.info.id, ...descendants.map((node) => node.info.id)]);
+        const waiting = [root, ...descendants].reduce((sum, node) => sum + node.waiting.size, 0);
+        const agents = descendants.filter((node) => node.working || node.waiting.size > 0).length;
+        const shells = [...this.shells.values()].filter((id) => ids.has(id)).length;
+        const phase = waiting > 0
+            ? "attention"
+            : root.working || agents > 0 || shells > 0
+                ? "working"
+                : root.outcome === "succeeded"
+                    ? "complete"
+                    : root.outcome === "failed"
+                        ? "failed"
+                        : root.outcome === "interrupted"
+                            ? "stopped"
+                            : root.working === false
+                                ? "idle"
+                                : "offline";
+        const detail = phase === "attention"
+            ? "Needs your attention"
+            : phase === "complete"
+                ? "Completed"
+                : phase === "failed"
+                    ? "Run failed"
+                    : phase === "stopped"
+                        ? "Stopped"
+                        : phase === "offline"
+                            ? "Awaiting activity"
+                            : phase === "idle"
+                                ? "Ready"
+                                : root.working
+                                    ? root.detail
+                                    : "Background work";
+        return {
+            title: text(root.info.title ?? "OpenCode session", 240),
+            project: text(basename(root.info.location.directory), 120),
+            phase,
+            detail,
+            agents,
+            shells,
+            waiting,
+            ...(Number.isFinite(root.info.cost) ? { cost: root.info.cost } : {}),
+            ...(root.startedAt ? { startedAt: root.startedAt } : {}),
+            updatedAt: now(),
+        };
+    }
+    async queueAlert(sub, root, content, sourceID) {
+        if ((sub.billingUntil ?? 0) > now())
+            return;
+        const key = `alert/${sub.input.subscriptionID}/${sourceID}`;
+        if (this.jobs.has(key) || (this.receipts.get(key) ?? 0) > now())
+            return;
+        await this.queue(key, sub, { id: root.info.id, directory: root.info.location.directory }, content);
+    }
+    watchIdle(node) {
+        if (!this.waitSession || node.working !== true || this.waitingForIdle.has(node.info.id))
+            return;
+        const id = node.info.id, version = node.version;
+        const token = ++this.waitGeneration;
+        this.waitingForIdle.set(id, token);
+        void this.waitSession(id).then(() => this.serial(async () => {
+            if (this.waitingForIdle.get(id) !== token)
+                return;
+            this.waitingForIdle.delete(id);
+            if (this.stopped || this.nodes.get(id) !== node)
+                return;
+            if (node.version !== version) {
+                this.watchIdle(node);
+                return;
+            }
+            // Waiting for execution to become idle does not resolve an independently
+            // created form. Only request replies/cancellation or execution-end events do.
+            node.working = false;
+            node.seenAt = now();
+            node.version += 1;
+            for (const [key, route] of this.activities)
+                if (isOverview(route) && !route.ended)
+                    this.dirty.set(key, false);
+            this.schedule();
+        })).catch(() => { if (this.waitingForIdle.get(id) === token) {
+            this.waitingForIdle.delete(id);
+            this.workspaceKnown = false;
+        } });
+    }
+    workspaceContent(route) {
+        const roots = [...this.nodes.values()].filter((node) => !node.info.parentID);
+        const active = roots.map((node) => ({ node, value: this.content(node) }))
+            .filter(({ value }) => value.phase === "working" || value.phase === "attention")
+            .sort((a, b) => b.value.waiting - a.value.waiting || b.node.seenAt - a.node.seenAt);
+        const waiting = active.reduce((sum, item) => sum + item.value.waiting, 0);
+        const agents = [...this.nodes.values()].filter((node) => node.info.parentID && (node.working || node.waiting.size)).length;
+        const shells = this.shells.size;
+        if (active.length || shells || waiting || !this.workspaceKnown)
+            this.quietSince = undefined;
+        else
+            this.quietSince ??= now();
+        const phase = waiting ? "attention" : !this.workspaceKnown ? "offline" : active.length || shells ? "working" : now() - (this.quietSince ?? now()) >= 5 ? "complete" : "idle";
+        return {
+            title: phase === "complete" ? "All work finished" : "Workspace activity",
+            project: text(route.serverName ?? "Kiteyard", 120), phase,
+            detail: phase === "attention" ? "Needs your attention" : phase === "offline" ? "Awaiting updates" : phase === "complete" ? "All work finished" : phase === "idle" ? "Finishing work…" : "Working",
+            agents, shells, waiting, updatedAt: now(),
+            ...(this.workspaceKnown ? { sessionCount: active.length } : {}),
+            items: active.slice(0, 3).map(({ node, value }) => ({ id: createHash("sha256").update(node.info.id).digest("hex").slice(0, 32), title: text(node.info.title ?? "Session", 150), phase: value.phase, updatedAt: node.activeAt ?? Math.floor(node.info.time.updated / 1000) })),
+        };
+    }
+    async queueActivity(route) {
+        const sub = this.subscriptions.get(route.subscriptionID);
+        if (!sub || !usable(sub) || route.ended || route.unavailable || route.expiresAt <= now())
+            return;
+        const root = isOverview(route) ? undefined : await this.node(route.sessionID);
+        const timestamp = now();
+        if (timestamp <= route.lastTimestamp)
+            return; // coalesce same-second changes, never invent future timestamps
+        const content = root ? this.content(root) : this.workspaceContent(route);
+        const settled = ["complete", "failed", "stopped"].includes(content.phase);
+        const event = settled && route.scope !== "workspace" ? "end" : "update";
+        if (!settled && (sub.billingUntil ?? 0) > now())
+            return;
+        await this.queue("activity/" + routeKey(route.subscriptionID, route.activityID), sub, root ? { id: root.info.id, directory: root.info.location.directory } : { id: "ses_workspace", directory: "/" }, content, {
+            activityID: route.activityID,
+            event,
+            timestamp,
+        }, route.scope === "workspace" ? settled : undefined);
+        route.lastTimestamp = timestamp;
+        route.lastSent = timestamp;
+        this.dirty.delete(routeKey(route.subscriptionID, route.activityID));
+        if (isOverview(route) && content.phase === "idle")
+            this.dirty.set(routeKey(route.subscriptionID, route.activityID), false);
+        await this.save("activity/" + routeKey(route.subscriptionID, route.activityID), route);
+    }
+    async queue(key, sub, binding, content, activity, settled) {
+        if (this.jobs.size >= 512 && !this.jobs.has(key))
+            throw new SenderError("outbox_full");
+        const eventID = randomUUID();
+        const payload = {
+            version: 1,
+            subscriptionID: sub.input.subscriptionID,
+            eventID,
+            installationID: sub.input.installationID,
+            serverID: sub.input.serverID,
+            kind: activity ? "live_activity" : "alert",
+            producer: "server",
+            issuedAt: now(),
+            expiresAt: Math.min(now() + 3600, sub.input.expiresAt),
+            sessionID: binding.id,
+            directory: binding.directory,
+            content,
+            ...activity,
+        };
+        const bytes = Buffer.from(JSON.stringify(payload));
+        if (bytes.length > 2400 || Buffer.byteLength(payload.directory) > 1024)
+            throw new SenderError("content_too_large");
+        const ciphertext = encrypt(bytes, sub.input.recipientPublicKey, sub.input.authSecret);
+        const job = {
+            subscriptionID: sub.input.subscriptionID,
+            expiresAt: payload.expiresAt,
+            attempt: 0,
+            next: now(),
+            body: {
+                event_id: eventID,
+                kind: payload.kind,
+                ciphertext,
+                ...(activity ? { activity_id: activity.activityID, event: activity.event, timestamp: activity.timestamp } : {}),
+                ...(settled === undefined ? {} : { settled }),
+            },
+        };
+        await this.save("job/" + key, job);
+        this.jobs.set(key, job);
+    }
+    schedule() {
+        if (this.stopped || this.timer)
+            return;
+        if (![...this.jobs.values()].some((job) => job.expiresAt > now() && usable(this.subscriptions.get(job.subscriptionID))) &&
+            ![...this.activities.values()].some((route) => !route.ended &&
+                !route.unavailable &&
+                route.expiresAt > now() &&
+                usable(this.subscriptions.get(route.subscriptionID))))
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            void this.tick()
+                .catch(() => console.warn("[mobile-push] notification work failed; pending work retained"))
+                .finally(() => this.schedule());
+        }, 1000);
+        this.timer.unref?.();
+    }
+    async tick() {
+        if (this.flushing || this.stopped)
+            return;
+        this.flushing = true;
+        try {
+            await this.serial(async () => {
+                if (now() - this.cleanedAt >= 60) {
+                    this.cleanedAt = now();
+                    for (const [key, expiresAt] of this.receipts)
+                        if (expiresAt <= now()) {
+                            await this.storage.remove("receipt/" + key);
+                            this.receipts.delete(key);
+                        }
+                    const followed = new Set([...this.activities.values()].filter((route) => !route.ended).map((route) => route.sessionID));
+                    for (const [id, node] of this.nodes) {
+                        if (!node.working &&
+                            node.waiting.size === 0 &&
+                            !followed.has(id) &&
+                            (now() - node.seenAt > 3600 || this.nodes.size > 2048))
+                            this.nodes.delete(id);
+                    }
+                }
+                for (const [key, route] of this.activities) {
+                    if (route.expiresAt <= now()) {
+                        await this.storage.remove("activity/" + key);
+                        this.activities.delete(key);
+                        this.dirty.delete(key);
+                        continue;
+                    }
+                    if (!route.ended &&
+                        !route.unavailable &&
+                        (this.dirty.get(key) === true ||
+                            (this.dirty.has(key) && now() - route.lastSent >= 5) ||
+                            now() - route.lastSent >= 30))
+                        await this.queueActivity(route);
+                }
+            });
+            for (const [key, job] of [...this.jobs]) {
+                if (this.stopped)
+                    return;
+                if (this.jobs.get(key)?.body.event_id !== job.body.event_id)
+                    continue;
+                const sub = this.subscriptions.get(job.subscriptionID);
+                if ((this.receipts.get(key) ?? 0) > now()) {
+                    await this.serial(() => this.removeJobIfCurrent(key, job));
+                    continue;
+                }
+                if (!sub || sub.revoked || job.expiresAt <= now() || job.attempt >= 12) {
+                    await this.serial(() => this.removeJobIfCurrent(key, job));
+                    continue;
+                }
+                if (!usable(sub) || job.next > now())
+                    continue;
+                const result = await transmit(sub.input, job, this.abort.signal);
+                await this.serial(async () => {
+                    if (this.jobs.get(key)?.body.event_id !== job.body.event_id)
+                        return;
+                    if (result === "accepted") {
+                        if (job.body.kind === "alert") {
+                            const expiry = now() + 86400;
+                            await this.storage.set("receipt/" + key, expiry);
+                            this.receipts.set(key, expiry);
+                        }
+                        if (job.body.event === "end" && job.body.activity_id) {
+                            const route = this.activities.get(routeKey(job.subscriptionID, job.body.activity_id));
+                            if (route) {
+                                route.ended = true;
+                                route.expiresAt = Math.max(route.expiresAt, now() + 8 * 3600);
+                                await this.save("activity/" + routeKey(route.subscriptionID, route.activityID), route);
+                            }
+                        }
+                        await this.removeJob(key);
+                        return;
+                    }
+                    if (result === "credential") {
+                        // A response for an old credential must not disable a newer enrollment.
+                        if (this.subscriptions.get(job.subscriptionID)?.input.revision === sub.input.revision) {
+                            sub.unavailable = true;
+                            await this.save("sub/" + job.subscriptionID, sub);
+                        }
+                        return;
+                    }
+                    if (result === "billing") {
+                        if (this.subscriptions.get(job.subscriptionID)?.input.revision === sub.input.revision) {
+                            sub.billingUntil = now() + 60;
+                            await this.save("sub/" + job.subscriptionID, sub);
+                        }
+                        await this.removeJob(key);
+                        return;
+                    }
+                    if (result === "permanent") {
+                        if (job.body.activity_id) {
+                            const route = this.activities.get(routeKey(job.subscriptionID, job.body.activity_id));
+                            if (route) {
+                                route.unavailable = true;
+                                await this.save("activity/" + routeKey(route.subscriptionID, route.activityID), route);
+                            }
+                        }
+                        await this.removeJob(key);
+                        return;
+                    }
+                    job.attempt += 1;
+                    job.next = now() + result;
+                    await this.save("job/" + key, job);
+                });
+            }
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+    requireSubscription(id, enabled = false) {
+        const sub = this.subscriptions.get(id);
+        if (!sub)
+            throw new SenderError("subscription_not_found");
+        if (enabled && !usable(sub))
+            throw new SenderError("subscription_unavailable");
+        return sub;
+    }
+    serial(fn) {
+        const result = this.chain.then(fn);
+        this.chain = result.catch(() => undefined);
+        return result;
+    }
+    save(key, value) {
+        return this.storage.set(key, z.json().parse(JSON.parse(JSON.stringify(value))));
+    }
+    async removeJob(key) {
+        await this.storage.remove("job/" + key);
+        this.jobs.delete(key);
+    }
+    async removeJobIfCurrent(key, job) {
+        if (this.jobs.get(key)?.body.event_id === job.body.event_id)
+            await this.removeJob(key);
+    }
+}
+function now() {
+    return Math.floor(Date.now() / 1000);
+}
+function routeKey(subscriptionID, activityID) {
+    return `${subscriptionID}/${activityID}`;
+}
+function usable(sub) {
+    return !!sub && !sub.revoked && !sub.unavailable && sub.input.expiresAt > now();
+}
+function validateSubscription(input) {
+    const url = new URL(input.relayURL);
+    if (url.username ||
+        url.password ||
+        url.search ||
+        url.hash ||
+        url.pathname !== "/" ||
+        !(url.protocol === "https:" ||
+            (url.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname))))
+        throw new SenderError("invalid_relay_origin");
+    if (input.expiresAt <= now() || input.expiresAt > now() + 90 * 86400)
+        throw new SenderError("invalid_expiry");
+    try {
+        const recipient = decode(input.recipientPublicKey, 65);
+        if (recipient[0] !== 4)
+            throw new Error("invalid key");
+        const probe = createECDH("prime256v1");
+        probe.generateKeys();
+        probe.computeSecret(recipient);
+        decode(input.authSecret, 16);
+    }
+    catch {
+        throw new SenderError("invalid_encryption_parameters");
+    }
+}
+function isOverview(route) { return route.scope === "server" || route.scope === "workspace"; }
+function sessionFor(event, shells) {
+    switch (event.type) {
+        case "session.created":
+        case "session.renamed":
+        case "session.deleted":
+        case "session.execution.started":
+        case "session.execution.succeeded":
+        case "session.execution.failed":
+        case "session.execution.interrupted":
+        case "session.status":
+        case "session.tool.called":
+        case "permission.asked":
+        case "permission.replied":
+            return event.data.sessionID;
+        case "form.created":
+            return event.data.form.sessionID.startsWith("ses") ? event.data.form.sessionID : undefined;
+        case "form.replied":
+        case "form.cancelled":
+            return event.data.sessionID.startsWith("ses") ? event.data.sessionID : undefined;
+        case "shell.created":
+            return typeof event.data.info.metadata.sessionID === "string" ? event.data.info.metadata.sessionID : undefined;
+        case "shell.exited":
+        case "shell.deleted":
+            return shells.get(event.data.id);
+        default:
+            return undefined;
+    }
+}
+function text(value, budget) {
+    let size = 0;
+    return Array.from(value)
+        .filter((character) => {
+        size += Buffer.byteLength(character);
+        return size <= budget;
+    })
+        .join("");
+}
+async function transmit(sub, job, signal) {
+    try {
+        const response = await fetch(new URL("/v1/push", sub.relayURL), {
+            method: "POST",
+            headers: { Authorization: `Bearer ${sub.sendToken}`, "Content-Type": "application/json" },
+            body: JSON.stringify(job.body),
+            redirect: "error",
+            signal: AbortSignal.any([signal, AbortSignal.timeout(15_000)]),
+        });
+        await response.body?.cancel();
+        if (response.status === 202)
+            return "accepted";
+        if (response.status === 402)
+            return "billing";
+        if (response.status === 401 || (response.status === 410 && job.body.kind === "alert"))
+            return "credential";
+        if ([400, 403, 404, 410, 413].includes(response.status))
+            return "permanent";
+        return Math.max(1, Math.min(300, Number(response.headers.get("retry-after")) || 2 ** Math.min(job.attempt + 1, 7)));
+    }
+    catch {
+        return Math.min(120, 2 ** Math.min(job.attempt + 1, 7));
+    }
+}