@sema-agent/server 1.315.0 → 1.317.0

package/dist/plugins/pg-image-index.js

@@ -1,218 +1,2 @@
-import { createHash } from "node:crypto";
-import { pgSafeJsonStringify, pgSanitizeText, pgHasUnstorable, PgUnstorableError } from "./pg-safe-json.js";
-import { mapImageRow as mapRow, } from "./store-contracts.js";
-export const PG_IMAGE_INDEX_SCHEMA = [
-    `CREATE TABLE IF NOT EXISTS sandbox_image_index (
-     id                 VARCHAR(64)  NOT NULL,
-     profile            VARCHAR(64)  NOT NULL,
-     bands              JSONB,
-     repo               VARCHAR(255) NOT NULL,
-     tag                VARCHAR(128) NOT NULL,
-     digest             VARCHAR(80)  NOT NULL,
-     toolchain_versions JSONB,
-     capabilities       JSONB,
-     pod_contract       JSONB,
-     size_bytes         BIGINT,
-     status             VARCHAR(16)  NOT NULL DEFAULT 'building',
-     visibility         VARCHAR(16)  NOT NULL DEFAULT 'public',
-     tenant_id          VARCHAR(64),
-     manifest_sha       VARCHAR(64),
-     recipe_git_sha     VARCHAR(64),
-     generator_version  VARCHAR(32),
-     build_date         TIMESTAMPTZ(3),
-     supersedes         VARCHAR(64),
-     signed             SMALLINT     NOT NULL DEFAULT 0,
-     created_at         TIMESTAMPTZ(3) NOT NULL,
-     updated_at         TIMESTAMPTZ(3) NOT NULL,
-     PRIMARY KEY (id)
-   )`,
-    `CREATE UNIQUE INDEX IF NOT EXISTS uq_repo_digest ON sandbox_image_index (repo, digest)`,
-    `CREATE INDEX IF NOT EXISTS idx_profile_status ON sandbox_image_index (profile, status, visibility)`,
-    `CREATE INDEX IF NOT EXISTS idx_digest ON sandbox_image_index (digest)`,
-    `CREATE INDEX IF NOT EXISTS idx_tenant ON sandbox_image_index (tenant_id, status)`,
-];
-export async function ensureSchema(pool) {
-    for (const stmt of PG_IMAGE_INDEX_SCHEMA)
-        await pool.query(stmt);
-}
-const MAX_LIMIT = 200;
-const DEFAULT_LIMIT = 50;
-function visibilityClause(viewer, startIdx) {
-    if (viewer.operator)
-        return { sql: "1=1", params: [], nextIdx: startIdx };
-    if (viewer.tenantId)
-        return {
-            sql: `(visibility = 'public' OR tenant_id = $${startIdx})`,
-            params: [viewer.tenantId],
-            nextIdx: startIdx + 1,
-        };
-    return { sql: "visibility = 'public'", params: [], nextIdx: startIdx };
-}
-function encodeCursor(e) {
-    return Buffer.from(`${e.createdAt}|${e.id}`, "utf8").toString("base64url");
-}
-function decodeCursor(c) {
-    try {
-        const [createdAt, id] = Buffer.from(c, "base64url").toString("utf8").split("|");
-        if (!createdAt || !id)
-            return null;
-        return { createdAt, id };
-    }
-    catch {
-        return null;
-    }
-}
-const UPSERT_COLS = "(id, profile, bands, repo, tag, digest, toolchain_versions, capabilities, pod_contract, size_bytes, " +
-    "status, visibility, tenant_id, manifest_sha, recipe_git_sha, generator_version, build_date, supersedes, " +
-    "signed, created_at, updated_at)";
-const UPSERT_VALUES = "($1,$2,$3::jsonb,$4,$5,$6,$7::jsonb,$8::jsonb,$9::jsonb,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21)";
-function upsertParams(e, id, now) {
-    return [
-        id,
-        pgSanitizeText(e.profile),
-        pgSafeJsonStringify(e.bands ?? []),
-        e.repo,
-        pgSanitizeText(e.tag),
-        e.digest,
-        pgSafeJsonStringify(e.toolchainVersions ?? {}),
-        pgSafeJsonStringify(e.capabilities ?? {}),
-        pgSafeJsonStringify(e.podContract ?? {}),
-        e.sizeBytes,
-        e.status,
-        e.visibility,
-        e.tenantId ?? null,
-        e.manifestSha ?? null,
-        e.recipeGitSha == null ? null : pgSanitizeText(e.recipeGitSha),
-        e.generatorVersion == null ? null : pgSanitizeText(e.generatorVersion),
-        e.buildDate ? new Date(e.buildDate) : null,
-        e.supersedes == null ? null : pgSanitizeText(e.supersedes),
-        e.signed ? 1 : 0,
-        now,
-        now,
-    ];
-}
-export class PgImageIndex {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    static idFor(repo, digest) {
-        return createHash("sha256").update(`${repo}@${digest}`).digest("hex").slice(0, 64);
-    }
-    async upsert(e) {
-        if (pgHasUnstorable(e.repo))
-            throw new PgUnstorableError("image repo (identity)");
-        if (e.tenantId != null && pgHasUnstorable(e.tenantId))
-            throw new PgUnstorableError("image tenantId (identity)");
-        const id = PgImageIndex.idFor(e.repo, e.digest);
-        const now = new Date();
-        await this.pool.query(`INSERT INTO sandbox_image_index ${UPSERT_COLS}
-       VALUES ${UPSERT_VALUES}
-       ON CONFLICT (id) DO UPDATE SET
-         profile = EXCLUDED.profile, bands = EXCLUDED.bands, tag = EXCLUDED.tag,
-         toolchain_versions = EXCLUDED.toolchain_versions, capabilities = EXCLUDED.capabilities,
-         pod_contract = EXCLUDED.pod_contract, size_bytes = EXCLUDED.size_bytes,
-         status = EXCLUDED.status, visibility = EXCLUDED.visibility, tenant_id = EXCLUDED.tenant_id,
-         manifest_sha = EXCLUDED.manifest_sha, recipe_git_sha = EXCLUDED.recipe_git_sha,
-         generator_version = EXCLUDED.generator_version, build_date = EXCLUDED.build_date,
-         supersedes = EXCLUDED.supersedes, signed = EXCLUDED.signed, updated_at = EXCLUDED.updated_at`, upsertParams(e, id, now));
-        return id;
-    }
-    async registerBuilding(e) {
-        if (pgHasUnstorable(e.repo))
-            throw new PgUnstorableError("image repo (identity)");
-        if (e.tenantId != null && pgHasUnstorable(e.tenantId))
-            throw new PgUnstorableError("image tenantId (identity)");
-        const id = PgImageIndex.idFor(e.repo, e.digest);
-        const now = new Date();
-        await this.pool.query(`INSERT INTO sandbox_image_index ${UPSERT_COLS}
-       VALUES ${UPSERT_VALUES}
-       ON CONFLICT (id) DO UPDATE SET
-         profile = EXCLUDED.profile, bands = EXCLUDED.bands, tag = EXCLUDED.tag,
-         toolchain_versions = EXCLUDED.toolchain_versions, capabilities = EXCLUDED.capabilities,
-         pod_contract = EXCLUDED.pod_contract, size_bytes = EXCLUDED.size_bytes,
-         status = CASE WHEN sandbox_image_index.status = 'published'
-                       THEN sandbox_image_index.status ELSE EXCLUDED.status END,
-         visibility = CASE WHEN sandbox_image_index.status = 'published'
-                           THEN sandbox_image_index.visibility ELSE EXCLUDED.visibility END,
-         tenant_id = CASE WHEN sandbox_image_index.status = 'published'
-                          THEN sandbox_image_index.tenant_id ELSE EXCLUDED.tenant_id END,
-         manifest_sha = EXCLUDED.manifest_sha, recipe_git_sha = EXCLUDED.recipe_git_sha,
-         generator_version = EXCLUDED.generator_version, build_date = EXCLUDED.build_date,
-         supersedes = EXCLUDED.supersedes,
-         signed = CASE WHEN sandbox_image_index.status = 'published'
-                       THEN sandbox_image_index.signed ELSE EXCLUDED.signed END,
-         updated_at = EXCLUDED.updated_at`, upsertParams(e, id, now));
-        return id;
-    }
-    async getById(id) {
-        const res = await this.pool.query("SELECT * FROM sandbox_image_index WHERE id = $1 LIMIT 1", [id]);
-        return res.rows[0] ? mapRow(res.rows[0]) : null;
-    }
-    async getByDigest(digest) {
-        const res = await this.pool.query("SELECT * FROM sandbox_image_index WHERE digest = $1 ORDER BY updated_at DESC LIMIT 1", [digest]);
-        return res.rows[0] ? mapRow(res.rows[0]) : null;
-    }
-    async latestPublished(profile, viewer) {
-        const vis = visibilityClause(viewer, 2);
-        const res = await this.pool.query(`SELECT * FROM sandbox_image_index
-        WHERE profile = $1 AND status = 'published' AND ${vis.sql}
-        ORDER BY build_date DESC NULLS LAST, created_at DESC LIMIT 1`, [profile, ...vis.params]);
-        return res.rows[0] ? mapRow(res.rows[0]) : null;
-    }
-    async list(filter) {
-        const limit = Math.min(Math.max(1, filter.limit ?? DEFAULT_LIMIT), MAX_LIMIT);
-        const vis = visibilityClause(filter, 1);
-        const where = [vis.sql];
-        const params = [...vis.params];
-        let idx = vis.nextIdx;
-        if (filter.profile) {
-            where.push(`profile = $${idx++}`);
-            params.push(filter.profile);
-        }
-        if (filter.status) {
-            where.push(`status = $${idx++}`);
-            params.push(filter.status);
-        }
-        if (filter.capability) {
-            where.push(`capabilities -> $${idx++} = 'true'::jsonb`);
-            params.push(filter.capability);
-        }
-        if (filter.cursor) {
-            const c = decodeCursor(filter.cursor);
-            if (c) {
-                where.push(`(created_at < $${idx} OR (created_at = $${idx + 1} AND id < $${idx + 2}))`);
-                params.push(new Date(c.createdAt), new Date(c.createdAt), c.id);
-                idx += 3;
-            }
-        }
-        const sql = `SELECT * FROM sandbox_image_index WHERE ${where.join(" AND ")} ` +
-            `ORDER BY created_at DESC, id DESC LIMIT $${idx}`;
-        params.push(limit + 1);
-        const res = await this.pool.query(sql, params);
-        let entries = res.rows.map(mapRow);
-        let nextCursor = null;
-        if (entries.length > limit) {
-            entries = entries.slice(0, limit);
-            const last = entries[entries.length - 1];
-            nextCursor = encodeCursor({ createdAt: last.createdAt, id: last.id });
-        }
-        if (filter.latestOnly) {
-            const seen = new Set();
-            entries = entries.filter((e) => (seen.has(e.profile) ? false : (seen.add(e.profile), true)));
-        }
-        return { entries, nextCursor };
-    }
-    async setStatus(id, status, opts) {
-        const sets = ["status = $1", "updated_at = $2"];
-        const params = [status, new Date()];
-        let idx = 3;
-        if (opts && "supersedes" in opts) {
-            sets.push(`supersedes = $${idx++}`);
-            params.push(opts.supersedes ?? null);
-        }
-        params.push(id);
-        await this.pool.query(`UPDATE sandbox_image_index SET ${sets.join(", ")} WHERE id = $${idx}`, params);
-    }
-}
+export { PgImageIndex, PG_IMAGE_INDEX_SCHEMA, ensureSchema } from "./image-index-sql.js";
 //# sourceMappingURL=pg-image-index.js.map

package/dist/plugins/pg-outcome-ledger.d.ts

@@ -1,23 +1,3 @@
-import type { Pool, PoolClient } from "pg";
-import { type TaskOutcome, type RunStatus } from "./tidb-outcome-ledger.js";
-import type { TaskOutcome as CoreTaskOutcome } from "@sema-agent/core";
-export declare const PG_OUTCOME_LEDGER_SCHEMA: string[];
-export declare function ensureSchema(pool: Pool | PoolClient): Promise<void>;
-export declare class PgOutcomeLedger {
-    private readonly pool;
-    constructor(pool: Pool);
-    record(o: TaskOutcome): Promise<string>;
-    recordCore(o: CoreTaskOutcome): Promise<void>;
-    summary(opts?: {
-        taskSignature?: string;
-        includeAborted?: boolean;
-    }): Promise<Array<{
-        taskSignature: string;
-        model: string;
-        n: number;
-        passRate: number;
-        meanCostMicroUsd: number;
-    }>>;
-}
-export type { TaskOutcome, RunStatus };
+export { PgOutcomeLedger, PG_OUTCOME_LEDGER_SCHEMA, ensurePgOutcomeLedgerSchema as ensureSchema, } from "./outcome-ledger-sql.js";
+export type { TaskOutcome, RunStatus } from "./outcome-ledger-sql.js";
 //# sourceMappingURL=pg-outcome-ledger.d.ts.map

package/dist/plugins/pg-outcome-ledger.js

@@ -1,105 +1,2 @@
-import { randomUUID } from "node:crypto";
-import { taskSignature, deriveOutcome, } from "./tidb-outcome-ledger.js";
-import { coreOutcomeToLedgerRow } from "./tidb-outcome-ledger.js";
-import { pgSafeJsonStringify } from "./pg-safe-json.js";
-export const PG_OUTCOME_LEDGER_SCHEMA = [
-    `CREATE TABLE IF NOT EXISTS outcome_ledger (
-     id             VARCHAR(64)  NOT NULL,
-     task_signature VARCHAR(190) NOT NULL,
-     model          VARCHAR(190) NOT NULL,
-     task_id        VARCHAR(64),
-     run_status     VARCHAR(20)  NOT NULL DEFAULT 'completed-graded',
-     route          VARCHAR(16),
-     worker_count   INTEGER,
-     oracle_passed  INTEGER,
-     oracle_total   INTEGER,
-     assemble_exit  INTEGER,
-     lint_exit      INTEGER,
-     merge_ok       SMALLINT,
-     replan_triggers JSONB,
-     cost_micro_usd BIGINT,
-     turns          INTEGER,
-     outcome        VARCHAR(8),
-     llm_assisted   JSONB,
-     signature_inputs JSONB,
-     -- design/73 §1 bridge: the VERBATIM core TaskOutcome fact (oracleHadRedRun / status / oracle blob) as it
-     -- came off core, kept alongside the derived mechanical columns. NULL when the caller recorded through the
-     -- non-core \`record()\` path (no core fact to bridge).
-     core_outcome   JSONB,
-     created_at     TIMESTAMPTZ(3) NOT NULL,
-     PRIMARY KEY (id)
-   )`,
-    `CREATE INDEX IF NOT EXISTS idx_outcome_ledger_sig_model ON outcome_ledger (task_signature, model, run_status)`,
-    `CREATE INDEX IF NOT EXISTS idx_outcome_ledger_outcome ON outcome_ledger (outcome)`,
-    `CREATE INDEX IF NOT EXISTS idx_outcome_ledger_created ON outcome_ledger (created_at)`,
-];
-export async function ensureSchema(pool) {
-    for (const stmt of PG_OUTCOME_LEDGER_SCHEMA)
-        await pool.query(stmt);
-}
-export class PgOutcomeLedger {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async record(o) {
-        const id = randomUUID().replace(/-/g, "").slice(0, 32);
-        const sig = taskSignature(o.signatureInputs);
-        const m = o.mechanical;
-        const runStatus = o.runStatus ?? "completed-graded";
-        await this.pool.query(`INSERT INTO outcome_ledger
-        (id, task_signature, model, task_id, run_status, route, worker_count, oracle_passed, oracle_total,
-         assemble_exit, lint_exit, merge_ok, replan_triggers, cost_micro_usd, turns, outcome,
-         llm_assisted, signature_inputs, core_outcome, created_at)
-       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13::jsonb,$14,$15,$16,$17::jsonb,$18::jsonb,$19::jsonb,$20)`, [
-            id,
-            sig,
-            o.model,
-            o.taskId ?? null,
-            runStatus,
-            m.route ?? null,
-            m.workerCount ?? null,
-            m.oraclePassed ?? null,
-            m.oracleTotal ?? null,
-            m.assembleExit ?? null,
-            m.lintExit ?? null,
-            m.mergeOk == null ? null : m.mergeOk ? 1 : 0,
-            m.replanTriggers ? pgSafeJsonStringify(m.replanTriggers) : null,
-            m.costMicroUsd ?? null,
-            m.turns ?? null,
-            deriveOutcome(m, runStatus),
-            o.llmAssisted ? pgSafeJsonStringify(o.llmAssisted) : null,
-            pgSafeJsonStringify(o.signatureInputs),
-            o.core != null ? pgSafeJsonStringify(o.core) : null,
-            new Date(),
-        ]);
-        return id;
-    }
-    async recordCore(o) {
-        await this.record(coreOutcomeToLedgerRow(o));
-    }
-    async summary(opts = {}) {
-        const clauses = [];
-        const params = [];
-        if (!opts.includeAborted)
-            clauses.push("run_status = 'completed-graded'");
-        if (opts.taskSignature) {
-            params.push(opts.taskSignature);
-            clauses.push(`task_signature = $${params.length}`);
-        }
-        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
-        const res = await this.pool.query(`SELECT task_signature, model, COUNT(*) n,
-              AVG((outcome = 'pass')::int) pass_rate, AVG(cost_micro_usd) mean_cost
-         FROM outcome_ledger ${where}
-        GROUP BY task_signature, model
-        ORDER BY task_signature, model`, params);
-        return res.rows.map((r) => ({
-            taskSignature: String(r.task_signature),
-            model: String(r.model),
-            n: Number(r.n),
-            passRate: Number(r.pass_rate),
-            meanCostMicroUsd: Number(r.mean_cost ?? 0),
-        }));
-    }
-}
+export { PgOutcomeLedger, PG_OUTCOME_LEDGER_SCHEMA, ensurePgOutcomeLedgerSchema as ensureSchema, } from "./outcome-ledger-sql.js";
 //# sourceMappingURL=pg-outcome-ledger.js.map

package/dist/plugins/pg-resume-anchor-store.d.ts

@@ -1,14 +1,2 @@
-import type { Pool } from "pg";
-export declare class PgResumeAnchorStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    put(sessionId: string, eventId: string, entryId: string, owner: string | null): Promise<void>;
-    resolve(sessionId: string, eventId: string, owner: string | null): Promise<string | undefined>;
-    listBySession(sessionId: string): Promise<Array<{
-        eventId: string;
-        entryId: string;
-        owner: string | null;
-    }>>;
-    deleteBySession(sessionId: string): Promise<number>;
-}
+export { PgResumeAnchorStore } from "./resume-anchor-store-sql.js";
 //# sourceMappingURL=pg-resume-anchor-store.d.ts.map

package/dist/plugins/pg-resume-anchor-store.js

@@ -1,23 +1,2 @@
-export class PgResumeAnchorStore {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async put(sessionId, eventId, entryId, owner) {
-        await this.pool.query("INSERT INTO resume_anchor (session_id, event_id, entry_id, owner, created_at) VALUES ($1,$2,$3,$4,$5) " +
-            "ON CONFLICT (session_id, event_id) DO UPDATE SET entry_id = EXCLUDED.entry_id, owner = EXCLUDED.owner", [sessionId, eventId, entryId, owner, new Date()]);
-    }
-    async resolve(sessionId, eventId, owner) {
-        const r = await this.pool.query("SELECT entry_id FROM resume_anchor WHERE session_id = $1 AND event_id = $2 AND owner IS NOT DISTINCT FROM $3", [sessionId, eventId, owner]);
-        return r.rows[0] ? String(r.rows[0].entry_id) : undefined;
-    }
-    async listBySession(sessionId) {
-        const r = await this.pool.query("SELECT event_id, entry_id, owner FROM resume_anchor WHERE session_id = $1", [sessionId]);
-        return r.rows.map((row) => ({ eventId: String(row.event_id), entryId: String(row.entry_id), owner: row.owner == null ? null : String(row.owner) }));
-    }
-    async deleteBySession(sessionId) {
-        const r = await this.pool.query("DELETE FROM resume_anchor WHERE session_id = $1", [sessionId]);
-        return r.rowCount ?? 0;
-    }
-}
+export { PgResumeAnchorStore } from "./resume-anchor-store-sql.js";
 //# sourceMappingURL=pg-resume-anchor-store.js.map

package/dist/plugins/pg-run-store.d.ts

@@ -1,76 +1,2 @@
-import type { TaskResult, TaskStatus } from "@sema-agent/core";
-import { type UsageRow } from "../usage-analytics.js";
-import type { Pool } from "pg";
-import type { RunRecord, RunEvent, SessionSummary } from "./store-contracts.js";
-export declare class PgRunStore {
-    private readonly pool;
-    constructor(pool: Pool);
-    private tx;
-    createRun(taskId: string, sessionId: string, owner: string | null, instanceId: string, meta?: {
-        jobId?: string | null;
-        source?: string | null;
-        objectivePreview?: string | null;
-    }): Promise<{
-        ok: true;
-    } | {
-        ok: false;
-        activeTaskId: string;
-    }>;
-    requestCancel(taskId: string, owner: string | null): Promise<boolean>;
-    isCancelRequested(taskId: string, owner: string | null): Promise<boolean>;
-    requestPreempt(taskId: string, owner: string | null): Promise<boolean>;
-    isPreemptRequested(taskId: string, owner: string | null): Promise<boolean>;
-    heartbeat(taskId: string, owner: string | null): Promise<void>;
-    appendEvent(taskId: string, seq: number, type: string, data: unknown): Promise<void>;
-    maxSeq(taskId: string): Promise<number>;
-    setTerminal(taskId: string, status: TaskStatus, result: TaskResult | null, error: string | null): Promise<void>;
-    setSuspended(taskId: string): Promise<void>;
-    setNeedsReview(taskId: string): Promise<void>;
-    markResuming(taskId: string): Promise<boolean>;
-    getActiveTaskId(sessionId: string): Promise<string | undefined>;
-    private rowToRun;
-    getRun(taskId: string): Promise<RunRecord | undefined>;
-    listRuns(opts: {
-        status?: string;
-        jobId?: string;
-        source?: string;
-        owner?: string;
-        cursor?: {
-            createdAt: string;
-            taskId: string;
-        };
-        limit: number;
-    }): Promise<RunRecord[]>;
-    listSessions(opts: {
-        owner?: string;
-        cursor?: {
-            lastActivityAt: string;
-            sessionId: string;
-        };
-        limit: number;
-        q?: string;
-    }): Promise<SessionSummary[]>;
-    deleteBySession(sessionId: string, owner: string | null): Promise<{
-        removed: number;
-    } | {
-        active: string;
-    }>;
-    sourceSummary(sinceMs: number): Promise<Array<{
-        source: string | null;
-        status: string;
-        count: number;
-    }>>;
-    usageScan(fromMs: number, toMs: number, opts?: {
-        owner?: string;
-        limit?: number;
-    }): Promise<{
-        rows: UsageRow[];
-        truncated: boolean;
-    }>;
-    retainedFrom(taskId: string): Promise<number>;
-    getEvents(taskId: string, afterSeq: number): Promise<RunEvent[]>;
-    reapStale(olderThanMs: number): Promise<number>;
-    reapSuspended(olderThanMs: number): Promise<number>;
-    failSuspendedWithExpiredCheckpoint(): Promise<number>;
-}
+export { PgRunStore } from "./run-store-sql.js";
 //# sourceMappingURL=pg-run-store.d.ts.map