@sema-agent/server 1.293.0 → 1.295.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/hooks/hook-runner.js

@@ -1,8 +1,10 @@
 import { spawn } from "node:child_process";
+import { hostShell, resolveHostShell } from "../plugins/host-platform.js";
 import { HooksConfig, DEFAULT_HOOK_TIMEOUT_SECONDS, HOOK_EVENT_OWNER, } from "@sema-agent/registry-core/hooks";
 import { redactSecrets } from "../trace/redact.js";
 import { ccPromptSystemFor, wrapCondition, parseCcVerdict, CC_EVALUATOR_MAX_OUTPUT_TOKENS } from "./cc-stop-prompt.js";
 import { renderBranchTranscript } from "./branch-transcript.js";
+void resolveHostShell().catch(() => undefined);
 export const MAX_HOOK_ENTRIES_PER_EVENT = 32;
 export const MAX_HOOK_COMMAND_CHARS = 8_192;
 export const MAX_HOOK_TIMEOUT_SECONDS = 600;
@@ -144,7 +146,8 @@ function runCommandHook(entry, payload, ctx) {
         const timeoutMs = Math.min(entry.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS, MAX_HOOK_TIMEOUT_SECONDS) * 1000;
         let child;
         try {
-            child = spawn("/bin/sh", ["-c", entry.command], {
+            const sh = hostShell();
+            child = spawn(sh.shell, [...sh.args, entry.command], {
                 cwd: ctx.cwd,
                 env: hookEnv(ctx),
                 stdio: ["pipe", "pipe", "pipe"],
@@ -203,7 +206,8 @@ function fireAsyncCommandHook(entry, payload, ctx, event) {
     try {
         const rewake = entry.asyncRewake === true;
         const timeoutMs = Math.min(entry.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS, MAX_HOOK_TIMEOUT_SECONDS) * 1000;
-        const child = spawn("/bin/sh", ["-c", entry.command], {
+        const sh = hostShell();
+        const child = spawn(sh.shell, [...sh.args, entry.command], {
             cwd: ctx.cwd,
             env: hookEnv(ctx),
             stdio: ["pipe", "ignore", rewake ? "pipe" : "ignore"],

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

@@ -4062,6 +4062,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/host-platform.js

@@ -1,10 +1,16 @@
 import { getShellConfig, killProcessTree, signalProcessTree } from "@sema-agent/core";
 export const IS_WIN32 = process.platform === "win32";
-const POSIX_SHELL = { shell: "/bin/sh", args: ["-c"] };
+const POSIX_SH_FALLBACK = { shell: "/bin/sh", args: ["-c"] };
 let cachedWinShell;
+let cachedPosixShell;
 export async function resolveHostShell() {
-    if (!IS_WIN32)
-        return POSIX_SHELL;
+    if (!IS_WIN32) {
+        if (cachedPosixShell)
+            return cachedPosixShell;
+        const posixCfg = await getShellConfig(process.env.HOST_SHELL_PATH || undefined);
+        cachedPosixShell = posixCfg.ok ? { shell: posixCfg.value.shell, args: posixCfg.value.args } : POSIX_SH_FALLBACK;
+        return cachedPosixShell;
+    }
     if (cachedWinShell)
         return cachedWinShell;
     const custom = process.env.HOST_SHELL_PATH;
@@ -18,14 +24,16 @@ export async function resolveHostShell() {
     return cachedWinShell;
 }
 export function hostShell() {
-    if (!IS_WIN32)
-        return POSIX_SHELL;
+    if (!IS_WIN32) {
+        return cachedPosixShell ?? POSIX_SH_FALLBACK;
+    }
     if (!cachedWinShell)
         throw new Error("host shell not resolved yet — resolveHostShell() must settle before any spawn (shellReady ordering bug)");
     return cachedWinShell;
 }
 export function resetHostShellCacheForTest() {
     cachedWinShell = undefined;
+    cachedPosixShell = undefined;
 }
 export function spawnGroupOptions() {
     return IS_WIN32 ? { detached: false, windowsHide: true } : { detached: true };

package/dist/plugins/remote-env-local-docker.d.ts

@@ -114,6 +114,9 @@ export declare class RemoteLocalDockerExecutionEnv implements RemoteExecutionEnv
     private execArgv;
     private execRaw;
     private docker;
+    private containerShell;
+    private containerShellProbed;
+    private probeContainerShell;
     private ensureConnectedExec;
     private fsReady;
     private tempResult;

package/dist/plugins/remote-env-local-docker.js

@@ -480,7 +480,7 @@ export class RemoteLocalDockerExecutionEnv {
         const mergedEnv = { ...(this.cfg.env ?? {}), ...(env ?? {}) };
         for (const [k, v] of Object.entries(mergedEnv))
             args.push("-e", `${k}=${v}`);
-        args.push(this.containerName, "/bin/sh", "-c", command);
+        args.push(this.containerName, this.containerShell, "-c", command);
         return args;
     }
     execRaw(command) {
@@ -547,14 +547,31 @@ export class RemoteLocalDockerExecutionEnv {
             });
         });
     }
+    containerShell = "/bin/sh";
+    containerShellProbed = false;
+    async probeContainerShell() {
+        if (this.containerShellProbed)
+            return;
+        this.containerShellProbed = true;
+        try {
+            const r = await this.docker(this.withHostFlag(["exec", this.containerName, "/bin/sh", "-c", "command -v bash"]), { timeoutMs: this.cfg.controlTimeoutMs });
+            if (r.ok && r.value.exitCode === 0 && r.value.stdout.trim().length > 0)
+                this.containerShell = "bash";
+        }
+        catch {
+        }
+    }
     async ensureConnectedExec() {
         if (this.destroyed)
             return { ok: false, error: new ExecutionError("shell_unavailable", "execution env already destroyed") };
-        if (this.containerId)
+        if (this.containerId) {
+            await this.probeContainerShell();
             return ok(undefined);
+        }
         const c = await this.connect();
         if (!c.ok)
             return { ok: false, error: new ExecutionError("shell_unavailable", `local-docker connect failed: ${c.error.message}`, c.error) };
+        await this.probeContainerShell();
         return ok(undefined);
     }
     async fsReady(p) {

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.293.0",
+  "version": "1.295.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",