@sema-agent/server 1.314.0 → 1.316.0

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

@@ -0,0 +1,210 @@
+import { captureManifest, applyManifest, DEFAULT_SNAPSHOT_BOUNDS } from "@sema-agent/core";
+import { createHash } from "node:crypto";
+import { SqlBlobBackend, sqlBlobSizes } from "./blob-backend.js";
+import { mysqlDriver, pgDriver } from "./sql-driver.js";
+export class SqlFileSnapshotStore {
+    db;
+    pool;
+    bounds;
+    inFlight = new Set();
+    blobs;
+    onSkippedVanished = undefined;
+    constructor(db, pool, blobBackend, bounds = DEFAULT_SNAPSHOT_BOUNDS) {
+        this.db = db;
+        this.pool = pool;
+        this.bounds = bounds;
+        this.blobs = blobBackend ?? new SqlBlobBackend(this.db.dialect, this.pool);
+    }
+    q(tidb, pg) {
+        return this.db.dialect === "tidb" ? tidb : pg;
+    }
+    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}\x00${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 (conn) => {
+                const exists = await conn.query(this.q("SELECT 1 FROM snapshot_manifest WHERE scope = ? AND snap_key = ? LIMIT 1", "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 conn.query(this.q("INSERT INTO snapshot_manifest (scope, snap_key, rel_path, blob_hash) VALUES (?,?,?,?)", "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}\x00${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 (conn) => {
+                const exists = await conn.query(this.q("SELECT 1 FROM snapshot_manifest WHERE scope = ? AND snap_key = ? LIMIT 1", "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 conn.query(this.q("INSERT INTO snapshot_manifest (scope, snap_key, rel_path, blob_hash) VALUES (?,?,?,?)", "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 { rows } = await this.db.query(this.q("SELECT rel_path, blob_hash FROM snapshot_manifest WHERE scope = ? AND snap_key = ?", "SELECT rel_path, blob_hash FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2"), [scope, key]);
+            if (rows.length === 0)
+                return { ok: false, error: { code: "not_found", message: `no file snapshot for ${scope}/${key}` } };
+            const manifest = new Map(rows.map((r) => [String(r.rel_path), String(r.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 { rows } = await this.db.query(this.q("SELECT 1 FROM snapshot_manifest WHERE scope = ? AND snap_key = ? LIMIT 1", "SELECT 1 FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2 LIMIT 1"), [scope, key]);
+        return Boolean(rows[0]);
+    }
+    async listKeys(scope) {
+        const { rows } = await this.db.query(this.q("SELECT DISTINCT snap_key FROM snapshot_manifest WHERE scope = ?", "SELECT DISTINCT snap_key FROM snapshot_manifest WHERE scope = $1"), [scope]);
+        return rows.map((r) => String(r.snap_key));
+    }
+    async exportManifest(scope, key) {
+        const { rows } = await this.db.query(this.q("SELECT rel_path, blob_hash FROM snapshot_manifest WHERE scope = ? AND snap_key = ?", "SELECT rel_path, blob_hash FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2"), [scope, key]);
+        if (rows.length === 0)
+            return null;
+        return new Map(rows.map((r) => [String(r.rel_path), String(r.blob_hash)]));
+    }
+    async getBlob(hash) {
+        return this.blobs.getBlob(hash);
+    }
+    async hasBlobs(hashes) {
+        return this.blobs.hasBlobs(hashes);
+    }
+    async blobSizes(hashes) {
+        return sqlBlobSizes(this.db.dialect, this.pool, hashes);
+    }
+    async reap(scope, keepKeys) {
+        return this.tx(async (conn) => {
+            const { rows: keys } = await conn.query(this.q("SELECT DISTINCT snap_key FROM snapshot_manifest WHERE scope = ?", "SELECT DISTINCT snap_key FROM snapshot_manifest WHERE scope = $1"), [scope]);
+            const drop = keys.map((k) => String(k.snap_key)).filter((k) => !keepKeys.includes(k));
+            for (const k of drop) {
+                await conn.query(this.q("DELETE FROM snapshot_manifest WHERE scope = ? AND snap_key = ?", "DELETE FROM snapshot_manifest WHERE scope = $1 AND snap_key = $2"), [scope, k]);
+            }
+            return drop.length;
+        });
+    }
+    async deleteBySession(scope) {
+        const { affected } = await this.db.query(this.q("DELETE FROM snapshot_manifest WHERE scope = ?", "DELETE FROM snapshot_manifest WHERE scope = $1"), [scope]);
+        return affected;
+    }
+    async gcOrphanBlobs() {
+        const { rows } = await this.db
+            .query("SELECT blob_hash FROM snapshot_blob WHERE blob_hash NOT IN (SELECT blob_hash FROM snapshot_manifest)")
+            .catch(() => ({ rows: [], affected: 0 }));
+        const orphans = rows.map((r) => String(r.blob_hash));
+        if (orphans.length === 0)
+            return 0;
+        return this.blobs.deleteBlobs(orphans);
+    }
+    async sweepOrphanBlobs() {
+        return this.gcOrphanBlobs();
+    }
+    async tx(fn) {
+        const conn = await this.db.connect();
+        try {
+            await conn.begin();
+            const out = await fn(conn);
+            await conn.commit();
+            return out;
+        }
+        catch (err) {
+            try {
+                await conn.rollback();
+            }
+            catch {
+            }
+            throw err;
+        }
+        finally {
+            conn.release();
+        }
+    }
+}
+export class TiDBFileSnapshotStore extends SqlFileSnapshotStore {
+    constructor(pool, blobBackend, bounds = DEFAULT_SNAPSHOT_BOUNDS) {
+        super(mysqlDriver(pool), pool, blobBackend, bounds);
+    }
+}
+export class PgFileSnapshotStore extends SqlFileSnapshotStore {
+    constructor(pool, blobBackend, bounds = DEFAULT_SNAPSHOT_BOUNDS) {
+        super(pgDriver(pool), pool, blobBackend, bounds);
+    }
+}
+//# sourceMappingURL=file-snapshot-store-sql.js.map

package/dist/plugins/image-bake-store-sql.d.ts

@@ -0,0 +1,53 @@
+import type { Pool as MySqlPool } from "mysql2/promise";
+import type { Pool as PgPool, PoolClient } from "pg";
+import { type SqlDriver } from "./sql-driver.js";
+import { type BakeStatus, type BakeState, type BakeRecord, type BakeEvent, type CreateBakeInput, type BakeTerminal } from "./store-contracts.js";
+export declare const PG_IMAGE_BAKE_SCHEMA: string[];
+export declare function ensurePgImageBakeSchema(pool: PgPool | PoolClient, poolName?: string): Promise<void>;
+export declare class SqlImageBake {
+    protected readonly db: SqlDriver;
+    protected readonly poolName: string;
+    constructor(db: SqlDriver, poolName?: string);
+    private q;
+    private insertParams;
+    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>;
+    private terminalParamsTidb;
+    private terminalParamsPg;
+    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;
+}
+export declare class TiDBImageBake extends SqlImageBake {
+    constructor(pool: MySqlPool, poolName?: string);
+}
+export declare class PgImageBake extends SqlImageBake {
+    constructor(pool: PgPool, poolName?: string);
+}
+//# sourceMappingURL=image-bake-store-sql.d.ts.map