@sema-agent/server 1.314.0 → 1.316.0

package/dist/plugins/pg-cost-quota.js

@@ -1,151 +1,11 @@
-import { DEFAULT_COUNTER_QUERY_TIMEOUT_MS } from "./write-behind-counter.js";
-const SEP = "\u0000";
-class PgWriteBehindCounter {
-    pool;
-    windowMs;
-    now;
-    onDegraded;
-    queryTimeoutMs;
-    pendingDelta = new Map();
-    fleetTotal = new Map();
-    timer;
-    flushing = false;
-    flushStartedAt = 0;
-    failStreak = new Map();
-    constructor(pool, windowMs, now = () => Date.now(), onDegraded, queryTimeoutMs = DEFAULT_COUNTER_QUERY_TIMEOUT_MS) {
-        this.pool = pool;
-        this.windowMs = windowMs;
-        this.now = now;
-        this.onDegraded = onDegraded;
-        this.queryTimeoutMs = queryTimeoutMs;
-    }
-    bump(kind, failed, error) {
-        if (!this.onDegraded)
-            return;
-        const prev = this.failStreak.get(kind) ?? 0;
-        if (!failed && prev === 0)
-            return;
-        const next = failed ? prev + 1 : 0;
-        this.failStreak.set(kind, next);
-        try {
-            this.onDegraded({ table: "cost_quota", kind, streak: next, prevStreak: prev, ...(failed && error !== undefined ? { error: error instanceof Error ? error.message : String(error) } : {}) });
-        }
-        catch {
-        }
-    }
-    bucket() {
-        return Math.floor(this.now() / this.windowMs);
-    }
-    rk(key) {
-        return `${key}${SEP}${this.bucket()}`;
-    }
-    used(key) {
-        const rk = this.rk(key);
-        return (this.fleetTotal.get(rk) ?? 0) + (this.pendingDelta.get(rk) ?? 0);
-    }
-    addLocal(key, n) {
-        if (n <= 0)
-            return;
-        const rk = this.rk(key);
-        this.pendingDelta.set(rk, (this.pendingDelta.get(rk) ?? 0) + n);
-    }
-    retryAfterSec() {
-        return Math.ceil(((this.bucket() + 1) * this.windowMs - this.now()) / 1000);
-    }
-    async flush() {
-        if (this.flushing) {
-            if (this.now() - this.flushStartedAt > 60_000)
-                this.bump("stalled", true, "flush round stalled >60s (hung query?)");
-            return;
-        }
-        this.flushing = true;
-        this.flushStartedAt = this.now();
-        try {
-            await this.flushOnce();
-        }
-        finally {
-            this.flushing = false;
-            this.bump("stalled", false);
-        }
-    }
-    async flushOnce() {
-        let attempted = false;
-        let failure;
-        let hadFailure = false;
-        for (const [rk, delta] of [...this.pendingDelta]) {
-            if (delta <= 0)
-                continue;
-            const sep = rk.lastIndexOf(SEP);
-            const key = rk.slice(0, sep);
-            const windowBucket = Number(rk.slice(sep + 1));
-            attempted = true;
-            try {
-                const q = {
-                    text: "INSERT INTO cost_quota (scope_key, window_bucket, micro, updated_at) VALUES ($1,$2,$3,$4) " +
-                        "ON CONFLICT (scope_key, window_bucket) DO UPDATE SET micro = cost_quota.micro + EXCLUDED.micro, updated_at = EXCLUDED.updated_at",
-                    values: [key, windowBucket, delta, new Date()],
-                    query_timeout: this.queryTimeoutMs,
-                };
-                await this.pool.query(q);
-                const remaining = (this.pendingDelta.get(rk) ?? 0) - delta;
-                if (remaining > 0)
-                    this.pendingDelta.set(rk, remaining);
-                else
-                    this.pendingDelta.delete(rk);
-            }
-            catch (err) {
-                hadFailure = true;
-                failure = err;
-            }
-        }
-        if (attempted)
-            this.bump("flush", hadFailure, failure);
-        await this.refresh();
-        await this.reap();
-    }
-    async refresh() {
-        const b = this.bucket();
-        try {
-            const q = { text: "SELECT scope_key, micro FROM cost_quota WHERE window_bucket = $1", values: [b], query_timeout: this.queryTimeoutMs };
-            const res = await this.pool.query(q);
-            const next = new Map();
-            for (const r of res.rows) {
-                next.set(`${String(r.scope_key)}${SEP}${b}`, Number(r.micro));
-            }
-            this.fleetTotal = next;
-            this.bump("refresh", false);
-        }
-        catch (err) {
-            this.bump("refresh", true, err);
-        }
-    }
-    async reap() {
-        try {
-            const q = { text: "DELETE FROM cost_quota WHERE window_bucket < $1", values: [this.bucket()], query_timeout: this.queryTimeoutMs };
-            const res = await this.pool.query(q);
-            return res.rowCount ?? 0;
-        }
-        catch {
-            return 0;
-        }
-    }
-    startRefresh(intervalMs = 5_000) {
-        this.timer ??= setInterval(() => void this.flush(), intervalMs);
-        this.timer.unref?.();
-        return this;
-    }
-    stop() {
-        if (this.timer)
-            clearInterval(this.timer);
-        this.timer = undefined;
-    }
-}
+import { PgWriteBehindCounter } from "./write-behind-counter.js";
+const COST_QUOTA_TABLE = { table: "cost_quota", keyCol: "scope_key", valCol: "micro" };
 export class PgCostQuota {
     limitMicroUsd;
     counter;
     constructor(pool, limitMicroUsd, windowMs, now, onDegraded, queryTimeoutMs) {
         this.limitMicroUsd = limitMicroUsd;
-        this.counter = new PgWriteBehindCounter(pool, windowMs, now, onDegraded, queryTimeoutMs);
+        this.counter = new PgWriteBehindCounter(pool, COST_QUOTA_TABLE, windowMs, now, onDegraded, queryTimeoutMs);
     }
     check(scopeKey) {
         const used = this.counter.used(scopeKey);

package/dist/plugins/pg-file-snapshot-store.d.ts

@@ -1,28 +1,2 @@
-import { type FileSnapshotBounds, type FileSnapshotStore, type FileSnapshotResult, type ExecutionEnv } from "@sema-agent/core";
-import type { Pool } from "pg";
-import { type BlobBackend } from "./blob-backend.js";
-export declare class PgFileSnapshotStore implements FileSnapshotStore {
-    private readonly pool;
-    private readonly bounds;
-    private readonly inFlight;
-    private readonly blobs;
-    onSkippedVanished: ((count: number) => void | Promise<void>) | undefined;
-    constructor(pool: Pool, blobBackend?: BlobBackend, bounds?: FileSnapshotBounds);
-    private putBlobRow;
-    putBlob(hash: string, bytes: Uint8Array): Promise<FileSnapshotResult>;
-    snapshot(scope: string, key: string, env: ExecutionEnv, root: string, signal?: AbortSignal): Promise<FileSnapshotResult>;
-    importManifest(scope: string, key: string, manifest: Map<string, string>, srcGetBlob: (hash: string) => Promise<Uint8Array | undefined>): Promise<FileSnapshotResult>;
-    restore(scope: string, key: string, env: ExecutionEnv, root: string, signal?: AbortSignal): Promise<FileSnapshotResult>;
-    has(scope: string, key: string): Promise<boolean>;
-    listKeys(scope: string): Promise<string[]>;
-    exportManifest(scope: string, key: string): Promise<Map<string, string> | null>;
-    getBlob(hash: string): Promise<Uint8Array | undefined>;
-    hasBlobs(hashes: string[]): Promise<Set<string>>;
-    blobSizes(hashes: string[]): Promise<Map<string, number>>;
-    reap(scope: string, keepKeys: string[]): Promise<number>;
-    deleteBySession(scope: string): Promise<number>;
-    private gcOrphanBlobs;
-    sweepOrphanBlobs(): Promise<number>;
-    private tx;
-}
+export { PgFileSnapshotStore } from "./file-snapshot-store-sql.js";
 //# sourceMappingURL=pg-file-snapshot-store.d.ts.map

package/dist/plugins/pg-file-snapshot-store.js

@@ -1,191 +1,2 @@
-import { captureManifest, applyManifest, DEFAULT_SNAPSHOT_BOUNDS } from "@sema-agent/core";
-import { createHash } from "node:crypto";
-import { SqlBlobBackend, sqlBlobSizes } from "./blob-backend.js";
-export class PgFileSnapshotStore {
-    pool;
-    bounds;
-    inFlight = new Set();
-    blobs;
-    onSkippedVanished = undefined;
-    constructor(pool, blobBackend, bounds = DEFAULT_SNAPSHOT_BOUNDS) {
-        this.pool = pool;
-        this.bounds = bounds;
-        this.blobs = blobBackend ?? new SqlBlobBackend("pg", pool);
-    }
-    async putBlobRow(hash, bytes) {
-        await this.blobs.putBlob(hash, bytes);
-    }
-    async putBlob(hash, bytes) {
-        if (createHash("sha256").update(bytes).digest("hex") !== hash) {
-            return { ok: false, error: { code: "read_failed", message: `putBlob ${hash} fails content-address integrity — nothing stored` } };
-        }
-        try {
-            await this.putBlobRow(hash, bytes);
-            return { ok: true };
-        }
-        catch (err) {
-            return { ok: false, error: { code: "restore_failed", message: `putBlob ${hash} write/upload failed: ${err.message}` } };
-        }
-    }
-    async snapshot(scope, key, env, root, signal) {
-        const flightKey = `${scope} ${key}`;
-        if (this.inFlight.has(flightKey))
-            return { ok: true };
-        this.inFlight.add(flightKey);
-        try {
-            if (await this.has(scope, key))
-                return { ok: true };
-            let cap;
-            try {
-                cap = await captureManifest(env, root, this.bounds, signal, async (hash, bytes) => {
-                    await this.putBlobRow(hash, bytes);
-                });
-            }
-            catch (err) {
-                return { ok: false, error: { code: "restore_failed", message: `snapshot blob write failed: ${err.message}` } };
-            }
-            if (!cap.ok)
-                return { ok: false, error: cap.error };
-            if (cap.skippedVanished > 0 && this.onSkippedVanished) {
-                try {
-                    void Promise.resolve(this.onSkippedVanished(cap.skippedVanished)).catch(() => { });
-                }
-                catch { }
-            }
-            await this.tx(async (c) => {
-                const exists = await c.query("SELECT 1 FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2 LIMIT 1", [scope, key]);
-                if (exists.rows[0])
-                    return;
-                for (const [relPath, hash] of cap.value) {
-                    await c.query("INSERT INTO snapshot_manifest (scope, snap_key, rel_path, blob_hash) VALUES ($1,$2,$3,$4)", [scope, key, relPath, hash]);
-                }
-            });
-            return { ok: true };
-        }
-        catch (err) {
-            return { ok: false, error: { code: "restore_failed", message: `snapshot persist failed: ${err.message}` } };
-        }
-        finally {
-            this.inFlight.delete(flightKey);
-        }
-    }
-    async importManifest(scope, key, manifest, srcGetBlob) {
-        const flightKey = `${scope} ${key}`;
-        if (this.inFlight.has(flightKey))
-            return { ok: true };
-        this.inFlight.add(flightKey);
-        try {
-            if (await this.has(scope, key))
-                return { ok: true };
-            for (const hash of new Set(manifest.values())) {
-                let bytes;
-                try {
-                    bytes = await srcGetBlob(hash);
-                }
-                catch (err) {
-                    return { ok: false, error: { code: "read_failed", message: `source blob ${hash} fetch failed: ${err.message}` } };
-                }
-                if (!bytes)
-                    return { ok: false, error: { code: "read_failed", message: `missing source blob ${hash}` } };
-                if (createHash("sha256").update(bytes).digest("hex") !== hash) {
-                    return { ok: false, error: { code: "read_failed", message: `source blob ${hash} fails content-address integrity` } };
-                }
-                await this.putBlobRow(hash, bytes);
-            }
-            await this.tx(async (c) => {
-                const exists = await c.query("SELECT 1 FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2 LIMIT 1", [scope, key]);
-                if (exists.rows[0])
-                    return;
-                for (const [relPath, hash] of manifest) {
-                    await c.query("INSERT INTO snapshot_manifest (scope, snap_key, rel_path, blob_hash) VALUES ($1,$2,$3,$4)", [scope, key, relPath, hash]);
-                }
-            });
-            return { ok: true };
-        }
-        catch (err) {
-            return { ok: false, error: { code: "restore_failed", message: `import persist failed: ${err.message}` } };
-        }
-        finally {
-            this.inFlight.delete(flightKey);
-        }
-    }
-    async restore(scope, key, env, root, signal) {
-        try {
-            const r = await this.pool.query("SELECT rel_path, blob_hash FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2", [scope, key]);
-            if (r.rows.length === 0)
-                return { ok: false, error: { code: "not_found", message: `no file snapshot for ${scope}/${key}` } };
-            const manifest = new Map(r.rows.map((row) => [row.rel_path, row.blob_hash]));
-            return await applyManifest(env, root, this.bounds, signal, manifest, (hash) => this.blobs.getBlob(hash));
-        }
-        catch (err) {
-            return { ok: false, error: { code: "restore_failed", message: `restore blob read failed: ${err.message}` } };
-        }
-    }
-    async has(scope, key) {
-        const r = await this.pool.query("SELECT 1 FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2 LIMIT 1", [scope, key]);
-        return Boolean(r.rows[0]);
-    }
-    async listKeys(scope) {
-        const r = await this.pool.query("SELECT DISTINCT snap_key FROM snapshot_manifest WHERE scope = $1", [scope]);
-        return r.rows.map((row) => row.snap_key);
-    }
-    async exportManifest(scope, key) {
-        const r = await this.pool.query("SELECT rel_path, blob_hash FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2", [scope, key]);
-        if (r.rows.length === 0)
-            return null;
-        return new Map(r.rows.map((row) => [row.rel_path, row.blob_hash]));
-    }
-    async getBlob(hash) {
-        return this.blobs.getBlob(hash);
-    }
-    async hasBlobs(hashes) {
-        return this.blobs.hasBlobs(hashes);
-    }
-    async blobSizes(hashes) {
-        return sqlBlobSizes("pg", this.pool, hashes);
-    }
-    async reap(scope, keepKeys) {
-        return this.tx(async (c) => {
-            const keys = await c.query("SELECT DISTINCT snap_key FROM snapshot_manifest WHERE scope = $1", [scope]);
-            const drop = keys.rows.map((k) => k.snap_key).filter((k) => !keepKeys.includes(k));
-            for (const k of drop)
-                await c.query("DELETE FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2", [scope, k]);
-            return drop.length;
-        });
-    }
-    async deleteBySession(scope) {
-        const r = await this.pool.query("DELETE FROM snapshot_manifest WHERE scope = $1", [scope]);
-        return r.rowCount ?? 0;
-    }
-    async gcOrphanBlobs() {
-        const r = await this.pool.query("SELECT blob_hash FROM snapshot_blob WHERE blob_hash NOT IN (SELECT blob_hash FROM snapshot_manifest)").catch(() => undefined);
-        const orphans = (r?.rows ?? []).map((row) => row.blob_hash);
-        if (orphans.length === 0)
-            return 0;
-        return this.blobs.deleteBlobs(orphans);
-    }
-    async sweepOrphanBlobs() {
-        return this.gcOrphanBlobs();
-    }
-    async tx(fn) {
-        const c = await this.pool.connect();
-        try {
-            await c.query("BEGIN");
-            const out = await fn(c);
-            await c.query("COMMIT");
-            return out;
-        }
-        catch (err) {
-            try {
-                await c.query("ROLLBACK");
-            }
-            catch {
-            }
-            throw err;
-        }
-        finally {
-            c.release();
-        }
-    }
-}
+export { PgFileSnapshotStore } from "./file-snapshot-store-sql.js";
 //# sourceMappingURL=pg-file-snapshot-store.js.map

package/dist/plugins/pg-image-bake.d.ts

@@ -1,42 +1,3 @@
-import type { Pool, PoolClient } from "pg";
-import type { BakeStatus, BakeState, BakeRecord, BakeEvent, CreateBakeInput, BakeTerminal } from "./store-contracts.js";
+export { PgImageBake, PG_IMAGE_BAKE_SCHEMA, ensurePgImageBakeSchema as ensureSchema } from "./image-bake-store-sql.js";
 export type { BakeStatus, BakeState, BakeErrorCode, BakeRecord, BakeEvent, CreateBakeInput, BakeTerminal, } from "./store-contracts.js";
-export declare const PG_IMAGE_BAKE_SCHEMA: string[];
-export declare function ensureSchema(pool: Pool | PoolClient, poolName?: string): Promise<void>;
-export declare class PgImageBake {
-    private readonly pool;
-    private readonly poolName;
-    constructor(pool: Pool, poolName?: string);
-    createBake(input: CreateBakeInput): Promise<{
-        created: boolean;
-        bake: BakeRecord;
-    }>;
-    createBakeIfIdle(input: CreateBakeInput): Promise<{
-        created: boolean;
-        bake: BakeRecord | null;
-    }>;
-    getBake(bakeId: string): Promise<BakeRecord | null>;
-    getBakeByIdem(idemKey: string): Promise<BakeRecord | null>;
-    findActiveByArgv(argv: string[]): Promise<BakeRecord | null>;
-    findActiveAny(): Promise<BakeRecord | null>;
-    findNextQueuedId(): Promise<string | null>;
-    claimBake(bakeId: string, runnerId: string, leaseMs: number): Promise<BakeRecord | null>;
-    appendEvent(bakeId: string, kind: string, data: unknown, opts?: {
-        lineOrd?: number | null;
-        level?: string | null;
-    }): Promise<number | null>;
-    private lineOrdExists;
-    maxSeq(bakeId: string): Promise<number>;
-    retainedFrom(bakeId: string): Promise<number>;
-    getEvents(bakeId: string, afterSeq: number): Promise<BakeEvent[]>;
-    setStatus(bakeId: string, status: BakeStatus): Promise<void>;
-    setState(bakeId: string, state: BakeState): Promise<void>;
-    setTerminal(bakeId: string, t: BakeTerminal): Promise<number>;
-    setIndexId(bakeId: string, indexId: string): Promise<boolean>;
-    heartbeatLease(bakeId: string, runnerId: string, leaseMs: number): Promise<boolean>;
-    requestCancel(bakeId: string): Promise<boolean>;
-    isCancelRequested(bakeId: string): Promise<boolean>;
-    reapStaleBakes(olderThanMs: number): Promise<number>;
-    private tx;
-}
 //# sourceMappingURL=pg-image-bake.d.ts.map