@sema-agent/server 1.314.0 → 1.316.0

package/dist/plugins/workflow-run-store-sql.js

@@ -0,0 +1,299 @@
+import { summarizeWorkflowRun, isTerminalWorkflowStatus, WorkflowRunStoreError } from "@sema-agent/core";
+import { foldKeyFamily, MAX_PENDING_PER_SESSION, PURGE_FENCE_MS, SERVED_FENCE_MS, } from "../orchestration/workflow-completion-inbox.js";
+import { mysqlDriver, pgDriver } from "./sql-driver.js";
+export const MAX_RUN_BLOB_BYTES = 4 * 1024 * 1024;
+const onWarnType = (msg, meta) => void [msg, meta];
+export function slimOversizeRun(run, maxBytes) {
+    const MARK = "…[truncated: run blob exceeded the store cap]";
+    const cut = (s) => s.slice(0, 4000) + MARK;
+    const step1 = {
+        ...run,
+        ...(typeof run.result === "string" && run.result.length > 4000 ? { result: cut(run.result) } : {}),
+        ...(typeof run.error === "string" && run.error.length > 4000 ? { error: cut(run.error) } : {}),
+    };
+    let blob = JSON.stringify(step1);
+    if (Buffer.byteLength(blob) <= maxBytes)
+        return blob;
+    const step2 = { ...step1, phases: [], agents: [], groups: [], error: step1.error ? String(step1.error).slice(0, 1000) + MARK : MARK };
+    blob = JSON.stringify(step2);
+    return Buffer.byteLength(blob) <= maxBytes ? blob : null;
+}
+export class SqlWorkflowRunStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    q(tidb, pg) {
+        return this.db.dialect === "tidb" ? tidb : pg;
+    }
+    async put(id, run) {
+        const stored = { ...run, id, rev: run.rev ?? 0 };
+        try {
+            await this.db.query(this.q("INSERT INTO workflow_run (id, scope, status, run, rev, created_at, ended_at) VALUES (?,?,?,?,?,?,?)", "INSERT INTO workflow_run (id, scope, status, run, rev, created_at, ended_at) VALUES ($1,$2,$3,$4,$5,$6,$7)"), [id, run.scope, run.status, JSON.stringify(stored), stored.rev, run.createdAt, run.endedAt ?? null]);
+        }
+        catch (e) {
+            const isDupKey = this.db.dialect === "tidb" ? e.code === "ER_DUP_ENTRY" : e.code === "23505";
+            if (isDupKey) {
+                throw new WorkflowRunStoreError("workflow_run.already_exists", "workflow run id already exists");
+            }
+            throw e;
+        }
+    }
+    async get(id) {
+        const { rows } = await this.db.query(this.q("SELECT run, rev FROM workflow_run WHERE id = ?", "SELECT run, rev FROM workflow_run WHERE id = $1"), [id]);
+        const r = rows[0];
+        if (!r)
+            return null;
+        const run = JSON.parse(String(r.run));
+        run.rev = Number(r.rev);
+        return run;
+    }
+    async update(id, scope, run, expect) {
+        let blob = JSON.stringify({ ...run, id, scope });
+        if (Buffer.byteLength(blob) > MAX_RUN_BLOB_BYTES) {
+            const slim = slimOversizeRun({ ...run, id, scope }, MAX_RUN_BLOB_BYTES);
+            if (slim === null)
+                return false;
+            blob = slim;
+        }
+        const res = await this.db.query(this.q(`UPDATE workflow_run SET run = ?, rev = rev + 1, status = ?, ended_at = ? WHERE id = ? AND scope = ?${expect !== undefined ? " AND rev = ?" : ""}`, `UPDATE workflow_run SET run = $1, rev = rev + 1, status = $2, ended_at = $3 WHERE id = $4 AND scope = $5${expect !== undefined ? " AND rev = $6" : ""}`), expect !== undefined
+            ? [blob, run.status, run.endedAt ?? null, id, scope, expect.rev]
+            : [blob, run.status, run.endedAt ?? null, id, scope]);
+        return res.affected === 1;
+    }
+    async listByScope(scope, opts) {
+        const params = [scope];
+        let where;
+        let limit = "";
+        if (this.db.dialect === "tidb") {
+            where = "scope = ?";
+            if (opts?.status !== undefined) {
+                where += " AND status = ?";
+                params.push(opts.status);
+            }
+            if (opts?.session !== undefined) {
+                where += " AND JSON_UNQUOTE(JSON_EXTRACT(run, '$.originatingSessionId')) = ?";
+                params.push(opts.session);
+            }
+            if (opts?.limit !== undefined) {
+                limit = " LIMIT ?";
+                params.push(Math.max(0, opts.limit));
+            }
+        }
+        else {
+            where = "scope = $1";
+            if (opts?.status !== undefined) {
+                params.push(opts.status);
+                where += ` AND status = $${params.length}`;
+            }
+            if (opts?.session !== undefined) {
+                params.push(opts.session);
+                where += ` AND run::json->>'originatingSessionId' = $${params.length}`;
+            }
+            if (opts?.limit !== undefined) {
+                params.push(Math.max(0, opts.limit));
+                limit = ` LIMIT $${params.length}`;
+            }
+        }
+        const { rows } = await this.db.query(`SELECT run, rev FROM workflow_run WHERE ${where} ORDER BY created_at DESC, id DESC${limit}`, params);
+        return rows.map((r) => {
+            const run = JSON.parse(String(r.run));
+            run.rev = Number(r.rev);
+            return summarizeWorkflowRun(run);
+        });
+    }
+    async reapAllScopes(now, opts) {
+        const { rows } = await this.db.query("SELECT DISTINCT scope FROM workflow_run");
+        let total = 0;
+        for (const r of rows)
+            total += await this.reap(String(r.scope), now, opts);
+        return total;
+    }
+    async reap(scope, now, opts) {
+        if (opts?.maxAgeMs === undefined && opts?.keep === undefined)
+            return 0;
+        const { rows } = await this.db.query(this.q("SELECT id, status, created_at, ended_at FROM workflow_run WHERE scope = ? ORDER BY created_at DESC, id DESC", "SELECT id, status, created_at, ended_at FROM workflow_run WHERE scope = $1 ORDER BY created_at DESC, id DESC"), [scope]);
+        const terminal = rows.filter((r) => isTerminalWorkflowStatus(String(r.status)));
+        const doomed = [];
+        for (let i = 0; i < terminal.length; i++) {
+            const r = terminal[i];
+            const anchor = r.ended_at != null ? Number(r.ended_at) : Number(r.created_at);
+            const tooOld = opts.maxAgeMs !== undefined && anchor < now - opts.maxAgeMs;
+            const overKeep = opts.keep !== undefined && i >= opts.keep;
+            if (tooOld || overKeep)
+                doomed.push(String(r.id));
+        }
+        if (doomed.length === 0)
+            return 0;
+        const res = await this.db.query(this.q(`DELETE FROM workflow_run WHERE scope = ? AND id IN (${doomed.map(() => "?").join(",")})`, "DELETE FROM workflow_run WHERE scope = $1 AND id = ANY($2::text[])"), this.db.dialect === "tidb" ? [scope, ...doomed] : [scope, doomed]);
+        return res.affected;
+    }
+}
+const KIND_SERVED = "served";
+const KIND_PURGE = "purge";
+export class SqlWorkflowCompletionInbox {
+    db;
+    onWarn;
+    constructor(db, onWarn) {
+        this.db = db;
+        this.onWarn = onWarn;
+    }
+    q(tidb, pg) {
+        return this.db.dialect === "tidb" ? tidb : pg;
+    }
+    async sweepFences(now) {
+        await this.db.query(this.q("DELETE FROM workflow_inbox_fence WHERE until_ms < ?", "DELETE FROM workflow_inbox_fence WHERE until_ms < $1"), [now]);
+    }
+    async enqueue(entry) {
+        const now = Date.now();
+        await this.sweepFences(now);
+        const served = await this.db.query(this.q("SELECT 1 FROM workflow_inbox_fence WHERE session_id = ? AND kind = ? AND run_id IN (?, ?) AND until_ms >= ?", "SELECT 1 FROM workflow_inbox_fence WHERE session_id = $1 AND kind = $2 AND run_id IN ($3, $4) AND until_ms >= $5"), [entry.sessionId, KIND_SERVED, entry.runId, foldKeyFamily(entry.runId), now]);
+        if (served.rows.length > 0) {
+            this.onWarn?.("workflow_completion_enqueue_after_poll_served", { sessionId: entry.sessionId, runId: entry.runId });
+            return;
+        }
+        const purge = await this.db.query(this.q("SELECT owner, owner_known FROM workflow_inbox_fence WHERE session_id = ? AND kind = ? AND run_id = '' AND until_ms >= ?", "SELECT owner, owner_known FROM workflow_inbox_fence WHERE session_id = $1 AND kind = $2 AND run_id = '' AND until_ms >= $3"), [entry.sessionId, KIND_PURGE, now]);
+        const pf = purge.rows[0];
+        if (pf && (Number(pf.owner_known) === 0 || (pf.owner === null ? entry.owner === null : String(pf.owner) === entry.owner))) {
+            this.onWarn?.("workflow_completion_enqueue_after_purge", { sessionId: entry.sessionId, runId: entry.runId });
+            return;
+        }
+        await this.db.query(this.q("REPLACE INTO workflow_completion_inbox (session_id, run_id, owner, status, summary, enqueued_at, kind, payload) VALUES (?,?,?,?,?,?,?,?)", "INSERT INTO workflow_completion_inbox (session_id, run_id, owner, status, summary, enqueued_at, kind, payload) VALUES ($1,$2,$3,$4,$5,$6,$7,$8) " +
+            "ON CONFLICT (session_id, run_id) DO UPDATE SET seq = nextval(pg_get_serial_sequence('workflow_completion_inbox','seq')), " +
+            "owner = EXCLUDED.owner, status = EXCLUDED.status, summary = EXCLUDED.summary, enqueued_at = EXCLUDED.enqueued_at, kind = EXCLUDED.kind, payload = EXCLUDED.payload"), [entry.sessionId, entry.runId, entry.owner, entry.status, entry.summary, entry.enqueuedAt, entry.kind ?? null, entry.payload ?? null]);
+        const confirm = await this.db.query(this.q("SELECT kind, owner, owner_known FROM workflow_inbox_fence WHERE session_id = ? AND until_ms >= ? AND (run_id IN (?, ?) OR (kind = ? AND run_id = ''))", "SELECT kind, owner, owner_known FROM workflow_inbox_fence WHERE session_id = $1 AND until_ms >= $2 AND (run_id IN ($3, $4) OR (kind = $5 AND run_id = ''))"), [entry.sessionId, now, entry.runId, foldKeyFamily(entry.runId), KIND_PURGE]);
+        for (const f of confirm.rows) {
+            const isServed = String(f.kind) === KIND_SERVED;
+            const purgeFencesUs = !isServed && (Number(f.owner_known) === 0 || (f.owner === null ? entry.owner === null : String(f.owner) === entry.owner));
+            if (isServed || purgeFencesUs) {
+                await this.ack(entry.sessionId, entry.runId);
+                this.onWarn?.(isServed ? "workflow_completion_enqueue_after_poll_served" : "workflow_completion_enqueue_after_purge", {
+                    sessionId: entry.sessionId,
+                    runId: entry.runId,
+                });
+                return;
+            }
+        }
+        const over = await this.db.query(this.q("SELECT seq, run_id FROM workflow_completion_inbox WHERE session_id = ? ORDER BY seq DESC LIMIT 100000 OFFSET ?", "SELECT seq, run_id FROM workflow_completion_inbox WHERE session_id = $1 ORDER BY seq DESC OFFSET $2"), [entry.sessionId, MAX_PENDING_PER_SESSION]);
+        if (over.rows.length > 0) {
+            await this.db.query(this.q(`DELETE FROM workflow_completion_inbox WHERE session_id = ? AND seq IN (${over.rows.map(() => "?").join(",")})`, "DELETE FROM workflow_completion_inbox WHERE session_id = $1 AND seq = ANY($2::bigint[])"), this.db.dialect === "tidb" ? [entry.sessionId, ...over.rows.map((r) => r.seq)] : [entry.sessionId, over.rows.map((r) => r.seq)]);
+            for (const r of over.rows)
+                this.onWarn?.("workflow_completion_inbox_overflow", { sessionId: entry.sessionId, droppedRunId: String(r.run_id) });
+        }
+    }
+    async pending(sessionId) {
+        const { rows } = await this.db.query(this.q("SELECT i.run_id, i.owner, i.status, i.summary, i.enqueued_at, i.kind, i.payload FROM workflow_completion_inbox i " +
+            "WHERE i.session_id = ? AND NOT EXISTS (SELECT 1 FROM workflow_inbox_fence f WHERE f.session_id = i.session_id AND f.kind = ? AND f.run_id IN (i.run_id, REGEXP_REPLACE(i.run_id, '#[0-9]+$', '')) AND f.until_ms >= ?) " +
+            "ORDER BY i.seq ASC", "SELECT i.run_id, i.owner, i.status, i.summary, i.enqueued_at, i.kind, i.payload FROM workflow_completion_inbox i " +
+            "WHERE i.session_id = $1 AND NOT EXISTS (SELECT 1 FROM workflow_inbox_fence f WHERE f.session_id = i.session_id AND f.kind = $2 AND f.run_id IN (i.run_id, regexp_replace(i.run_id, '#[0-9]+$', '')) AND f.until_ms >= $3) " +
+            "ORDER BY i.seq ASC"), [sessionId, KIND_SERVED, Date.now()]);
+        return rows.map((r) => ({
+            sessionId,
+            runId: String(r.run_id),
+            owner: r.owner === null ? null : String(r.owner),
+            status: String(r.status),
+            summary: String(r.summary),
+            enqueuedAt: Number(r.enqueued_at),
+            ...(r.kind != null ? { kind: String(r.kind) } : {}),
+            ...(r.payload != null ? { payload: String(r.payload) } : {}),
+        }));
+    }
+    async ack(sessionId, runId) {
+        await this.db.query(this.q("DELETE FROM workflow_completion_inbox WHERE session_id = ? AND run_id = ?", "DELETE FROM workflow_completion_inbox WHERE session_id = $1 AND run_id = $2"), [sessionId, runId]);
+    }
+    async purge(sessionId, purgedOwner) {
+        const now = Date.now();
+        await this.sweepFences(now);
+        await this.db.query(this.q("INSERT INTO workflow_inbox_fence (session_id, kind, run_id, owner, owner_known, until_ms) VALUES (?,?,?,?,?,?) " +
+            "ON DUPLICATE KEY UPDATE owner = VALUES(owner), owner_known = VALUES(owner_known), until_ms = VALUES(until_ms)", "INSERT INTO workflow_inbox_fence (session_id, kind, run_id, owner, owner_known, until_ms) VALUES ($1,$2,'',$3,$4,$5) " +
+            "ON CONFLICT (session_id, kind, run_id) DO UPDATE SET owner = EXCLUDED.owner, owner_known = EXCLUDED.owner_known, until_ms = EXCLUDED.until_ms"), this.db.dialect === "tidb"
+            ? [sessionId, KIND_PURGE, "", purgedOwner ?? null, purgedOwner !== undefined ? 1 : 0, now + PURGE_FENCE_MS]
+            : [sessionId, KIND_PURGE, purgedOwner ?? null, purgedOwner !== undefined ? 1 : 0, now + PURGE_FENCE_MS]);
+        await this.db.query(this.q("DELETE FROM workflow_completion_inbox WHERE session_id = ?", "DELETE FROM workflow_completion_inbox WHERE session_id = $1"), [sessionId]);
+    }
+    async markTerminalServed(sessionId, runId) {
+        const now = Date.now();
+        await this.sweepFences(now);
+        await this.db.query(this.q("INSERT INTO workflow_inbox_fence (session_id, kind, run_id, owner, owner_known, until_ms) VALUES (?,?,?,NULL,0,?) " +
+            "ON DUPLICATE KEY UPDATE until_ms = VALUES(until_ms)", "INSERT INTO workflow_inbox_fence (session_id, kind, run_id, owner, owner_known, until_ms) VALUES ($1,$2,$3,NULL,0,$4) " +
+            "ON CONFLICT (session_id, kind, run_id) DO UPDATE SET until_ms = EXCLUDED.until_ms"), [sessionId, KIND_SERVED, runId, now + SERVED_FENCE_MS]);
+        await this.ack(sessionId, runId);
+        await this.db.query(this.q("DELETE FROM workflow_completion_inbox WHERE session_id = ? AND run_id <> ? AND REGEXP_REPLACE(run_id, '#[0-9]+$', '') = ?", "DELETE FROM workflow_completion_inbox WHERE session_id = $1 AND run_id <> $2 AND regexp_replace(run_id, '#[0-9]+$', '') = $3"), [sessionId, runId, runId]);
+    }
+}
+export class SqlWorkflowNotifyJournalStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    q(tidb, pg) {
+        return this.db.dialect === "tidb" ? tidb : pg;
+    }
+    async record(input) {
+        await this.db.query(this.q("INSERT IGNORE INTO workflow_notify_journal (run_id, scope, acked, source_task_id, principal, created_at) VALUES (?,?,0,?,?,?)", "INSERT INTO workflow_notify_journal (run_id, scope, acked, source_task_id, principal, created_at) VALUES ($1,$2,0,$3,$4,$5) ON CONFLICT (run_id) DO NOTHING"), [input.runId, input.scope, input.sourceTaskId ?? null, input.principal ?? null, input.createdAt]);
+    }
+    async ack(runId, ackedAt) {
+        await this.db.query(this.q("UPDATE workflow_notify_journal SET acked = 1, acked_at = ? WHERE run_id = ? AND acked = 0", "UPDATE workflow_notify_journal SET acked = 1, acked_at = $1 WHERE run_id = $2 AND acked = 0"), [ackedAt, runId]);
+    }
+    async listPending() {
+        const { rows } = await this.db.query("SELECT run_id, scope, source_task_id, principal, created_at FROM workflow_notify_journal WHERE acked = 0");
+        return rows.map((r) => ({
+            runId: String(r.run_id),
+            scope: String(r.scope),
+            acked: false,
+            ...(r.source_task_id != null ? { sourceTaskId: String(r.source_task_id) } : {}),
+            ...(r.principal != null ? { principal: String(r.principal) } : {}),
+            createdAt: Number(r.created_at),
+        }));
+    }
+    async reapAcked(before) {
+        const res = await this.db.query(this.q("DELETE FROM workflow_notify_journal WHERE acked = 1 AND acked_at < ?", "DELETE FROM workflow_notify_journal WHERE acked = 1 AND acked_at < $1"), [before]);
+        return res.affected;
+    }
+    async get(runId) {
+        const { rows } = await this.db.query(this.q("SELECT run_id, scope, acked, source_task_id, principal, created_at, acked_at FROM workflow_notify_journal WHERE run_id = ?", "SELECT run_id, scope, acked, source_task_id, principal, created_at, acked_at FROM workflow_notify_journal WHERE run_id = $1"), [runId]);
+        const r = rows[0];
+        if (!r)
+            return null;
+        return {
+            runId: String(r.run_id),
+            scope: String(r.scope),
+            acked: Number(r.acked) === 1,
+            ...(r.source_task_id != null ? { sourceTaskId: String(r.source_task_id) } : {}),
+            ...(r.principal != null ? { principal: String(r.principal) } : {}),
+            createdAt: Number(r.created_at),
+            ...(r.acked_at != null ? { ackedAt: Number(r.acked_at) } : {}),
+        };
+    }
+}
+export class TiDBWorkflowRunStore extends SqlWorkflowRunStore {
+    constructor(pool) {
+        super(mysqlDriver(pool));
+    }
+}
+export class TiDBWorkflowCompletionInbox extends SqlWorkflowCompletionInbox {
+    constructor(pool, onWarn) {
+        super(mysqlDriver(pool), onWarn);
+    }
+}
+export class TiDBWorkflowNotifyJournalStore extends SqlWorkflowNotifyJournalStore {
+    constructor(pool) {
+        super(mysqlDriver(pool));
+    }
+}
+export class PgWorkflowRunStore extends SqlWorkflowRunStore {
+    constructor(pool) {
+        super(pgDriver(pool));
+    }
+}
+export class PgWorkflowCompletionInbox extends SqlWorkflowCompletionInbox {
+    constructor(pool, onWarn) {
+        super(pgDriver(pool), onWarn);
+    }
+}
+export class PgWorkflowNotifyJournalStore extends SqlWorkflowNotifyJournalStore {
+    constructor(pool) {
+        super(pgDriver(pool));
+    }
+}
+//# sourceMappingURL=workflow-run-store-sql.js.map

package/dist/plugins/write-behind-counter.d.ts

@@ -1,4 +1,5 @@
-import type { Pool } from "mysql2/promise";
+import type { Pool as MySqlPool } from "mysql2/promise";
+import type { Pool as PgPool } from "pg";
 export interface CounterTable {
     table: string;
     keyCol: string;
@@ -13,7 +14,9 @@ export interface CounterDegradeInfo {
 }
 export type CounterDegradeHook = (info: CounterDegradeInfo) => void;
 export declare const DEFAULT_COUNTER_QUERY_TIMEOUT_MS = 30000;
-export declare class WriteBehindCounter {
+type CounterDialect = "tidb" | "pg";
+export declare class SqlWriteBehindCounter {
+    private readonly dialect;
     private readonly pool;
     private readonly t;
     private readonly windowMs;
@@ -26,7 +29,8 @@ export declare class WriteBehindCounter {
     private flushing;
     private flushStartedAt;
     private failStreak;
-    constructor(pool: Pool, t: CounterTable, windowMs: number, now?: () => number, onDegraded?: CounterDegradeHook | undefined, queryTimeoutMs?: number);
+    constructor(dialect: CounterDialect, pool: MySqlPool | PgPool, t: CounterTable, windowMs: number, now?: () => number, onDegraded?: CounterDegradeHook | undefined, queryTimeoutMs?: number);
+    private exec;
     private bump;
     bucket(): number;
     private rk;
@@ -40,4 +44,11 @@ export declare class WriteBehindCounter {
     startRefresh(intervalMs?: number): this;
     stop(): void;
 }
+export declare class WriteBehindCounter extends SqlWriteBehindCounter {
+    constructor(pool: MySqlPool, t: CounterTable, windowMs: number, now?: () => number, onDegraded?: CounterDegradeHook, queryTimeoutMs?: number);
+}
+export declare class PgWriteBehindCounter extends SqlWriteBehindCounter {
+    constructor(pool: PgPool, t: CounterTable, windowMs: number, now?: () => number, onDegraded?: CounterDegradeHook, queryTimeoutMs?: number);
+}
+export {};
 //# sourceMappingURL=write-behind-counter.d.ts.map

package/dist/plugins/write-behind-counter.js

@@ -1,6 +1,7 @@
 const SEP = "\u0000";
 export const DEFAULT_COUNTER_QUERY_TIMEOUT_MS = 30_000;
-export class WriteBehindCounter {
+export class SqlWriteBehindCounter {
+    dialect;
     pool;
     t;
     windowMs;
@@ -13,7 +14,8 @@ export class WriteBehindCounter {
     flushing = false;
     flushStartedAt = 0;
     failStreak = new Map();
-    constructor(pool, t, windowMs, now = () => Date.now(), onDegraded, queryTimeoutMs = DEFAULT_COUNTER_QUERY_TIMEOUT_MS) {
+    constructor(dialect, pool, t, windowMs, now = () => Date.now(), onDegraded, queryTimeoutMs = DEFAULT_COUNTER_QUERY_TIMEOUT_MS) {
+        this.dialect = dialect;
         this.pool = pool;
         this.t = t;
         this.windowMs = windowMs;
@@ -21,6 +23,17 @@ export class WriteBehindCounter {
         this.onDegraded = onDegraded;
         this.queryTimeoutMs = queryTimeoutMs;
     }
+    async exec(sql, params) {
+        if (this.dialect === "tidb") {
+            const [r] = (await this.pool.query({ sql, timeout: this.queryTimeoutMs }, params));
+            if (Array.isArray(r))
+                return { rows: r, affected: 0 };
+            return { rows: [], affected: Number(r?.affectedRows ?? 0) };
+        }
+        const q = { text: sql, values: params, query_timeout: this.queryTimeoutMs };
+        const res = await this.pool.query(q);
+        return { rows: (res.rows ?? []), affected: res.rowCount ?? 0 };
+    }
     bump(kind, failed, error) {
         if (!this.onDegraded)
             return;
@@ -72,6 +85,11 @@ export class WriteBehindCounter {
     }
     async flushOnce() {
         const { table, keyCol, valCol } = this.t;
+        const sql = this.dialect === "tidb"
+            ? `INSERT INTO ${table} (${keyCol}, window_bucket, ${valCol}, updated_at) VALUES (?,?,?,?) ` +
+                `ON DUPLICATE KEY UPDATE ${valCol} = ${valCol} + VALUES(${valCol}), updated_at = VALUES(updated_at)`
+            : `INSERT INTO ${table} (${keyCol}, window_bucket, ${valCol}, updated_at) VALUES ($1,$2,$3,$4) ` +
+                `ON CONFLICT (${keyCol}, window_bucket) DO UPDATE SET ${valCol} = ${table}.${valCol} + EXCLUDED.${valCol}, updated_at = EXCLUDED.updated_at`;
         let attempted = false;
         let failure;
         let hadFailure = false;
@@ -83,11 +101,7 @@ export class WriteBehindCounter {
             const windowBucket = Number(rk.slice(sep + 1));
             attempted = true;
             try {
-                await this.pool.query({
-                    sql: `INSERT INTO ${table} (${keyCol}, window_bucket, ${valCol}, updated_at) VALUES (?,?,?,?) ` +
-                        `ON DUPLICATE KEY UPDATE ${valCol} = ${valCol} + VALUES(${valCol}), updated_at = VALUES(updated_at)`,
-                    timeout: this.queryTimeoutMs,
-                }, [key, windowBucket, delta, new Date()]);
+                await this.exec(sql, [key, windowBucket, delta, new Date()]);
                 const remaining = (this.pendingDelta.get(rk) ?? 0) - delta;
                 if (remaining > 0)
                     this.pendingDelta.set(rk, remaining);
@@ -108,10 +122,11 @@ export class WriteBehindCounter {
         const { table, keyCol, valCol } = this.t;
         const b = this.bucket();
         try {
-            const [rows] = await this.pool.query({ sql: `SELECT ${keyCol}, ${valCol} FROM ${table} WHERE window_bucket = ?`, timeout: this.queryTimeoutMs }, [b]);
+            const { rows } = await this.exec(this.dialect === "tidb"
+                ? `SELECT ${keyCol}, ${valCol} FROM ${table} WHERE window_bucket = ?`
+                : `SELECT ${keyCol}, ${valCol} FROM ${table} WHERE window_bucket = $1`, [b]);
             const next = new Map();
-            for (const r of rows) {
-                const row = r;
+            for (const row of rows) {
                 next.set(`${String(row[keyCol])}${SEP}${b}`, Number(row[valCol]));
             }
             this.fleetTotal = next;
@@ -123,8 +138,10 @@ export class WriteBehindCounter {
     }
     async reap() {
         try {
-            const [res] = await this.pool.query({ sql: `DELETE FROM ${this.t.table} WHERE window_bucket < ?`, timeout: this.queryTimeoutMs }, [this.bucket()]);
-            return res.affectedRows;
+            const { affected } = await this.exec(this.dialect === "tidb"
+                ? `DELETE FROM ${this.t.table} WHERE window_bucket < ?`
+                : `DELETE FROM ${this.t.table} WHERE window_bucket < $1`, [this.bucket()]);
+            return affected;
         }
         catch {
             return 0;
@@ -141,4 +158,14 @@ export class WriteBehindCounter {
         this.timer = undefined;
     }
 }
+export class WriteBehindCounter extends SqlWriteBehindCounter {
+    constructor(pool, t, windowMs, now, onDegraded, queryTimeoutMs) {
+        super("tidb", pool, t, windowMs, now, onDegraded, queryTimeoutMs);
+    }
+}
+export class PgWriteBehindCounter extends SqlWriteBehindCounter {
+    constructor(pool, t, windowMs, now, onDegraded, queryTimeoutMs) {
+        super("pg", pool, t, windowMs, now, onDegraded, queryTimeoutMs);
+    }
+}
 //# sourceMappingURL=write-behind-counter.js.map

package/dist/principal-jwt.d.ts

@@ -0,0 +1,44 @@
+import type { ApprovalHmacKey, PrincipalJwtKey } from "./auth-keys.js";
+export declare function verifyPrincipalJwt(token: string, keys: PrincipalJwtKey[], expect: {
+    iss: string;
+    aud: string;
+    nowSec?: number;
+    skewSec?: number;
+    maxTtlSec?: number;
+}): {
+    sub: string;
+    bnd?: string;
+} | null;
+export declare function approvalBnd(env: {
+    sessionId: string;
+    boundCallId?: string | null;
+    boundInputHash?: string | null;
+}): string;
+export declare function verifyDirectDoorProof(proof: {
+    jwt?: string;
+    mac?: string;
+    kid?: string;
+}, envelope: {
+    sessionId: string;
+    boundCallId?: string | null;
+    boundInputHash?: string | null;
+    decision: string;
+    reason?: string | null;
+}, config: {
+    principalJwtPubkeys: PrincipalJwtKey[];
+    principalJwtIss?: string;
+    principalJwtAud?: string;
+    principalJwtMaxTtlSec?: number;
+    approvalHmacKeys: ApprovalHmacKey[];
+}, opts?: {
+    actionBinding?: boolean;
+}): {
+    ok: true;
+    principal: string;
+} | {
+    ok: false;
+    status: number;
+    errorCode: string;
+    error: string;
+};
+//# sourceMappingURL=principal-jwt.d.ts.map

package/dist/principal-jwt.js

@@ -0,0 +1,95 @@
+import { createHash, createPublicKey, verify as cryptoVerify } from "node:crypto";
+import { verifyApprovalHmac } from "./approval-hmac.js";
+function b64urlToBuf(s) {
+    return Buffer.from(s, "base64url");
+}
+function verifyJwsSignature(alg, signingInput, sig, pub) {
+    try {
+        if (alg === "EdDSA")
+            return cryptoVerify(null, signingInput, pub, sig);
+        if (alg === "RS256")
+            return cryptoVerify("sha256", signingInput, pub, sig);
+        if (alg === "ES256")
+            return cryptoVerify("sha256", signingInput, { key: pub, dsaEncoding: "ieee-p1363" }, sig);
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+export function verifyPrincipalJwt(token, keys, expect) {
+    if (keys.length === 0)
+        return null;
+    const parts = token.split(".");
+    if (parts.length !== 3)
+        return null;
+    const [h, p, s] = parts;
+    let header;
+    let payload;
+    let sig;
+    try {
+        header = JSON.parse(b64urlToBuf(h).toString("utf8"));
+        payload = JSON.parse(b64urlToBuf(p).toString("utf8"));
+        sig = b64urlToBuf(s);
+    }
+    catch {
+        return null;
+    }
+    if (typeof header !== "object" || header === null || typeof payload !== "object" || payload === null)
+        return null;
+    if (typeof header.alg !== "string" || typeof header.kid !== "string" || sig.length === 0)
+        return null;
+    const key = keys.find((k) => k.kid === header.kid);
+    if (!key || key.alg !== header.alg)
+        return null;
+    let pub;
+    try {
+        pub = createPublicKey(key.key);
+    }
+    catch {
+        return null;
+    }
+    const signingInput = Buffer.from(`${h}.${p}`, "utf8");
+    if (!verifyJwsSignature(key.alg, signingInput, sig, pub))
+        return null;
+    if (payload.iss !== expect.iss)
+        return null;
+    const aud = payload.aud;
+    const audOk = aud === expect.aud || (Array.isArray(aud) && aud.includes(expect.aud));
+    if (!audOk)
+        return null;
+    if (typeof payload.sub !== "string" || payload.sub.length === 0)
+        return null;
+    const now = expect.nowSec ?? Math.floor(Date.now() / 1000);
+    const skew = expect.skewSec ?? 30;
+    if (typeof payload.exp !== "number" || payload.exp + skew < now)
+        return null;
+    if (payload.nbf !== undefined && (typeof payload.nbf !== "number" || payload.nbf - skew > now))
+        return null;
+    if (expect.maxTtlSec && payload.exp - now > expect.maxTtlSec + skew)
+        return null;
+    const bnd = typeof payload.cnf?.bnd === "string" ? payload.cnf.bnd : undefined;
+    return { sub: payload.sub, bnd };
+}
+export function approvalBnd(env) {
+    return createHash("sha256").update(JSON.stringify([env.sessionId, env.boundCallId ?? null, env.boundInputHash ?? null])).digest("hex");
+}
+export function verifyDirectDoorProof(proof, envelope, config, opts) {
+    const actionBinding = opts?.actionBinding ?? true;
+    if (!proof.jwt)
+        return { ok: false, status: 401, errorCode: "principal_unverified", error: "direct door requires a signed principal token (X-Approval-Principal-Token)" };
+    const verified = verifyPrincipalJwt(proof.jwt, config.principalJwtPubkeys, { iss: config.principalJwtIss ?? "\0", aud: config.principalJwtAud ?? "\0", maxTtlSec: config.principalJwtMaxTtlSec });
+    if (!verified)
+        return { ok: false, status: 401, errorCode: "principal_unverified", error: "principal token failed verification" };
+    if (actionBinding && !envelope.boundInputHash)
+        return { ok: false, status: 400, errorCode: "approval_mac_required", error: "direct door requires boundInputHash (the bound action) in the body" };
+    if (verified.bnd !== approvalBnd(envelope))
+        return { ok: false, status: 401, errorCode: "principal_unbound", error: "principal token is not bound to this decision (cnf.bnd mismatch)" };
+    if (!proof.mac)
+        return { ok: false, status: 401, errorCode: "approval_mac_required", error: "direct door requires an approval MAC (X-Approval-Mac)" };
+    const ok = verifyApprovalHmac({ sessionId: envelope.sessionId, boundCallId: envelope.boundCallId ?? null, boundInputHash: envelope.boundInputHash ?? null, decision: envelope.decision, reason: envelope.reason ?? null }, proof.mac, proof.kid, config.approvalHmacKeys);
+    if (!ok)
+        return { ok: false, status: 401, errorCode: "approval_mac_invalid", error: "approval envelope MAC invalid" };
+    return { ok: true, principal: verified.sub };
+}
+//# sourceMappingURL=principal-jwt.js.map

package/dist/security.d.ts

@@ -3,7 +3,6 @@ import { type SessionStore, type SessionTreeEntry } from "@sema-agent/core";
 import type { ServiceConfig } from "./config-types.js";
 import type { TaskRequestBody } from "./http/wire-types.js";
 import type { StagingHandle } from "./session-sync-kernel.js";
-import type { ApprovalHmacKey, PrincipalJwtKey } from "./auth-keys.js";
 export { parseApprovalHmacKeys, parsePrincipalJwks } from "./auth-keys.js";
 export type { ApprovalHmacKey, PrincipalJwtKey } from "./auth-keys.js";
 export interface SessionListItem {
@@ -81,61 +80,6 @@ export declare function setSsoScope(req: IncomingMessage, scope: string): void;
 export declare function ssoVerifiedScope(req: IncomingMessage): string | undefined;
 export declare function verifiedPrincipal(req: IncomingMessage, config: ServiceConfig): string | undefined;
 export { memoryScopeFor, memoryEngineRemoteLanePosture, memoryEngineBackendFor, memorySpecForRequest } from "./memory-scope.js";
-export declare function approvalHmacMessage(env: {
-    sessionId: string;
-    boundCallId?: string | null;
-    boundInputHash?: string | null;
-    decision: string;
-    reason?: string | null;
-}): string;
-export declare const MAX_APPROVAL_REASON_CHARS = 4096;
-export declare function verifyApprovalHmac(env: {
-    sessionId: string;
-    boundCallId?: string | null;
-    boundInputHash?: string | null;
-    decision: string;
-    reason?: string | null;
-}, mac: string, kid: string | undefined, keys: ApprovalHmacKey[]): boolean;
-export declare function verifyPrincipalJwt(token: string, keys: PrincipalJwtKey[], expect: {
-    iss: string;
-    aud: string;
-    nowSec?: number;
-    skewSec?: number;
-    maxTtlSec?: number;
-}): {
-    sub: string;
-    bnd?: string;
-} | null;
-export declare function approvalBnd(env: {
-    sessionId: string;
-    boundCallId?: string | null;
-    boundInputHash?: string | null;
-}): string;
-export declare function verifyDirectDoorProof(proof: {
-    jwt?: string;
-    mac?: string;
-    kid?: string;
-}, envelope: {
-    sessionId: string;
-    boundCallId?: string | null;
-    boundInputHash?: string | null;
-    decision: string;
-    reason?: string | null;
-}, config: {
-    principalJwtPubkeys: PrincipalJwtKey[];
-    principalJwtIss?: string;
-    principalJwtAud?: string;
-    principalJwtMaxTtlSec?: number;
-    approvalHmacKeys: ApprovalHmacKey[];
-}, opts?: {
-    actionBinding?: boolean;
-}): {
-    ok: true;
-    principal: string;
-} | {
-    ok: false;
-    status: number;
-    errorCode: string;
-    error: string;
-};
+export { approvalHmacMessage, MAX_APPROVAL_REASON_CHARS, verifyApprovalHmac } from "./approval-hmac.js";
+export { verifyPrincipalJwt, approvalBnd, verifyDirectDoorProof } from "./principal-jwt.js";
 //# sourceMappingURL=security.d.ts.map