@allbluecn/web-app 0.19.2 → 0.19.4

package/src/server/ai-gateway/sandbox/browser-policy.ts

@@ -20,8 +20,15 @@
 // 其余 abort——被拦 URL 经 onBlocked 回调上抛给执行器累积 networkLog。
 //
 // 白名单口径（fail-closed）：仅 http(s) scheme + targetEnv 域（精确 host 及其子域，
-// targetEnv 兼容「URL」与「裸域名标识」两种形态）+ 本机回环（localhost/127.0.0.1/::1）。
-// 相似域后缀欺骗（target.a.com.evil.io）不匹配 endsWith("." + host)，天然拒绝。
+// targetEnv 兼容「URL」与「裸域名标识」两种形态）+ 条件开启的本机回环。相似域
+// 后缀欺骗（target.a.com.evil.io）不匹配 endsWith("." + host)，天然拒绝。
+//
+// SSRF 边界（审计 2026-10-25 A3x-2 🟠，已证实）：执行器跑在服务端（playwright），
+// targetEnv 来自用户可配置的 TestRun.targetEnv。回环地址（localhost/127.0.0.0/8/
+// 0.0.0.0/::1）恒放行会让云端部署的沙箱浏览器探测服务器本机各端口——改为仅
+// desktop（用户自担）或显式 AI_BROWSER_ALLOW_LOOPBACK=true 时放行；云端默认
+// fail-closed。targetEnv 本身若指向内网属运维显式配置（与 fetch-guard 的
+// allowPrivate 同理，须在 targetEnv 写入来源做校验，见 testcase 侧）。
 //
 // 纯服务端逻辑模块：只描述 playwright 的最小结构面（不 import playwright 运行时，
 // 真实 Page 结构兼容本接口），不触 DB，禁止引入 prisma。
@@ -40,8 +47,26 @@ export interface BrowserPolicyPage {
   ): unknown;
 }
 
-/** 本机回环白名单（targetEnv 未配置时仍可执行本机部署的冒烟） */
-const LOCAL_HOSTNAMES: ReadonlySet<string> = new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+/** 命名回环主机（IP 段形态见 isLoopbackHost） */
+const LOCAL_HOSTNAMES: ReadonlySet<string> = new Set(["localhost", "::1", "[::1]"]);
+
+/** 回环/未指定地址全集：127.0.0.0/8、0.0.0.0、::（含括号形态）。
+ * 导出供 testcase/automation-rerun 的 targetEnv→baseUrl 裁决复用（同一口径）。 */
+export function isLoopbackHost(hostname: string): boolean {
+  if (LOCAL_HOSTNAMES.has(hostname)) return true;
+  if (/^127(?:\.\d{1,3}){3}$/.test(hostname)) return true;
+  return hostname === "0.0.0.0" || hostname === "[::]" || hostname === "::";
+}
+
+/**
+ * 回环放行的部署形态开关：desktop（用户自担）或显式 AI_BROWSER_ALLOW_LOOPBACK=true
+ * （自托管本机冒烟的逃生门，与 fetch-guard 的 allowPrivate 显式声明同思路）。
+ * 云端 / DEPLOY_TARGET 未设时默认拒绝——服务器本机端口面不对用户可控导航开放。
+ */
+export function isLoopbackAllowedByDeployment(): boolean {
+  if ((process.env.DEPLOY_TARGET ?? "").trim() === "desktop") return true;
+  return process.env.AI_BROWSER_ALLOW_LOOPBACK === "true";
+}
 
 export interface NetworkPolicyVerdict {
   allowed: boolean;
@@ -49,6 +74,11 @@ export interface NetworkPolicyVerdict {
   reason: string;
 }
 
+export interface BrowserPolicyOptions {
+  /** 覆盖部署形态的回环放行判定（测试注入用；缺省按 isLoopbackAllowedByDeployment） */
+  allowLoopback?: boolean;
+}
+
 /** 从 targetEnv 提取白名单域：URL 形态取 hostname，裸域名标识原样作为 host */
 export function targetEnvHostname(targetEnv: string): string | null {
   const raw = targetEnv.trim();
@@ -63,10 +93,14 @@ export function targetEnvHostname(targetEnv: string): string | null {
 }
 
 /**
- * URL 白名单裁决（纯函数）：http(s) scheme + （targetEnv 域含子域 | 本机回环）。
- * 非法 URL 一律拒绝（fail-closed）。
+ * URL 白名单裁决（纯函数）：http(s) scheme + （targetEnv 域含子域 | 条件放行的
+ * 本机回环）。非法 URL 一律拒绝（fail-closed）。
  */
-export function isUrlAllowedByPolicy(url: string, targetEnv: string): NetworkPolicyVerdict {
+export function isUrlAllowedByPolicy(
+  url: string,
+  targetEnv: string,
+  opts?: BrowserPolicyOptions,
+): NetworkPolicyVerdict {
   let parsed: URL;
   try {
     parsed = new URL(url);
@@ -77,7 +111,8 @@ export function isUrlAllowedByPolicy(url: string, targetEnv: string): NetworkPol
     return { allowed: false, reason: `scheme-forbidden: ${parsed.protocol}` };
   }
   const hostname = parsed.hostname.toLowerCase();
-  if (LOCAL_HOSTNAMES.has(hostname)) return { allowed: true, reason: "allowed" };
+  const allowLoopback = opts?.allowLoopback ?? isLoopbackAllowedByDeployment();
+  if (allowLoopback && isLoopbackHost(hostname)) return { allowed: true, reason: "allowed" };
   const target = targetEnvHostname(targetEnv);
   if (!target) return { allowed: false, reason: "no-target-env" };
   if (hostname === target || hostname.endsWith(`.${target}`)) {
@@ -95,10 +130,11 @@ export async function applyBrowserNetworkPolicy(
   page: BrowserPolicyPage,
   targetEnv: string,
   onBlocked?: (url: string) => void,
+  opts?: BrowserPolicyOptions,
 ): Promise<void> {
   await page.route("**/*", async (route) => {
     const url = route.request().url();
-    const verdict = isUrlAllowedByPolicy(url, targetEnv);
+    const verdict = isUrlAllowedByPolicy(url, targetEnv, opts);
     if (verdict.allowed) {
       await route.continue();
       return;

package/src/server/ai-gateway/sandbox/harness-sandbox.ts

@@ -23,6 +23,7 @@ import {
   createSecrets,
   localSource,
 } from "@tanstack/ai-sandbox"
+import { randomUUID } from "node:crypto"
 import { InMemoryLockStore } from "@tanstack/ai/locks"
 import type { PgStreamDurabilityFactory } from "../durability/pg-stream"
 import { pgLockStore } from "../locks/pg-lock"
@@ -40,10 +41,20 @@ import { acpCompatibleText } from "@tanstack/ai-acp"
 import { opencodeText } from "@tanstack/ai-opencode"
 import type { SandboxCheckpointStore } from "@tanstack/ai-sandbox"
 
-/** 内存 checkpoint store 骨架——任务 14 占位，后续接 DB 持久化 */
+/**
+ * 内存 checkpoint store 骨架——任务 14 占位，后续接 DB 持久化。
+ *
+ * 占位不等于放任（审计 2026-10-25 🟡）：append 只增不删会让长生命周期进程
+ * 内存持续增长，故设条目上限 FIFO 淘汰；deleteHead 真删 head 指向条目；
+ * ownerToken 用 randomUUID（Date.now() 同毫秒并发即重复）；fence 单调递增
+ * （恒 0 使写者栅栏失效）。
+ */
+const MEMORY_CHECKPOINT_MAX_ENTRIES = 200
+
 function memoryCheckpointStore(): SandboxCheckpointStore {
   const checkpoints = new Map<string, unknown>()
   const heads = new Map<string, string>()
+  let fenceCounter = 0
   return {
     get: async (_id: string) => (checkpoints.get(_id) ?? null) as never,
     list: async (threadId: string) => {
@@ -55,25 +66,54 @@ function memoryCheckpointStore(): SandboxCheckpointStore {
     getHead: async (threadId: string) => heads.get(`thread:${threadId}`) ?? null,
     append: async (input: any) => {
       const tid = input?.writer?.threadId ?? "unknown"
-      const id = `thread:${tid}:${Date.now()}`
+      const id = `thread:${tid}:${Date.now()}-${randomUUID().slice(0, 8)}`
       checkpoints.set(id, input.checkpoint)
       heads.set(`thread:${tid}`, id)
+      // FIFO 淘汰：Map 迭代按插入序，删到上限以内（head 指向的条目若被淘汰，
+      // getHead 返回的 id 在 get 中自然落空——占位实现的已知边界）。
+      while (checkpoints.size > MEMORY_CHECKPOINT_MAX_ENTRIES) {
+        const oldest = checkpoints.keys().next().value
+        if (oldest === undefined) break
+        checkpoints.delete(oldest)
+      }
       return { headId: id } as any
     },
-    deleteHead: async () => undefined,
+    deleteHead: async (input: {
+      threadId: string
+      checkpointId: string
+    }) => {
+      // 仅当 input.checkpointId 仍是当前 head 时才删（防误删新 head）。
+      // heads 的 key 与 getHead 同前缀（`thread:<threadId>`），value 是完整
+      // checkpoint id（`thread:<threadId>:<ts>-<uuid>`）。
+      const headKey = `thread:${input.threadId}`
+      const headId = heads.get(headKey)
+      if (headId === undefined || headId !== input.checkpointId) return
+      heads.delete(headKey)
+      checkpoints.delete(headId)
+    },
     acquireWriter: async (threadId: string) => ({
       threadId,
       expiresAt: Date.now() + 60_000,
       renewAfterMs: 30_000,
       renew: () => Promise.resolve({ expiresAt: Date.now() + 60_000 } as any),
-      ownerToken: `token-${threadId}-${Date.now()}`,
-      fence: 0,
+      ownerToken: `token-${threadId}-${randomUUID()}`,
+      fence: ++fenceCounter,
       release: () => Promise.resolve(),
     }) as any,
     listBlobReferences: async () => [],
   } as never
 }
 
+/** 快照恢复的消息上限——与 persistence/message-store.ts 的 LOAD_THREAD_MAX_MESSAGES 同口径。 */
+const SANDBOX_LOAD_THREAD_MAX_MESSAGES = 100
+
+/**
+ * 单个快照 blob 的大小上限（审计 2026-10-25 🟠 残余项：result 列落 base64 无上限，
+ * 超大 blob 会把 Postgres 行撑爆）。workspace 快照以代码/文本文件为主，16MB 已远超
+ * 常规文件；超出即抛错（fail-fast，由快照层上报），绝不静默截断二进制。
+ */
+const SANDBOX_BLOB_MAX_BYTES = 16 * 1024 * 1024
+
 export interface BuildSandboxMiddlewareParams {
   threadId: string
   policyLevel: SandboxPolicyLevel
@@ -121,12 +161,25 @@ export async function buildSandboxMiddleware(
   middleware: ReturnType<typeof withSandbox>
   adapter?: AnyTextAdapter
 }> {
-  const { provider } = await resolveSandboxProvider()
+  const { provider, kind } = await resolveSandboxProvider()
+
+  // 审计 2026-10-25 ⚪：harness adapter 子进程内免审批执行（bypassPermissions /
+  // approvalPolicy=never）安全性完全押在外层沙箱隔离上；与无隔离的 local-process
+  // 组合 = 全程无人工闸门。desktop 用户自担可接受，其他形态显式告警一次。
+  if (params.adapterKind && kind === "local-process") {
+    console.warn(
+      "[sandbox] harness adapter 免审批执行运行在 local-process（无文件系统/网络隔离）之上：" +
+        "建议仅 desktop 形态使用，或改用云沙箱 provider 承载 harness。",
+    )
+  }
 
   // harness 型 provider 需要将后端 AI key 注入沙箱 env：
   // claudeCodeText 读 ANTHROPIC_API_KEY，codexText 读 CODEX_API_KEY。
   // 从 AiProviderConfig（enabled=true）读取用户已配置的 key 并解密，
   // 以 workspace.secrets 形式传入 defineSandbox，由 withSandbox 注入沙箱环境。
+  // ⚠ 边界（审计 2026-10-25 ⚪）：注入的 env 暴露给沙箱内任意进程（`printenv`
+  // 即得）——BYOK 自担风险（key 本属用户），desktop 形态可接受；harness provider
+  // 无「key 文件 + 权限收紧」替代通道前维持此形态，不做伪脱敏。
   let injectedSecrets: ReturnType<typeof createSecrets> | undefined
   if (params.adapterKind && params.userId) {
     const mapping = HARNESS_KEY_MAPPING[params.adapterKind as keyof typeof HARNESS_KEY_MAPPING]
@@ -192,12 +245,20 @@ export async function buildSandboxMiddleware(
       persistence: {
         stores: {
           messages: {
+            // 与主链路 message-store 同口径（审计 2026-10-25 🟡）：userId 行级
+            // 隔离（params.userId 在场时）+ take 100 上限（desc 读 + reverse 恢复
+            // 时间序），防超长线程全量载入拖垮快照恢复。
             loadThread: async (threadId: string) => {
               const msgs = await prisma.chatMessage.findMany({
-                where: { threadId },
-                orderBy: { createdAt: "asc" },
+                where: {
+                  threadId,
+                  ...(params.userId ? { thread: { userId: params.userId } } : {}),
+                },
+                orderBy: { createdAt: "desc" },
+                take: SANDBOX_LOAD_THREAD_MAX_MESSAGES,
                 select: { id: true, role: true, content: true, parts: true, createdAt: true },
               })
+              msgs.reverse()
               return msgs.map((m) => ({
                 id: m.id,
                 role: m.role as "user" | "assistant" | "tool",
@@ -247,10 +308,15 @@ export async function buildSandboxMiddleware(
               return { size: buffer.length }
             },
             put: async (key: string, body: Uint8Array) => {
+              if (body.byteLength > SANDBOX_BLOB_MAX_BYTES) {
+                throw new Error(
+                  `sandbox blob 超过 ${SANDBOX_BLOB_MAX_BYTES / 1024 / 1024}MB 上限（${key}: ${body.byteLength} bytes），拒绝落库`,
+                )
+              }
               const base64 = Buffer.from(body).toString("base64")
               await prisma.generationRun.upsert({
                 where: { id: key },
-                update: { result: base64 as any },
+                update: { result: base64 },
                 // create 分支必须携带真实 threadId/userId：GenerationRun.threadId
                 // 有 FK 指向 ChatThread（schema.prisma），旧实现误用 blob key 充当
                 // 二者——全新 key（快照捕获经 ai-sandbox putIfAbsent 到达此处时的
@@ -263,7 +329,7 @@ export async function buildSandboxMiddleware(
                   userId: params.userId ?? "sandbox",
                   kind: "sandbox-blob",
                   status: "completed",
-                  result: base64 as any,
+                  result: base64,
                   activity: "sandbox",
                 },
               })

package/src/server/ai-gateway/sandbox/local-process.ts

@@ -69,9 +69,92 @@ function unsupported(surface: string): Error {
   )
 }
 
+/**
+ * 子进程环境变量白名单（审计 2026-10-25 🟠）：绝不整体展开宿主 process.env——
+ * 否则 DATABASE_URL、AUTH_SECRET、各 API key env 会随每个 `sh -c` 子进程泄漏，
+ * 沙箱内 `printenv` 即得（readonly 档白名单恰放行 printenv*），配合可出网
+ * （networkPolicy=false 如实声明）即构成完整外传链路。仅放行运行命令所需的
+ * 无敏感基线变量；业务/密钥变量必须经显式通道注入（create env / env.set /
+ * per-call options.env，叠加在白名单之上）。
+ *
+ * `AI_SANDBOX_PASSTHROUGH_ENV`（逗号分隔变量名）为运维逃生门：自托管测试执行
+ * 等场景需要额外透传（如 PLAYWRIGHT_BROWSERS_PATH）时显式声明，默认零透传。
+ */
+const EXEC_ENV_ALLOWLIST = [
+  "PATH",
+  "HOME",
+  "LANG",
+  "LC_ALL",
+  "TMPDIR",
+  "TMP",
+  "TEMP",
+  "TZ",
+  "USER",
+  "LOGNAME",
+  "SHELL",
+] as const
+
+function buildChildEnv(): Record<string, string> {
+  const childEnv: Record<string, string> = {}
+  for (const key of EXEC_ENV_ALLOWLIST) {
+    const value = process.env[key]
+    if (value !== undefined) childEnv[key] = value
+  }
+  const passthrough = process.env.AI_SANDBOX_PASSTHROUGH_ENV?.trim()
+  if (passthrough) {
+    for (const name of passthrough.split(",")) {
+      const key = name.trim()
+      if (!key || (EXEC_ENV_ALLOWLIST as readonly string[]).includes(key)) continue
+      const value = process.env[key]
+      if (value !== undefined) childEnv[key] = value
+    }
+  }
+  return childEnv
+}
+
+/** exec 输出上限（stdout/stderr 各自独立计数），超出部分丢弃并留截断标记。 */
+const EXEC_OUTPUT_LIMIT = 1024 * 1024
+const EXEC_OUTPUT_TRUNCATED = "\n[local-process] 输出超过 1MB 上限，已截断"
+
+/**
+ * exec 默认超时：exec 契约是「阻塞到完成」的短命令面，未传 AbortSignal 的调用
+ * 对挂死命令（如无参 `cat` 等 stdin）会永远 pending——兜一个宽上限（10 分钟）。
+ * 调用方传了自己的 signal（如 testcase runner 的可配置超时）则完全由调用方接管，
+ * 不叠加默认超时（避免把调用方 10 分钟+ 的合法长跑提前 kill）。
+ * `AI_SANDBOX_EXEC_TIMEOUT_MS` 可覆盖默认值（自托管长命令调大 / 测试注入小值）。
+ */
+const EXEC_DEFAULT_TIMEOUT_MS = 10 * 60_000
+
+function resolveExecTimeoutMs(): number {
+  const raw = process.env.AI_SANDBOX_EXEC_TIMEOUT_MS?.trim()
+  if (raw) {
+    const parsed = Number(raw)
+    if (Number.isFinite(parsed) && parsed > 0) return parsed
+  }
+  return EXEC_DEFAULT_TIMEOUT_MS
+}
+
+/**
+ * 非 desktop 形态的误配/显式自担警告（审计 2026-10-25 🟠）：local-process 无
+ * 文件系统/网络隔离，云端服务器上显式 `AI_SANDBOX_PROVIDER=local-process` 属
+ * 高风险配置（自托管 AI 测试执行是合法用例，故 warn 而非拒绝）。模块级一次性。
+ */
+let warnedNonDesktop = false
+function warnOnceNonDesktop(): void {
+  if (warnedNonDesktop) return
+  warnedNonDesktop = true
+  if ((process.env.DEPLOY_TARGET ?? "").trim() === "desktop") return
+  console.warn(
+    "[sandbox] local-process 沙箱运行于非 desktop 部署形态（DEPLOY_TARGET 未设为 desktop）：" +
+      "子进程无文件系统/网络隔离，exec 命令以宿主用户权限运行。仅建议桌面端或" +
+      "明确自担风险的自托管场景（如 AI 测试执行）使用。",
+  )
+}
+
 export function localProcessSandbox(config: { root: string }): SandboxProvider {
   const root = path.resolve(config.root)
   const live = new Map<string, SandboxHandle>()
+  warnOnceNonDesktop()
 
   // 如实声明：本机进程模型无端口暴露、无快照、无网络策略、无 fork。
   // 虚报会让调用方依赖不存在的隔离能力（如 harness adapter 依赖 writableStdin=true 走 stdin 投递）。
@@ -105,6 +188,39 @@ export function localProcessSandbox(config: { root: string }): SandboxProvider {
     return resolved
   }
 
+  // ⚠ 边界如实声明（审计 2026-10-25 🟠）：resolveSafe/resolveReal 只约束本 provider
+  // 的 fs API 面，**不约束 exec 命令内容**——`sh -c` 以宿主用户权限运行，`cat /etc/passwd`、
+  // `find /` 等绝对路径操作完全在 exec 能力范围内，本机模型不存在文件系统隔离，隔离
+  // 完全依赖外部形态（desktop 用户自担 / 云 provider 由远端沙箱承载）。fs 面的
+  // resolveReal 在词法校验后追加 realpath 校验：沿最近已存在祖先做 realpath 后比对
+  // 前缀，防止工作区内 symlink 指向工作区外造成 fs 白名单穿透（readFile 会跟随
+  // symlink）。TOCTOU 竞态（校验后目标被替换）在本机威胁模型下接受。
+  async function resolveReal(realRoot: string, lexicalRoot: string, rel: string): Promise<string> {
+    const lexical = resolveSafe(lexicalRoot, rel)
+    let probe = lexical
+    for (;;) {
+      let real: string
+      try {
+        real = await fsPromises.realpath(probe)
+      } catch (err) {
+        const code = (err as NodeJS.ErrnoException)?.code
+        // 目标（或其部分路径段）尚不存在：向上找最近已存在祖先校验——
+        // 不存在的段不可能是 symlink，校验已存在前缀即可。
+        if ((code === "ENOENT" || code === "ENOTDIR") && path.dirname(probe) !== probe) {
+          probe = path.dirname(probe)
+          continue
+        }
+        throw err
+      }
+      if (real !== realRoot && !real.startsWith(realRoot + path.sep)) {
+        throw new Error(
+          `路径越界（symlink）：${JSON.stringify(rel)} 经符号链接指向 ${real}，逃出沙箱工作区`,
+        )
+      }
+      return lexical
+    }
+  }
+
   function instanceDir(id: string): string {
     return resolveSafe(root, sanitizeId(id))
   }
@@ -118,17 +234,24 @@ export function localProcessSandbox(config: { root: string }): SandboxProvider {
     }
   }
 
-  function makeHandle(id: string, workspaceRoot: string, initialEnv: Record<string, string>): SandboxHandle {
+  function makeHandle(
+    id: string,
+    workspaceRoot: string,
+    realRoot: string,
+    initialEnv: Record<string, string>,
+  ): SandboxHandle {
     let envMap: Record<string, string> = { ...initialEnv }
 
     const fs: SandboxFs = {
-      // 全部 async：resolveSafe 的越界抛错必须变成 rejected promise，
+      // 全部 async：resolveSafe/resolveReal 的越界抛错必须变成 rejected promise，
       // 裸 throw 会让调用方拿到同步异常而非可 await 的失败。
-      read: async (p) => fsPromises.readFile(resolveSafe(workspaceRoot, p), "utf8"),
-      readBytes: async (p) => Uint8Array.from(await fsPromises.readFile(resolveSafe(workspaceRoot, p))),
-      write: async (p, data) => fsPromises.writeFile(resolveSafe(workspaceRoot, p), data),
+      read: async (p) => fsPromises.readFile(await resolveReal(realRoot, workspaceRoot, p), "utf8"),
+      readBytes: async (p) =>
+        Uint8Array.from(await fsPromises.readFile(await resolveReal(realRoot, workspaceRoot, p))),
+      write: async (p, data) =>
+        fsPromises.writeFile(await resolveReal(realRoot, workspaceRoot, p), data),
       list: async (p) => {
-        const target = resolveSafe(workspaceRoot, p)
+        const target = await resolveReal(realRoot, workspaceRoot, p)
         const entries = await fsPromises.readdir(target, { withFileTypes: true })
         return entries.map((e) => ({
           name: e.name,
@@ -138,20 +261,26 @@ export function localProcessSandbox(config: { root: string }): SandboxProvider {
       },
       mkdir: async (p) => {
         // fsPromises.mkdir 返回 string|undefined，契约要求 Promise<void>
-        await fsPromises.mkdir(resolveSafe(workspaceRoot, p), { recursive: true })
+        await fsPromises.mkdir(await resolveReal(realRoot, workspaceRoot, p), { recursive: true })
       },
-      remove: async (p) => fsPromises.rm(resolveSafe(workspaceRoot, p), { recursive: true, force: true }),
+      remove: async (p) =>
+        fsPromises.rm(await resolveReal(realRoot, workspaceRoot, p), { recursive: true, force: true }),
       rename: async (from, to) =>
-        fsPromises.rename(resolveSafe(workspaceRoot, from), resolveSafe(workspaceRoot, to)),
+        fsPromises.rename(
+          await resolveReal(realRoot, workspaceRoot, from),
+          await resolveReal(realRoot, workspaceRoot, to),
+        ),
       exists: async (p) => {
         try {
-          await fsPromises.access(resolveSafe(workspaceRoot, p))
+          await fsPromises.access(await resolveReal(realRoot, workspaceRoot, p))
           return true
         } catch {
           return false
         }
       },
       lstat: async (p) => {
+        // lstat 契约明确「不跟随 symlink」——只读链接元数据，不做 realpath 校验
+        //（realpath 会穿透链接本体误判为越界）。
         let st: import("node:fs").Stats
         try {
           st = await fsPromises.lstat(resolveSafe(workspaceRoot, p))
@@ -172,30 +301,51 @@ export function localProcessSandbox(config: { root: string }): SandboxProvider {
       // 而非 rejected promise，`expect(...).rejects.toThrow()` 无法捕获。
       exec: async (command, options) => {
         const cwd = resolveSafe(workspaceRoot, options?.cwd ?? ".")
-        const childEnv = { ...process.env, PWD: cwd, ...envMap, ...(options?.env ?? {}) }
+        const childEnv = {
+          ...buildChildEnv(),
+          PWD: cwd,
+          ...envMap,
+          ...(options?.env ?? {}),
+        }
+        // 未传 signal 时叠加默认超时（挂死命令不永久 pending）；传了 signal
+        // 即由调用方全权接管生命周期（如 testcase runner 的可配置超时）。
+        const timeoutMs = options?.signal ? null : resolveExecTimeoutMs()
         return new Promise<ExecResult>((resolve, reject) => {
           let settled = false
           let stdout = ""
           let stderr = ""
+          let stdoutTruncated = false
+          let stderrTruncated = false
           let child: ReturnType<typeof spawnChild>
+          let timer: NodeJS.Timeout | undefined
 
+          const cleanup = () => {
+            // abort 监听以 { once: true } 注册且 onAbort 有 settled 守卫，
+            // 无需手动 removeEventListener；这里只负责清超时定时器。
+            if (timer !== undefined) clearTimeout(timer)
+          }
           const fail = (err: Error) => {
             if (settled) return
             settled = true
-            options?.signal?.removeEventListener("abort", onAbort)
+            cleanup()
             reject(err)
           }
           const finish = (code: number | null, signal: NodeJS.Signals | null) => {
             if (settled) return
             settled = true
-            options?.signal?.removeEventListener("abort", onAbort)
-            resolve({ stdout, stderr, exitCode: exitCodeOf(code, signal) })
+            cleanup()
+            resolve({
+              stdout: stdoutTruncated ? stdout + EXEC_OUTPUT_TRUNCATED : stdout,
+              stderr: stderrTruncated ? stderr + EXEC_OUTPUT_TRUNCATED : stderr,
+              exitCode: exitCodeOf(code, signal),
+            })
           }
-          const onAbort = () => {
+          const onAbort = (reason: string) => {
             if (settled) return
             settled = true
+            cleanup()
             child?.kill("SIGKILL")
-            reject(new Error(`exec 被 AbortSignal 取消：${command}`))
+            reject(new Error(`${reason}：${command}`))
           }
 
           try {
@@ -205,26 +355,58 @@ export function localProcessSandbox(config: { root: string }): SandboxProvider {
             return
           }
 
+          if (timeoutMs !== null) {
+            timer = setTimeout(() => {
+              onAbort(`exec 超过默认超时 ${Math.round(timeoutMs / 1000)}s 被终止`)
+            }, timeoutMs)
+          }
+
+          // 输出上限：超出后继续排空管道（防背压卡死子进程）但不再累加内存。
           child.stdout!.on("data", (d: Buffer) => {
+            if (stdout.length >= EXEC_OUTPUT_LIMIT) {
+              stdoutTruncated = true
+              return
+            }
             stdout += d.toString("utf8")
+            if (stdout.length > EXEC_OUTPUT_LIMIT) {
+              stdoutTruncated = true
+              stdout = stdout.slice(0, EXEC_OUTPUT_LIMIT)
+            }
           })
           child.stderr!.on("data", (d: Buffer) => {
+            if (stderr.length >= EXEC_OUTPUT_LIMIT) {
+              stderrTruncated = true
+              return
+            }
             stderr += d.toString("utf8")
+            if (stderr.length > EXEC_OUTPUT_LIMIT) {
+              stderrTruncated = true
+              stderr = stderr.slice(0, EXEC_OUTPUT_LIMIT)
+            }
           })
           child.on("error", fail)
           child.on("close", finish)
           if (options?.signal) {
             if (options.signal.aborted) {
-              onAbort()
+              onAbort("exec 被 AbortSignal 取消")
             } else {
-              options.signal.addEventListener("abort", onAbort, { once: true })
+              options.signal.addEventListener(
+                "abort",
+                () => onAbort("exec 被 AbortSignal 取消"),
+                { once: true },
+              )
             }
           }
         })
       },
       spawn: async (command, options) => {
         const cwd = resolveSafe(workspaceRoot, options?.cwd ?? ".")
-        const childEnv = { ...process.env, PWD: cwd, ...envMap, ...(options?.env ?? {}) }
+        const childEnv = {
+          ...buildChildEnv(),
+          PWD: cwd,
+          ...envMap,
+          ...(options?.env ?? {}),
+        }
         const child = spawnChild("sh", ["-c", command], { cwd, env: childEnv })
         const handle: SpawnHandle = {
           pid: child.pid ?? -1,
@@ -307,16 +489,25 @@ export function localProcessSandbox(config: { root: string }): SandboxProvider {
       const id = input.id === undefined ? randomUUID() : sanitizeId(input.id)
       const workspaceRoot = instanceDir(id)
       await fsPromises.mkdir(workspaceRoot, { recursive: true })
-      const handle = makeHandle(id, workspaceRoot, { ...(input.env ?? {}) })
+      // realpath 工作区根（macOS /tmp → /private/tmp 等 symlink 形态），
+      // 作为 fs 面 realpath 越界校验的锚点。
+      const realRoot = await fsPromises.realpath(workspaceRoot)
+      const handle = makeHandle(id, workspaceRoot, realRoot, { ...(input.env ?? {}) })
       live.set(id, handle)
       return handle
     },
     resume: async (input) => {
       // 本机模型：工作目录还在 = 可恢复；destroy 删目录后自然返回 null。
       const id = sanitizeId(input.id)
+      // 同 id 已有存活 handle（同进程内重复 resume）必须复用而非另造：
+      // 两个 handle 指向同一 workspaceRoot 时，任一 destroy 会删掉另一
+      // handle 脚下目录（审计 2026-10-25 🟡）。
+      const existing = live.get(id)
+      if (existing) return existing
       const workspaceRoot = instanceDir(id)
       if (!(await dirExists(workspaceRoot))) return null
-      const handle = makeHandle(id, workspaceRoot, {})
+      const realRoot = await fsPromises.realpath(workspaceRoot)
+      const handle = makeHandle(id, workspaceRoot, realRoot, {})
       live.set(id, handle)
       return handle
     },