@sema-agent/server 1.315.0 → 1.317.0

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

@@ -1,221 +1,2 @@
-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 { MAX_RUN_BLOB_BYTES, slimOversizeRun } from "./tidb-workflow-run-store.js";
-export class PgWorkflowRunStore {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async put(id, run) {
-        const stored = { ...run, id, rev: run.rev ?? 0 };
-        try {
-            await this.pool.query("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) {
-            if (e.code === "23505") {
-                throw new WorkflowRunStoreError("workflow_run.already_exists", "workflow run id already exists");
-            }
-            throw e;
-        }
-    }
-    async get(id) {
-        const res = await this.pool.query("SELECT run, rev FROM workflow_run WHERE id = $1", [id]);
-        const r = res.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.pool.query(`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.rowCount === 1;
-    }
-    async listByScope(scope, opts) {
-        const params = [scope];
-        let 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}`;
-        }
-        let limit = "";
-        if (opts?.limit !== undefined) {
-            params.push(Math.max(0, opts.limit));
-            limit = ` LIMIT $${params.length}`;
-        }
-        const res = await this.pool.query(`SELECT run, rev FROM workflow_run WHERE ${where} ORDER BY created_at DESC, id DESC${limit}`, params);
-        return res.rows.map((r) => {
-            const run = JSON.parse(String(r.run));
-            run.rev = Number(r.rev);
-            return summarizeWorkflowRun(run);
-        });
-    }
-    async reapAllScopes(now, opts) {
-        const res = await this.pool.query("SELECT DISTINCT scope FROM workflow_run");
-        let total = 0;
-        for (const r of res.rows)
-            total += await this.reap(r.scope, now, opts);
-        return total;
-    }
-    async reap(scope, now, opts) {
-        if (opts?.maxAgeMs === undefined && opts?.keep === undefined)
-            return 0;
-        const res = await this.pool.query("SELECT id, status, created_at, ended_at FROM workflow_run WHERE scope = $1 ORDER BY created_at DESC, id DESC", [scope]);
-        const rows = res.rows;
-        const terminal = rows.filter((r) => isTerminalWorkflowStatus(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(r.id);
-        }
-        if (doomed.length === 0)
-            return 0;
-        const del = await this.pool.query(`DELETE FROM workflow_run WHERE scope = $1 AND id = ANY($2::text[])`, [scope, doomed]);
-        return del.rowCount ?? 0;
-    }
-}
-const KIND_SERVED = "served";
-const KIND_PURGE = "purge";
-export class PgWorkflowCompletionInbox {
-    pool;
-    onWarn;
-    constructor(pool, onWarn) {
-        this.pool = pool;
-        this.onWarn = onWarn;
-    }
-    async sweepFences(now) {
-        await this.pool.query("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.pool.query("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.rowCount ?? 0) > 0) {
-            this.onWarn?.("workflow_completion_enqueue_after_poll_served", { sessionId: entry.sessionId, runId: entry.runId });
-            return;
-        }
-        const purge = await this.pool.query("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 : pf.owner === entry.owner))) {
-            this.onWarn?.("workflow_completion_enqueue_after_purge", { sessionId: entry.sessionId, runId: entry.runId });
-            return;
-        }
-        await this.pool.query("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.pool.query("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 = f.kind === KIND_SERVED;
-            const purgeFencesUs = !isServed && (Number(f.owner_known) === 0 || (f.owner === null ? entry.owner === null : 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.pool.query("SELECT seq, run_id FROM workflow_completion_inbox WHERE session_id = $1 ORDER BY seq DESC OFFSET $2", [entry.sessionId, MAX_PENDING_PER_SESSION]);
-        const overRows = over.rows;
-        if (overRows.length > 0) {
-            await this.pool.query("DELETE FROM workflow_completion_inbox WHERE session_id = $1 AND seq = ANY($2::bigint[])", [
-                entry.sessionId,
-                overRows.map((r) => r.seq),
-            ]);
-            for (const r of overRows)
-                this.onWarn?.("workflow_completion_inbox_overflow", { sessionId: entry.sessionId, droppedRunId: r.run_id });
-        }
-    }
-    async pending(sessionId) {
-        const res = await this.pool.query("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 res.rows.map((r) => ({
-            sessionId,
-            runId: r.run_id,
-            owner: r.owner,
-            status: r.status,
-            summary: r.summary,
-            enqueuedAt: Number(r.enqueued_at),
-            ...(r.kind != null ? { kind: r.kind } : {}),
-            ...(r.payload != null ? { payload: r.payload } : {}),
-        }));
-    }
-    async ack(sessionId, runId) {
-        await this.pool.query("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.pool.query("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", [sessionId, KIND_PURGE, purgedOwner ?? null, purgedOwner !== undefined ? 1 : 0, now + PURGE_FENCE_MS]);
-        await this.pool.query("DELETE FROM workflow_completion_inbox WHERE session_id = $1", [sessionId]);
-    }
-    async markTerminalServed(sessionId, runId) {
-        const now = Date.now();
-        await this.sweepFences(now);
-        await this.pool.query("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.pool.query("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 PgWorkflowNotifyJournalStore {
-    pool;
-    constructor(pool) {
-        this.pool = pool;
-    }
-    async record(input) {
-        await this.pool.query("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.pool.query("UPDATE workflow_notify_journal SET acked = 1, acked_at = $1 WHERE run_id = $2 AND acked = 0", [ackedAt, runId]);
-    }
-    async listPending() {
-        const res = await this.pool.query("SELECT run_id, scope, source_task_id, principal, created_at FROM workflow_notify_journal WHERE acked = 0");
-        return res.rows.map((r) => ({
-            runId: r.run_id,
-            scope: r.scope,
-            acked: false,
-            ...(r.source_task_id != null ? { sourceTaskId: r.source_task_id } : {}),
-            ...(r.principal != null ? { principal: r.principal } : {}),
-            createdAt: Number(r.created_at),
-        }));
-    }
-    async reapAcked(before) {
-        const res = await this.pool.query("DELETE FROM workflow_notify_journal WHERE acked = 1 AND acked_at < $1", [before]);
-        return res.rowCount ?? 0;
-    }
-    async get(runId) {
-        const res = await this.pool.query("SELECT run_id, scope, acked, source_task_id, principal, created_at, acked_at FROM workflow_notify_journal WHERE run_id = $1", [runId]);
-        const r = res.rows[0];
-        if (!r)
-            return null;
-        return {
-            runId: r.run_id,
-            scope: r.scope,
-            acked: Number(r.acked) === 1,
-            ...(r.source_task_id != null ? { sourceTaskId: r.source_task_id } : {}),
-            ...(r.principal != null ? { principal: r.principal } : {}),
-            createdAt: Number(r.created_at),
-            ...(r.acked_at != null ? { ackedAt: Number(r.acked_at) } : {}),
-        };
-    }
-}
+export { PgWorkflowRunStore, PgWorkflowCompletionInbox, PgWorkflowNotifyJournalStore } from "./workflow-run-store-sql.js";
 //# sourceMappingURL=pg-workflow-run-store.js.map

package/dist/plugins/remote-env-host.js

@@ -6,6 +6,7 @@ import { randomBytes } from "node:crypto";
 import { openSync, closeSync, readSync, statSync, truncateSync, unlinkSync, mkdirSync, rmdirSync, mkdtempSync, existsSync, realpathSync } from "node:fs";
 import { StringDecoder } from "node:string_decoder";
 import { armPipeDestroyGrace } from "./remote-shell.js";
+import { hostBackgroundShellEnabled, hostExecSpoolEnabled } from "../config.js";
 import { resolveHostShell, hostShell, spawnGroupOptions, killTreeHard, killTreeSoft, collapseWin32EnvKeys } from "./host-platform.js";
 import { BackgroundShellManager, seedMemStream, feedMemStream, drainMemStream } from "./background-shell-support.js";
 import { FileError, ExecutionError, RemoteExecutionError, scrubSecretEnv, RollingTailBuffer, markTruncated, SchedulerError, BackgroundShellError, } from "@sema-agent/core";
@@ -149,11 +150,11 @@ export class RemoteHostExecutionEnv {
     }
     get backgroundCapabilities() {
         return {
-            supported: (this.cfg.backgroundShell ?? true) && process.env.HOST_BG_DISABLED !== "true",
+            supported: (this.cfg.backgroundShell ?? true) && hostBackgroundShellEnabled(),
             maxConcurrent: HOST_BG_MAX_CONCURRENT,
             defaultBgTimeoutSec: HOST_BG_DEFAULT_TIMEOUT_SEC,
             maxBgTimeoutSec: HOST_BG_MAX_TIMEOUT_SEC,
-            supportsDetach: (this.cfg.backgroundShell ?? true) && process.env.HOST_BG_DISABLED !== "true",
+            supportsDetach: (this.cfg.backgroundShell ?? true) && hostBackgroundShellEnabled(),
         };
     }
     _bgManager;
@@ -331,7 +332,7 @@ export class RemoteHostExecutionEnv {
         const cwd = this.resolve(options?.cwd ?? this.cwd);
         const timeoutMs = options?.timeout != null ? options.timeout * 1000 : this.cfg.commandTimeoutMs;
         const detachSignal = options?.detachSignal;
-        if (process.platform !== "win32" && process.env.HOST_EXEC_SPOOL_DISABLED !== "true") {
+        if (process.platform !== "win32" && hostExecSpoolEnabled()) {
             const spool = this.openFgSpool();
             if (spool)
                 return this.execViaSpool(command, options, cwd, timeoutMs, detachSignal, spool);

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

@@ -0,0 +1,23 @@
+import type { Pool as MySqlPool } from "mysql2/promise";
+import type { Pool as PgPool } from "pg";
+import { type SqlDriver } from "./sql-driver.js";
+export declare class SqlResumeAnchorStore {
+    protected readonly db: SqlDriver;
+    constructor(db: SqlDriver);
+    private q;
+    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 declare class TiDBResumeAnchorStore extends SqlResumeAnchorStore {
+    constructor(pool: MySqlPool);
+}
+export declare class PgResumeAnchorStore extends SqlResumeAnchorStore {
+    constructor(pool: PgPool);
+}
+//# sourceMappingURL=resume-anchor-store-sql.d.ts.map

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

@@ -0,0 +1,38 @@
+import { mysqlDriver, pgDriver } from "./sql-driver.js";
+export class SqlResumeAnchorStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    q(tidb, pg) {
+        return this.db.dialect === "tidb" ? tidb : pg;
+    }
+    async put(sessionId, eventId, entryId, owner) {
+        await this.db.query(this.q("INSERT INTO resume_anchor (session_id, event_id, entry_id, owner, created_at) VALUES (?,?,?,?,?) " +
+            "ON DUPLICATE KEY UPDATE entry_id = VALUES(entry_id), owner = VALUES(owner)", "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 { rows } = await this.db.query(this.q("SELECT entry_id FROM resume_anchor WHERE session_id = ? AND event_id = ? AND owner <=> ?", "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 rows[0] ? String(rows[0].entry_id) : undefined;
+    }
+    async listBySession(sessionId) {
+        const { rows } = await this.db.query(this.q("SELECT event_id, entry_id, owner FROM resume_anchor WHERE session_id = ?", "SELECT event_id, entry_id, owner FROM resume_anchor WHERE session_id = $1"), [sessionId]);
+        return rows.map((r) => ({ eventId: String(r.event_id), entryId: String(r.entry_id), owner: r.owner == null ? null : String(r.owner) }));
+    }
+    async deleteBySession(sessionId) {
+        const res = await this.db.query(this.q("DELETE FROM resume_anchor WHERE session_id = ?", "DELETE FROM resume_anchor WHERE session_id = $1"), [sessionId]);
+        return res.affected;
+    }
+}
+export class TiDBResumeAnchorStore extends SqlResumeAnchorStore {
+    constructor(pool) {
+        super(mysqlDriver(pool));
+    }
+}
+export class PgResumeAnchorStore extends SqlResumeAnchorStore {
+    constructor(pool) {
+        super(pgDriver(pool));
+    }
+}
+//# sourceMappingURL=resume-anchor-store-sql.js.map

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

@@ -0,0 +1,89 @@
+import type { TaskResult, TaskStatus } from "@sema-agent/core";
+import type { Pool as MySqlPool } from "mysql2/promise";
+import type { Pool as PgPool } from "pg";
+import { type UsageRow } from "../usage-analytics.js";
+import type { RunRecord, SessionSummary, RunEvent } from "./store-contracts.js";
+import { type SqlDriver } from "./sql-driver.js";
+export type { RunRecord, SessionSummary, RunEvent } from "./store-contracts.js";
+export declare class SqlRunStore {
+    protected readonly db: SqlDriver;
+    constructor(db: SqlDriver);
+    private q;
+    private isDupKey;
+    private json;
+    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[]>;
+    private rowToSession;
+    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 declare class TiDBRunStore extends SqlRunStore {
+    constructor(pool: MySqlPool);
+}
+export declare class PgRunStore extends SqlRunStore {
+    constructor(pool: PgPool);
+}
+//# sourceMappingURL=run-store-sql.d.ts.map