@sema-agent/server 1.294.0 → 1.296.0

package/dist/config.d.ts

@@ -162,6 +162,8 @@ export interface ServiceConfig {
         keyPrefix?: string;
         presignTtlSec?: number;
     };
+    snapshotBlobSqlMaxBytes?: number;
+    snapshotBlobAllowSql: boolean;
     sendUserFile?: {
         endpoint: string;
         publicEndpoint?: string;

package/dist/config.js

@@ -536,6 +536,8 @@ export function loadConfig() {
                 ...((ttl) => (ttl !== undefined ? { presignTtlSec: ttl } : {}))(optFinitePositiveEnv("SESSION_SNAPSHOT_TTL_SEC")),
             }
             : undefined,
+        snapshotBlobSqlMaxBytes: optFinitePositiveEnv("SNAPSHOT_BLOB_SQL_MAX_BYTES"),
+        snapshotBlobAllowSql: process.env.SNAPSHOT_BLOB_ALLOW_SQL_BYTES === "true",
         sendUserFile: (process.env.MINIO_ENDPOINT || process.env.S3_ENDPOINT) && process.env.MINIO_ACCESS_KEY && process.env.MINIO_SECRET_KEY
             ? {
                 endpoint: (process.env.MINIO_ENDPOINT || process.env.S3_ENDPOINT),

package/dist/http/server.d.ts

@@ -63,6 +63,7 @@ export interface ServiceDeps {
     approvalExemptionStore?: ApprovalExemptionStore;
     sessionPolicyStore?: ServiceSessionPolicyStore;
     fileSnapshotStore?: ServiceFileSnapshotStore;
+    snapshotBlobSqlCapBytes?: number;
     backend?: StoreBackend;
     sessionMirrorRuling?: (principal: string | undefined) => Promise<SessionMirrorRuling | undefined>;
     approvalStore?: ApprovalStore;

package/dist/http/server.js

@@ -668,6 +668,9 @@ export function createHttpServer(deps) {
                 approvals: Boolean(deps.checkpointStore),
                 sessions: Boolean(deps.sessionAudit),
                 sessionEvents: Boolean(deps.sessionWatch && deps.sessionStorage?.getLeafId && deps.sessionStorage?.ownerOf),
+                fleet: deps.fleetBus
+                    ? { stream: true, sessionScope: true, observe: true, resume: "snapshot", bgNotifyFailClosed: true, steerPriority: "advisory" }
+                    : false,
                 leader: Boolean(deps.leaderEndpoint),
                 memory: false,
                 memoryWrite: false,
@@ -4062,6 +4065,13 @@ export function createHttpServer(deps) {
                         return;
                     }
                     const body = await readRawBody(req, SYNC_BLOB_MAX_BYTES);
+                    if (deps.snapshotBlobSqlCapBytes !== undefined && body.byteLength > deps.snapshotBlobSqlCapBytes) {
+                        sendJson(res, 413, {
+                            code: "blob_too_large_for_sql",
+                            error: `blob of ${body.byteLength} bytes exceeds this deployment's SQL snapshot-blob cap (${deps.snapshotBlobSqlCapBytes} bytes; mysql-protocol packet limit) — configure MinIO object storage (MINIO_ENDPOINT/MINIO_ACCESS_KEY/MINIO_SECRET_KEY) for large snapshot blobs`,
+                        });
+                        return;
+                    }
                     if (createHash("sha256").update(body).digest("hex") !== hash) {
                         sendJson(res, 400, { error: "blob hash mismatch" });
                         return;

package/dist/main.js

@@ -28,7 +28,7 @@ import { loadConfig, logConfigDiagnostics } from "./config.js";
 import { resourceSuspendOptIn } from "./resource-suspend.js";
 import { createSessionStore, ensureChildSessionDurableWithPromotion } from "./plugins/session-store.js";
 import { ForkRoutingSessionStore } from "./plugins/fork-routing-session-store.js";
-import { createStoreBackend } from "./plugins/store-backend.js";
+import { createStoreBackend, assertCloudSnapshotBlobPosture } from "./plugins/store-backend.js";
 import { e2bExecutionEnvFactory } from "./plugins/remote-env-e2b.js";
 import { k8sExecutionEnvFactory } from "./plugins/remote-env-k8s.js";
 import { sshExecutionEnvFactory } from "./plugins/remote-env-ssh.js";
@@ -80,7 +80,7 @@ import { defaultLkgPath, defaultSkillCacheDir, saveLkg, loadLkg } from "./config
 import { TiDBRosterStore, PgRosterStore, ensureTiDBRosterSchema, ensurePgRosterSchema } from "./plugins/roster-store-sql.js";
 import { TiDBTaskAttachmentStore, PgTaskAttachmentStore, ensureTiDBTaskAttachmentSchema, ensurePgTaskAttachmentSchema, bindAttachmentsForTask, materializeAttachmentsInto } from "./plugins/task-attachment-store.js";
 import { LocalTaskAttachmentStore } from "./plugins/local-task-attachment-store.js";
-import { MinioBlobBackend } from "./plugins/blob-backend.js";
+import { MinioBlobBackend, SQL_BLOB_DEFAULT_MAX_BYTES } from "./plugins/blob-backend.js";
 import { TiDBBackgroundAgentStore, PgBackgroundAgentStore, ensureTiDBBackgroundAgentSchema, ensurePgBackgroundAgentSchema } from "./plugins/background-agent-store-sql.js";
 import { TiDBMailboxStore, PgMailboxStore, ensureTiDBMailboxSchema, ensurePgMailboxSchema } from "./plugins/mailbox-store-sql.js";
 import { createPrincipalCapsClient, gateExecutionLane, scopedTokenNeedsWorker, applyObserverEnvOptIn } from "./runtime-caps-resolver.js";
@@ -634,10 +634,14 @@ async function main() {
             "the in-memory store cannot enforce session ownership.");
     }
     if (config.requirePrincipal && backend?.kind === "local") {
-        throw new Error("REQUIRE_PRINCIPAL=true is not supported on the local in-memory backend (DB_BACKEND=local): its owner map is " +
-            "process-local and lost on restart, so it cannot durably enforce multi-tenant session ownership. Use a DB " +
-            "backend (DB_BACKEND=tidb|pg) for multi-tenant, or run local single-user with REQUIRE_PRINCIPAL=false.");
+        throw new Error("REQUIRE_PRINCIPAL=true is not supported on the local file backend (DB_BACKEND=local): session/run CONTENT is " +
+            "durable there, but OWNER attribution is process-local and lost on restart (store-backend.ts §0.5 — durable " +
+            "owners = P1), so it cannot durably enforce multi-tenant session ownership. Use a SQL backend " +
+            "(DB_BACKEND=mysql|pg) for multi-tenant, or run local single-user with REQUIRE_PRINCIPAL=false (a BFF may " +
+            "still inject x-agent-principal per request for memory scoping and audit attribution).");
     }
+    if (backend)
+        assertCloudSnapshotBlobPosture(backend.kind, config);
     if (!config.requirePrincipal && sessionStore.ownerOf) {
         logger.warn("principal_optional", {
             note: "owner-aware session store with REQUIRE_PRINCIPAL=false — owned sessions are protected, but headerless callers can create/share anonymous sessions; set REQUIRE_PRINCIPAL=true for multi-tenant",
@@ -1046,6 +1050,9 @@ async function main() {
         ...(sessionPolicyStore ? { sessionPolicyStore } : {}),
         ...(runtimeCapsResolver ? { runtimeCapsResolver } : {}),
         ...(fileSnapshotStore ? { fileSnapshotStore } : {}),
+        ...(backend && backend.kind !== "local" && !config.snapshotBlobStore
+            ? ((cap) => (cap !== undefined ? { snapshotBlobSqlCapBytes: cap } : {}))(config.snapshotBlobSqlMaxBytes ?? (backend.kind === "mysql" ? SQL_BLOB_DEFAULT_MAX_BYTES : undefined))
+            : {}),
         ...(executionEnvFactory ? { executionEnvFactory } : {}),
         ...(lspManager ? { lspManager } : {}),
         onBackgroundChildEvent: fleetBackgroundChildPublisher(fleetBus, (msg, fields) => logger.info(msg, fields)),

package/dist/plugins/blob-backend.d.ts

@@ -1,5 +1,10 @@
 import type { Pool as MysqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
+export declare const SQL_BLOB_DEFAULT_MAX_BYTES = 6291456;
+export declare class BlobTooLargeError extends Error {
+    readonly code: "blob_too_large_for_sql";
+    constructor(byteLen: number, capBytes: number);
+}
 export interface BlobBackend {
     putBlob(hash: string, bytes: Uint8Array): Promise<void>;
     getBlob(hash: string): Promise<Uint8Array | undefined>;
@@ -9,7 +14,8 @@ export interface BlobBackend {
 export declare class SqlBlobBackend implements BlobBackend {
     private readonly dialect;
     private readonly pool;
-    constructor(dialect: "tidb" | "pg", pool: MysqlPool | PgPool);
+    private readonly capBytes;
+    constructor(dialect: "tidb" | "pg", pool: MysqlPool | PgPool, maxBytes?: number);
     putBlob(hash: string, bytes: Uint8Array): Promise<void>;
     getBlob(hash: string): Promise<Uint8Array | undefined>;
     hasBlobs(hashes: string[]): Promise<Set<string>>;

package/dist/plugins/blob-backend.js

@@ -1,6 +1,17 @@
 import { createHash } from "node:crypto";
 import { presignS3Url } from "./s3-presign.js";
 const BLOB_GC_GRACE_MS = 3_600_000;
+export const SQL_BLOB_DEFAULT_MAX_BYTES = 6_291_456;
+export class BlobTooLargeError extends Error {
+    code = "blob_too_large_for_sql";
+    constructor(byteLen, capBytes) {
+        super(`blob of ${byteLen} bytes exceeds the SQL snapshot-blob cap (${capBytes} bytes): a single-row INSERT this large ` +
+            `hits TiDB's txn-entry-size-limit (default 6MiB) or the mysql-protocol max_allowed_packet (~2x text-protocol ` +
+            `inflation). Configure object storage (MINIO_ENDPOINT/MINIO_ACCESS_KEY/MINIO_SECRET_KEY) for large snapshot ` +
+            `blobs, or override the cap with SNAPSHOT_BLOB_SQL_MAX_BYTES if your deployment raised those limits.`);
+        this.name = "BlobTooLargeError";
+    }
+}
 const MINIO_OP_CONCURRENCY = 16;
 async function mapBounded(items, limit, fn) {
     let i = 0;
@@ -15,11 +26,15 @@ async function mapBounded(items, limit, fn) {
 export class SqlBlobBackend {
     dialect;
     pool;
-    constructor(dialect, pool) {
+    capBytes;
+    constructor(dialect, pool, maxBytes) {
         this.dialect = dialect;
         this.pool = pool;
+        this.capBytes = maxBytes ?? (dialect === "tidb" ? SQL_BLOB_DEFAULT_MAX_BYTES : Number.POSITIVE_INFINITY);
     }
     async putBlob(hash, bytes) {
+        if (bytes.byteLength > this.capBytes)
+            throw new BlobTooLargeError(bytes.byteLength, this.capBytes);
         if (this.dialect === "tidb") {
             await this.pool.query("INSERT INTO snapshot_blob (blob_hash, byte_len, bytes, created_at) VALUES (?,?,?,?) ON DUPLICATE KEY UPDATE created_at = VALUES(created_at)", [hash, bytes.byteLength, Buffer.from(bytes), new Date()]);
         }

package/dist/plugins/store-backend.d.ts

@@ -93,6 +93,7 @@ export interface StoreBackend {
     pgPool(): PgPool | undefined;
     dbNowMs?(): Promise<number>;
 }
+export declare function assertCloudSnapshotBlobPosture(kind: "mysql" | "pg" | "local", config: Pick<ServiceConfig, "snapshotBlobStore" | "snapshotBlobAllowSql">): void;
 export declare function snapshotBoundsFromConfig(config: ServiceConfig): FileSnapshotBounds;
 export declare function createStoreBackend(config: ServiceConfig): StoreBackend | undefined;
 //# sourceMappingURL=store-backend.d.ts.map

package/dist/plugins/store-backend.js

@@ -21,7 +21,7 @@ import { TiDBWorkflowJournalStore } from "./tidb-workflow-journal-store.js";
 import { PgWorkflowJournalStore } from "./pg-workflow-journal-store.js";
 import { TiDBFileSnapshotStore } from "./tidb-file-snapshot-store.js";
 import { PgFileSnapshotStore } from "./pg-file-snapshot-store.js";
-import { MinioBlobBackend } from "./blob-backend.js";
+import { MinioBlobBackend, SqlBlobBackend } from "./blob-backend.js";
 import { createTidbPool, ensureSchema as ensureTidbSchema } from "./tidb-pool.js";
 import { createPgPool, ensurePgSchema, pgPoolOptions } from "./pg-pool.js";
 import { TiDBRunStore } from "./tidb-run-store.js";
@@ -47,7 +47,7 @@ import { PgSessionStore } from "./pg-session-storage.js";
 function snapshotBlobBackend(config, dialect, pool) {
     const s = config.snapshotBlobStore;
     if (!s)
-        return undefined;
+        return new SqlBlobBackend(dialect, pool, config.snapshotBlobSqlMaxBytes);
     return new MinioBlobBackend({
         endpoint: s.endpoint,
         bucket: s.bucket,
@@ -58,6 +58,15 @@ function snapshotBlobBackend(config, dialect, pool) {
         ...(s.presignTtlSec ? { presignTtlSec: s.presignTtlSec } : {}),
     }, { dialect, pool });
 }
+export function assertCloudSnapshotBlobPosture(kind, config) {
+    if (kind === "local" || config.snapshotBlobStore || config.snapshotBlobAllowSql)
+        return;
+    throw new Error("cloud deployments (DB_BACKEND=mysql|pg) must configure object storage for snapshot blobs " +
+        "(MINIO_ENDPOINT/MINIO_ACCESS_KEY/MINIO_SECRET_KEY): single-row SQL blob writes hit TiDB's " +
+        "txn-entry-size-limit (default 6MiB) / the mysql-protocol packet limit (bytes belong in object storage — " +
+        "same ruling as the D-1 attachment store). Single-box/test rigs may explicitly opt out with " +
+        "SNAPSHOT_BLOB_ALLOW_SQL_BYTES=true (a per-blob cap then applies; oversized blobs are rejected 413).");
+}
 export function snapshotBoundsFromConfig(config) {
     const mb = config.rewindSnapshotMaxMb;
     return mb !== undefined ? { ...DEFAULT_SNAPSHOT_BOUNDS, maxBytes: Math.round(mb * 1024 * 1024) } : DEFAULT_SNAPSHOT_BOUNDS;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "1.294.0",
+  "version": "1.296.0",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",