@sema-agent/server 7.140.0 → 7.141.0

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

@@ -2,6 +2,7 @@ import path from "node:path";
 import { Sandbox, CommandExitError, FileType } from "e2b";
 import { FileError, ExecutionError, RemoteExecutionError, RollingTailBuffer, markTruncated, } from "@sema-agent/core";
 import { capabilitiesFor } from "../execution-lane-caps.js";
+import { ADAPTER_START, BOOTSTRAP_START, createSandboxReadFloor, e2bFloorCommand, engineStart, } from "./sandbox-read-floor.js";
 import { LANE_HOME_PROBE_COMMAND, LaneHomeSeat } from "../lane-home-probe.js";
 import { fileErrorFromExec } from "./remote-env-file-error.js";
 import { appendFileStaged, rewriteAppend, numEnvOr, runSymlinkChain, shellQuote, writeFileStaged } from "./remote-shell.js";
@@ -52,8 +53,90 @@ export class RemoteContainerExecutionEnv {
         this.cwd = this.cfg.mountPath;
         this.homeSeat = new LaneHomeSeat(PROVIDER, config);
         this.sandboxApi = deps.sandboxApi ?? Sandbox;
+        this.floor = deps.readFloor ?? createSandboxReadFloor({ lane: PROVIDER, knob: config.sandboxReadFloor, ...(config.logger !== undefined ? { logger: config.logger } : {}) });
+        this.capabilities = capabilitiesFor({ remoteExec: { provider: PROVIDER }, sandboxReadFloor: config.sandboxReadFloor });
+    }
+    capabilities;
+    floor;
+    startIn(start, command, envs) {
+        const launch = this.floor.wrap(start);
+        return launch.ok ? ok(e2bFloorCommand(launch.value, command, envs)) : launch;
+    }
+    runIn(sbx, s, opts = {}) {
+        const { background, ...rest } = opts;
+        const o = { ...rest, ...(s.user !== undefined ? { user: s.user } : {}), ...(s.envs !== undefined ? { envs: s.envs } : {}) };
+        return background ? sbx.commands.run(s.cmd, { ...o, background: true }) : sbx.commands.run(s.cmd, o);
+    }
+    floorTransport(sbx) {
+        const bootstrap = async (command) => {
+            const s = this.startIn(BOOTSTRAP_START, command, undefined);
+            if (!s.ok)
+                return { ok: false, error: s.error.message };
+            try {
+                const r = await this.rpc("floor.bootstrap", (signal) => this.runIn(sbx, s.value, { signal, timeoutMs: this.cfg.rpcTimeoutMs }));
+                return { ok: true, exitCode: r.exitCode, stdout: r.stdout, stderr: r.stderr };
+            }
+            catch (e) {
+                if (e instanceof CommandExitError)
+                    return { ok: true, exitCode: e.exitCode, stdout: e.stdout, stderr: e.stderr };
+                return { ok: false, error: errMsg(e) };
+            }
+        };
+        return {
+            bootstrap,
+            place: async (dest, bytes) => {
+                const dir = path.posix.dirname(dest);
+                const tmp = `${dest}.${Math.random().toString(16).slice(2, 10)}`;
+                const mk = await bootstrap(`umask 022 && mkdir -p ${shellQuote(dir)}`);
+                if (!mk.ok || mk.exitCode !== 0)
+                    return { ok: false, error: mk.ok ? mk.stderr.trim() || `exit ${mk.exitCode}` : mk.error };
+                try {
+                    const ab = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+                    await this.rpc("files.write", (signal) => sbx.files.write(tmp, ab, { user: "root", signal }), undefined, this.cfg.dataTimeoutMs);
+                }
+                catch (e) {
+                    return { ok: false, error: errMsg(e) };
+                }
+                const mv = await bootstrap(`chmod 0755 ${shellQuote(tmp)} && mv -f ${shellQuote(tmp)} ${shellQuote(dest)}`);
+                return mv.ok && mv.exitCode === 0 ? { ok: true } : { ok: false, error: mv.ok ? mv.stderr.trim() || `exit ${mv.exitCode}` : mv.error };
+            },
+            openRelay: (identity, command, events) => {
+                let handle;
+                let closed = false;
+                const pending = [];
+                const user = (() => {
+                    switch (identity) {
+                        case "root":
+                            return { user: "root" };
+                        case "exec-user":
+                            return {};
+                    }
+                })();
+                sbx.commands
+                    .run(command, { background: true, stdin: true, timeoutMs: 0, ...user, onStdout: (d) => events.data(d) })
+                    .then((h) => {
+                    handle = h;
+                    if (closed)
+                        return void h.kill().catch(() => { });
+                    for (const line of pending.splice(0))
+                        void h.sendStdin(line).catch(() => { });
+                    h.wait().then(() => events.closed("relay exited"), (e) => events.closed(`relay exited: ${errMsg(e)}`));
+                }, (e) => events.closed(`relay start failed: ${errMsg(e)}`));
+                return {
+                    send: (line) => {
+                        if (handle !== undefined)
+                            void handle.sendStdin(line).catch(() => { });
+                        else
+                            pending.push(line);
+                    },
+                    close: () => {
+                        closed = true;
+                        void handle?.kill().catch(() => { });
+                    },
+                };
+            },
+        };
     }
-    capabilities = capabilitiesFor({ remoteExec: { provider: "e2b" } });
     workspaceHandle() {
         if (!this.handle) {
             throw new RemoteExecutionError("connect_failed", "workspaceHandle() called before connect()");
@@ -66,8 +149,12 @@ export class RemoteContainerExecutionEnv {
     }
     async startBackground(command) {
         const conn = await this.ensureConnected();
-        if (conn.ok)
-            await conn.value.commands.run(command, { background: true });
+        if (!conn.ok)
+            return;
+        const s = this.startIn(engineStart(undefined), command, undefined);
+        if (!s.ok)
+            return void this.cfg.logger?.warn?.("remote_env_background_refused", { error: s.error.message });
+        await this.runIn(conn.value, s.value, { background: true });
     }
     async connect(config) {
         if (config?.snapshotId) {
@@ -109,6 +196,11 @@ export class RemoteContainerExecutionEnv {
                 this.cfg.metrics?.inc("remote_env_connect_total", { provider: PROVIDER, result: "error" });
                 return { ok: false, error: home ?? new RemoteExecutionError("connect_failed", "execution env destroyed during connect") };
             }
+            await this.floor.attach(this.floorTransport(sbx), { origin: "created", workspaceRoot: this.cfg.mountPath });
+            if (this.destroyed) {
+                await sbx.kill().catch(() => { });
+                return { ok: false, error: new RemoteExecutionError("connect_failed", "execution env destroyed during connect") };
+            }
             this.sbx = sbx;
             this.paused = false;
             this.startKeepAlive();
@@ -180,6 +272,12 @@ export class RemoteContainerExecutionEnv {
                 await sbx.kill().catch(() => { });
                 return { ok: false, error: new RemoteExecutionError("connect_failed", "execution env destroyed during resume") };
             }
+            const restoredRoot = options?.priorHandle?.mountPath ?? this.cfg.mountPath;
+            await this.floor.attach(this.floorTransport(sbx), { origin: "resumed", workspaceRoot: restoredRoot });
+            if (this.destroyed) {
+                await sbx.kill().catch(() => { });
+                return { ok: false, error: new RemoteExecutionError("connect_failed", "execution env destroyed during resume") };
+            }
             const home = await this.homeVerdict(sbx, options?.abortSignal);
             if (this.destroyed) {
                 await sbx.kill().catch(() => { });
@@ -194,7 +292,6 @@ export class RemoteContainerExecutionEnv {
             this.paused = false;
             this.startKeepAlive();
             this.cfg.logger?.info?.("remote_env_resume", { requested: snapshotId, connected: sbx.sandboxId });
-            const restoredRoot = options?.priorHandle?.mountPath ?? this.cfg.mountPath;
             this.cwd = restoredRoot;
             this.handle = { sandboxId: sbx.sandboxId, provider: PROVIDER, mountPath: restoredRoot, snapshotId, sessionToken: sbx.sandboxId };
             this.cfg.metrics?.inc("remote_env_resume_total", { provider: PROVIDER, result: "ok" });
@@ -227,7 +324,10 @@ export class RemoteContainerExecutionEnv {
             return undefined;
         let probe;
         try {
-            const r = await this.rpc("sandbox.home", (s) => sbx.commands.run(LANE_HOME_PROBE_COMMAND, { signal: s }), signal);
+            const start = this.startIn(ADAPTER_START, LANE_HOME_PROBE_COMMAND, undefined);
+            if (!start.ok)
+                throw start.error;
+            const r = await this.rpc("sandbox.home", (s) => this.runIn(sbx, start.value, { signal: s }), signal);
             probe = r.exitCode === 0 ? { ok: true, stdout: r.stdout } : { ok: false, reason: `exit ${r.exitCode}` };
         }
         catch (e) {
@@ -265,6 +365,7 @@ export class RemoteContainerExecutionEnv {
         this.destroyed = true;
         this.connecting = undefined;
         this.stopKeepAlive();
+        this.floor.dispose();
         await this.disposeBackgroundShells();
         const sbx = this.sbx;
         this.sbx = undefined;
@@ -285,12 +386,21 @@ export class RemoteContainerExecutionEnv {
         await this.destroy();
     }
     async exec(command, options) {
+        return this.execAs(engineStart(options?.readFloor), command, options);
+    }
+    execInternal(command, options) {
+        return this.execAs(ADAPTER_START, command, options);
+    }
+    async execAs(start, command, options) {
         if (options?.abortSignal?.aborted)
             return { ok: false, error: new ExecutionError("aborted", "exec aborted before start") };
         const conn = await this.ensureConnected();
         if (!conn.ok)
             return { ok: false, error: new ExecutionError("shell_unavailable", `remote connect failed: ${conn.error.message}`, conn.error) };
         const sbx = conn.value;
+        const launch = this.startIn(start, command, options?.env);
+        if (!launch.ok)
+            return launch;
         this.activeCommands++;
         const detachSignal = options?.detachSignal;
         const tee = detachSignal
@@ -315,10 +425,9 @@ export class RemoteContainerExecutionEnv {
         let starting;
         let startCut = false;
         try {
-            handle = await this.rpc("commands.run", () => (starting = sbx.commands.run(command, {
+            handle = await this.rpc("commands.run", () => (starting = this.runIn(sbx, launch.value, {
                 background: true,
                 cwd: this.resolve(options?.cwd ?? this.cwd),
-                ...(options?.env ? { envs: options.env } : {}),
                 timeoutMs: tee
                     ? Math.max(this.commandTimeoutMs(options?.timeout), (E2B_BG_MAX_TIMEOUT_SEC + E2B_BG_PROVIDER_BACKSTOP_PAD_SEC) * 1000)
                     : this.commandTimeoutMs(options?.timeout),
@@ -442,6 +551,9 @@ export class RemoteContainerExecutionEnv {
         if (!conn.ok)
             throw conn.error;
         const sbx = conn.value;
+        const launch = this.startIn(engineStart(undefined), command, options?.env);
+        if (!launch.ok)
+            throw new RemoteExecutionError("unsupported", launch.error.message, launch.error);
         const queue = [];
         let finished = false;
         let failure;
@@ -468,10 +580,9 @@ export class RemoteContainerExecutionEnv {
         let handle;
         let starting;
         try {
-            handle = await this.rpc("commands.run", () => (starting = sbx.commands.run(command, {
+            handle = await this.rpc("commands.run", () => (starting = this.runIn(sbx, launch.value, {
                 background: true,
                 cwd: this.resolve(options?.cwd ?? this.cwd),
-                ...(options?.env ? { envs: options.env } : {}),
                 timeoutMs: this.commandTimeoutMs(options?.timeout),
                 onStdout: (d) => push("stdout", d),
                 onStderr: (d) => push("stderr", d),
@@ -599,12 +710,14 @@ export class RemoteContainerExecutionEnv {
                 if (!conn.ok)
                     throw new Error(`remote connect failed: ${conn.error.message}`);
                 const sbx = conn.value;
+                const launch = self.startIn(engineStart(options?.readFloor), command, options?.env);
+                if (!launch.ok)
+                    throw launch.error;
                 const stdout = { tail: new RollingTailBuffer(), total: 0, cursor: 0 };
                 const stderr = { tail: new RollingTailBuffer(), total: 0, cursor: 0 };
-                const handle = await self.rpc("commands.run.bg", () => sbx.commands.run(command, {
+                const handle = await self.rpc("commands.run.bg", () => self.runIn(sbx, launch.value, {
                     background: true,
                     cwd: self.resolve(options?.cwd ?? self.cwd),
-                    ...(options?.env ? { envs: options.env } : {}),
                     timeoutMs: (ctx.bgTimeoutSec + E2B_BG_PROVIDER_BACKSTOP_PAD_SEC) * 1000,
                     onStdout: (d) => {
                         const b = Buffer.from(d, "utf8");
@@ -722,7 +835,7 @@ export class RemoteContainerExecutionEnv {
                     return { ok: false, error: this.fileError(e, dest, signal) };
                 }
             },
-            run: (cmd, signal) => this.exec(cmd, { cwd: "/", ...(signal !== undefined ? { abortSignal: signal } : {}) }),
+            run: (cmd, signal) => this.execInternal(cmd, { cwd: "/", ...(signal !== undefined ? { abortSignal: signal } : {}) }),
         };
     }
     async writeFile(p, content, abortSignal) {
@@ -764,7 +877,7 @@ export class RemoteContainerExecutionEnv {
     }
     async readLink(p, abortSignal) {
         const abs = this.resolve(p);
-        const r = await this.exec(`readlink -- ${shellQuote(abs)}`, { abortSignal });
+        const r = await this.execInternal(`readlink -- ${shellQuote(abs)}`, { abortSignal });
         if (!r.ok)
             return { ok: false, error: fileErrorFromExec(r.error, abs) };
         if (r.value.exitCode !== 0)
@@ -772,11 +885,11 @@ export class RemoteContainerExecutionEnv {
         return ok(r.value.stdout.trim());
     }
     async canonicalChain(p, abortSignal) {
-        return runSymlinkChain(this.resolve(p), (cmd) => this.exec(cmd, { abortSignal }));
+        return runSymlinkChain(this.resolve(p), (cmd) => this.execInternal(cmd, { abortSignal }));
     }
     async canonicalPath(p, abortSignal) {
         const abs = this.resolve(p);
-        const r = await this.exec(`realpath -- ${shellQuote(abs)}`, { abortSignal });
+        const r = await this.execInternal(`realpath -- ${shellQuote(abs)}`, { abortSignal });
         if (!r.ok)
             return { ok: false, error: fileErrorFromExec(r.error, abs) };
         if (r.value.exitCode !== 0) {
@@ -823,7 +936,7 @@ export class RemoteContainerExecutionEnv {
         const abs = this.resolve(p);
         if (options?.recursive) {
             const flags = options.force ? "-rf" : "-r";
-            const r = await this.exec(`rm ${flags} -- ${shellQuote(abs)}`, { abortSignal: options.abortSignal });
+            const r = await this.execInternal(`rm ${flags} -- ${shellQuote(abs)}`, { abortSignal: options.abortSignal });
             if (!r.ok)
                 return { ok: false, error: fileErrorFromExec(r.error, abs) };
             if (r.value.exitCode !== 0)
@@ -842,14 +955,14 @@ export class RemoteContainerExecutionEnv {
         }
     }
     async createTempDir(prefix = "tmp-", abortSignal) {
-        const r = await this.exec(`mktemp -d -t ${shellQuote(`${prefix}XXXXXX`)}`, { abortSignal });
+        const r = await this.execInternal(`mktemp -d -t ${shellQuote(`${prefix}XXXXXX`)}`, { abortSignal });
         return this.tempResult(r, "mktemp -d");
     }
     async createTempFile(options) {
         const prefix = options?.prefix ?? "";
         const suffix = options?.suffix ?? "";
         const suffixArg = suffix ? `--suffix=${shellQuote(suffix)} -t` : "-t";
-        const r = await this.exec(`mktemp ${suffixArg} ${shellQuote(`${prefix}XXXXXX`)}`, { abortSignal: options?.abortSignal });
+        const r = await this.execInternal(`mktemp ${suffixArg} ${shellQuote(`${prefix}XXXXXX`)}`, { abortSignal: options?.abortSignal });
         return this.tempResult(r, "mktemp");
     }
     resolve(p) {

package/dist/plugins/remote-env-k8s.d.ts

@@ -3,6 +3,8 @@ import { type SpaceCommitFence } from "../workspace-space-commit.js";
 import { type CacheMissMemory, type WorkspaceCacheCapability } from "../workspace-cache.js";
 import { type SandboxEgressGap, type SandboxIpv6 } from "../sandbox-egress-policy.js";
 import { FileError, ExecutionError, RemoteExecutionError, type ExecutionEnv, type RemoteExecutionEnv, type WorkspaceHandle, type FileInfo, type Result, type SymlinkChain, type OutputChunk, type ExecStreamOptions, type RemoteConnectConfig, type SnapshotId, type SessionToken, type VmLifecycleOptions, type ExecutionEnvFactory, type BackgroundShellCapability, type BackgroundShellId, type BackgroundShellError, type BackgroundSpawnOptions, type BackgroundPoll, type ExecutionEnvCapabilities } from "@sema-agent/core";
+import { type SandboxReadFloorKnob } from "../execution-lane-caps.js";
+import { type SandboxReadFloor } from "./sandbox-read-floor.js";
 import type { PodSpecPatch } from "./k8s-exec-protocol.js";
 import { type LaneHomeConfig } from "../lane-home-probe.js";
 type ExecOpts = Parameters<ExecutionEnv["exec"]>[1];
@@ -162,6 +164,8 @@ export interface K8sEnvConfig extends LaneHomeConfig {
         readonly image: string;
         readonly origins: readonly string[];
     };
+    /** `SANDBOX_READ_FLOOR`(keep | off;缺席 ⇒ keep):本 pod 守不守读拒表的字节地板 = 读地板模块服务本车道 ∧ 本键不是 off(`sandbox-read-floor.ts`)。 */
+    sandboxReadFloor?: SandboxReadFloorKnob;
 }
 import { type SandboxSecretSeatKind, type SandboxSecretVerb } from "./k8s-exec-protocol.js";
 export { type PodSpecPatch, applyPodSpecPatch } from "./k8s-exec-protocol.js";
@@ -179,6 +183,8 @@ export interface ExecSocket {
     on(event: "open" | "message" | "close" | "error", listener: (...args: unknown[]) => void): void;
     close(): void;
     terminate?(): void;
+    /** 写一帧(读地板中继的 stdin:首字节 = 通道 0)。只读的 exec 不用;没有它的套接字起不了中继(附着按 `relay_silent` 拒)。 */
+    send?(data: Buffer): void;
 }
 /**
  * Test seam ([ref] §9.3 fault-injection): inject the REST `request` and/or the exec-socket factory, so pod
@@ -199,6 +205,8 @@ export interface K8sEnvDeps {
     connectOnce?: (signal?: AbortSignal) => Promise<ConnectResult>;
     /** Worker-side object-store requests (the space pointer, listing, deletes). Default: global `fetch`. */
     fetch?: typeof fetch;
+    /** 这只环境手里的读地板模块(缺席 ⇒ `createSandboxReadFloor` 按旋钮选;钉注入守地板的模块)。能力块的 `keepsReadFloor` 读它的状态。 */
+    readFloor?: SandboxReadFloor;
 }
 /**
  * One run's space occupant — the space key of both lanes keyed by it (the space lane, the cache volume) — a closed set of three
@@ -290,8 +298,10 @@ export type SandboxLeaseWrite = {
     readonly message: string;
 };
 export declare class RemoteK8sExecutionEnv implements RemoteExecutionEnv, BackgroundShellCapability {
-    /** 能力块的唯一作者 = `capabilitiesFor`(`execution-lane-caps.ts`;逐键表态与理由在那里,本类零能力字面量)。快照店是它的输入(构造期铸,见下)。 */
+    /** 能力块的唯一作者 = `capabilitiesFor`(`execution-lane-caps.ts`;逐键表态与理由在那里,本类零能力字面量)。快照店与读地板旋钮是它的输入(构造期铸,见下);{@link floor} 由同一只判据、同一个旋钮值选出。 */
     readonly capabilities: ExecutionEnvCapabilities;
+    /** 读拒表字节地板模块:pod 里每一次 exec 起动都先经它的 `wrap`({@link runExec},唯一接缝)。 */
+    private readonly floor;
     cwd: string;
     private podName?;
     /** Cluster-internal pod address, captured when the pod reaches Running — the LSP `getHost` surface.
@@ -731,6 +741,15 @@ export declare class RemoteK8sExecutionEnv implements RemoteExecutionEnv, Backgr
      * being claimed) uploads nothing, and is that same upload failure.
      */
     private persistWorkspace;
+    /**
+     * 守地板的 pod 的二进制座:本包带的每个架构一只 ConfigMap(名 = 架构 + 摘要前 16 位,不可变;201 = 新建,409 = 同名同内容已在)。建不成
+     * ⇒ 告诉地板模块(附着按 `binary_digest` 拒,pod 照起、不带这只卷);不守地板 ⇒ `undefined`(pod 与改前逐字同)。部署前提:命名空间里 configmaps 的 create。
+     */
+    private ensureFloorSeat;
+    /** 地板模块的三件原语。引导命令经 {@link runExec}(起动形 `bootstrap`:只在附着中合法);放置由 pod 的只读卷完成(自检 `--digest` 证字节);
+     *  中继 = 一只开着 stdin 的长连 exec(与命令同一身份 —— k8s 的 exec 没有换身份的口),stdout 帧是中继的问,stdin 帧(首字节 0)是判官的答。 */
+    private floorTransport;
+    /** exec 的 URL:`argv` 原样作 `command` 参数(唯一来源 = {@link runExec} 里模块答案的编码,或地板模块自己的中继);`stdin` ⇒ 开 stdin 通道。 */
     private execUrl;
     /**
      * Run a command over the exec WebSocket. Frames: byte0=channel (1 stdout / 2 stderr / 3 status JSON with the