@allbluecn/web-app 0.19.2 → 0.19.4

package/src/server/testcase/automation-rerun.ts

@@ -57,6 +57,11 @@ import { getPrisma } from "@allbluecn/database/get-prisma";
 import { judgeRetryOutcome } from "@/server/testcase/flaky-retry";
 import { finalizeRunIfComplete } from "@/server/testcase/run-finalize";
 import { fireTestRunWebhook } from "@/server/testcase/run-webhook";
+// 回环守卫与 browser-policy 同一口径（审计 🟠 对齐 A3x-2：desktop/AI_BROWSER_ALLOW_LOOPBACK 逃生门）
+import {
+  isLoopbackAllowedByDeployment,
+  isLoopbackHost,
+} from "@/server/ai-gateway/sandbox/browser-policy";
 import {
   runPlaywrightSpec,
   runVitestSpec,
@@ -156,7 +161,13 @@ export async function runAutomationRerun(params: AutomationRerunParams): Promise
     select: { id: true, caseId: true, caseVersion: true },
   });
 
-  const baseUrl = resolveBaseUrl(params.targetEnv);
+  // baseUrl 惰性解析（审计 🟠 回环守卫）：守卫失败抛 SpecRunnerUnavailableError，
+  // 由 executeRunCase 的产物级 try 落 blocked——整批不悬空、unit 复跑不受影响
+  let cachedBaseUrl: string | null = null;
+  const resolveBaseUrlOnce = (): string => {
+    if (cachedBaseUrl === null) cachedBaseUrl = resolveBaseUrl(params.targetEnv);
+    return cachedBaseUrl;
+  };
   let executed = 0;
 
   for (const rc of runCases) {
@@ -167,7 +178,7 @@ export async function runAutomationRerun(params: AutomationRerunParams): Promise
     });
     if (!fresh || fresh.status !== "running") break;
 
-    const outcome = await executeRunCase(prisma, rc, baseUrl, params.userId);
+    const outcome = await executeRunCase(prisma, rc, resolveBaseUrlOnce, params.userId);
     // flaky 自动重跑（任务 32）：断言类失败（status=failed）inline 第二跑一次；
     // blocked（环境类）/skipped 不重跑。failed_confirm 以首跑为终局（首跑 failed
     // 为准进归因队列），flaky 以复跑结果置 retest + flaky=true。复跑产物单独保存
@@ -177,7 +188,7 @@ export async function runAutomationRerun(params: AutomationRerunParams): Promise
     let retryOutcome: CaseOutcome | null = null;
     let finalOutcome = outcome;
     if (outcome.status === "failed") {
-      const second = await executeRunCase(prisma, rc, baseUrl, params.userId);
+      const second = await executeRunCase(prisma, rc, resolveBaseUrlOnce, params.userId);
       const decision = judgeRetryOutcome(outcome.status, second.status);
       if (decision === "flaky") {
         finalOutcome = {
@@ -308,7 +319,7 @@ type RunCasePick = { id: string; caseId: string; caseVersion: number };
 async function executeRunCase(
   prisma: PrismaClient,
   rc: RunCasePick,
-  baseUrl: string,
+  baseUrl: () => string,
   userId: string,
 ): Promise<CaseOutcome> {
   const artifacts = (await prisma.testAutomationArtifact.findMany({
@@ -356,7 +367,7 @@ async function executeRunCase(
   const results: { artifact: ArtifactPick; result?: SpecRunResult; failure?: string }[] = [];
   for (const artifact of runnable) {
     try {
-      results.push({ artifact, result: await runOneSpec(artifact, baseUrl, userId) });
+      results.push({ artifact, result: await runOneSpec(artifact, baseUrl(), userId) });
     } catch (err) {
       results.push({
         artifact,
@@ -464,10 +475,36 @@ function countOf(report: Record<string, unknown>, key: string): number {
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
 
-/** e2e baseUrl 裁决：targetEnv 为 http(s) URL 直用；否则回落 TESTCASE_E2E_BASE_URL/缺省 */
+/**
+ * e2e baseUrl 裁决：targetEnv 为 http(s) URL 直用；否则回落 TESTCASE_E2E_BASE_URL/缺省。
+ * 回环守卫（2026-10 审计 🟠，与 sandbox/browser-policy 同口径）：spec 复跑的浏览器以
+ * 服务端身份访问该 URL，云端部署下回环目标即服务器本机端口探测面——仅 desktop
+ * （单机自担）或显式 AI_BROWSER_ALLOW_LOOPBACK=true 放行，其余 fail-closed 抛
+ * SpecRunnerUnavailableError（调用方按环境类失败落 blocked，不误报断言结果）。
+ * 私网（非回环）目标与内网 staging 属运维显式配置（browser-policy 同注释口径），
+ * 不在此拦截。
+ */
 function resolveBaseUrl(targetEnv: string | null): string {
-  if (targetEnv && /^https?:\/\//.test(targetEnv)) return targetEnv;
-  return process.env.TESTCASE_E2E_BASE_URL || DEFAULT_E2E_BASE_URL;
+  const resolved =
+    targetEnv && /^https?:\/\//.test(targetEnv)
+      ? targetEnv
+      : process.env.TESTCASE_E2E_BASE_URL || DEFAULT_E2E_BASE_URL;
+  if (isLoopbackBaseUrl(resolved) && !isLoopbackAllowedByDeployment()) {
+    throw new SpecRunnerUnavailableError(
+      `复跑目标 ${resolved} 指向本机回环地址，云端部署拒绝（SSRF 防线）；` +
+        `本机调试请设 DEPLOY_TARGET=desktop 或 AI_BROWSER_ALLOW_LOOPBACK=true`,
+    );
+  }
+  return resolved;
+}
+
+/** URL 解析 + hostname 回环判定（解析失败按非回环交由下游报错） */
+function isLoopbackBaseUrl(url: string): boolean {
+  try {
+    return isLoopbackHost(new URL(url).hostname.toLowerCase());
+  } catch {
+    return false;
+  }
 }
 
 async function rmQuietly(dir: string): Promise<void> {

package/src/server/testcase/builtin-executor.ts

@@ -87,6 +87,13 @@ const MAX_ACTIONS_PER_STEP = 8;
 /** observed/summaryText 长度护栏（report_step observed 上限 5000） */
 const OBSERVED_CHAR_LIMIT = 4_800;
 const SUMMARY_CHAR_LIMIT = 8_000;
+/**
+ * 整体执行预算（2026-10 审计 ⚪）：每步 ≤8 动作×30s + 每步一次 LLM 调用
+ * （runChatAsAgent 无超时参数），极端长用例可占住执行上下文数十分钟——ExecRun
+ * 30min 超时回收只落数据不终止宿主上的浏览器/LLM 进程。到点后中止后续步骤
+ * （verdict=uncertain 落账 + observed 记原因），浏览器 finally 清理。
+ */
+export const BUILTIN_EXEC_TOTAL_BUDGET_MS = 10 * 60_000;
 
 export type ExecVerdict = "pass" | "fail" | "uncertain";
 
@@ -222,7 +229,19 @@ export async function runBuiltinExec(params: BuiltinExecParams): Promise<Builtin
     );
 
     const ordered = [...params.caseSnapshot.steps.steps].sort((a, b) => a.order - b.order);
+    const budgetStartMs = Date.now();
     for (const step of ordered) {
+      // 整体预算闸（审计 ⚪）：到点中止后续步骤，verdict=uncertain 落账（页面状态
+      // 不再推进，剩余步骤不执行）；真实执行的步骤照常逐步上报
+      if (Date.now() - budgetStartMs > BUILTIN_EXEC_TOTAL_BUDGET_MS) {
+        finalVerdict = "uncertain";
+        steps.push({
+          order: step.order,
+          verdict: "uncertain",
+          observed: `整体执行预算（${Math.round(BUILTIN_EXEC_TOTAL_BUDGET_MS / 60_000)} 分钟）耗尽，本步骤及后续步骤未执行`,
+        });
+        break;
+      }
       const outcome = await execSnapshotStep(page, step, params);
       const screenshotBlobId = await captureScreenshot(page, params, step.order);
       await callTool(

package/src/server/testcase/list-query.ts

@@ -117,9 +117,24 @@ export function buildListWhere(data: {
             } else if (hasNone && realIds.length === 0) {
               andConditions.push(isNeg ? { assigneeId: { not: null } } : { assigneeId: null });
             } else if (hasNone) {
-              andConditions.push({
-                OR: [{ assigneeId: null }, { assigneeId: isNeg ? { notIn: realIds } : { in: realIds } }],
-              });
+              // is_not（不属于「未指派+指定人」）的正确语义是 NOT(未指派 OR in realIds)
+              // = 非空且 notIn（2026-10 审计 🟡：原实现 `OR: [null, notIn]` 把未指派
+              // 重新包含进结果，勾选「不属于：未指派、张三」时未指派用例仍命中）
+              andConditions.push(
+                isNeg
+                  ? {
+                      AND: [
+                        { assigneeId: { not: null } },
+                        { assigneeId: { notIn: realIds } },
+                      ],
+                    }
+                  : {
+                      OR: [
+                        { assigneeId: null },
+                        { assigneeId: { in: realIds } },
+                      ],
+                    },
+              );
             } else if (realIds.length > 0) {
               andConditions.push({
                 assigneeId: isNeg

package/src/server/testcase/permissions.ts

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+// 测试模块「资源 → 项目 → 成员」守卫（审计 2026-10-25：getPlanFn / getRunFn / getRunCaseFn /
+// getTestCaseFn / listTestCaseActivitiesFn 读侧无归属校验，而同文件写侧均有）。
+
+import { getPrisma } from "@allbluecn/database/get-prisma";
+import { assertProjectMembership } from "@/server/lib/project-membership";
+
+export const TESTCASE_FORBIDDEN_MESSAGE = "无权限操作该项目的测试模块";
+
+export function assertTestProjectMembership(projectId: string, userId: string): Promise<void> {
+  return assertProjectMembership(projectId, userId, TESTCASE_FORBIDDEN_MESSAGE);
+}
+
+export async function assertTestCaseProjectMember(caseId: string, userId: string): Promise<string> {
+  const prisma = await getPrisma();
+  const row = await prisma.testCase.findUnique({ where: { id: caseId }, select: { projectId: true } });
+  if (!row) throw new Error("用例不存在");
+  await assertTestProjectMembership(row.projectId, userId);
+  return row.projectId;
+}
+
+export async function assertTestPlanProjectMember(planId: string, userId: string): Promise<string> {
+  const prisma = await getPrisma();
+  const row = await prisma.testPlan.findUnique({ where: { id: planId }, select: { projectId: true } });
+  if (!row) throw new Error("计划不存在");
+  await assertTestProjectMembership(row.projectId, userId);
+  return row.projectId;
+}
+
+export async function assertTestRunProjectMember(runId: string, userId: string): Promise<string> {
+  const prisma = await getPrisma();
+  const row = await prisma.testRun.findUnique({ where: { id: runId }, select: { projectId: true } });
+  if (!row) throw new Error("执行批次不存在");
+  await assertTestProjectMembership(row.projectId, userId);
+  return row.projectId;
+}
+
+/** 执行用例经 run 反查项目 */
+export async function assertRunCaseProjectMember(runCaseId: string, userId: string): Promise<string> {
+  const prisma = await getPrisma();
+  const row = await prisma.testRunCase.findUnique({
+    where: { id: runCaseId },
+    select: { run: { select: { projectId: true } } },
+  });
+  if (!row) throw new Error("执行用例不存在");
+  await assertTestProjectMembership(row.run.projectId, userId);
+  return row.run.projectId;
+}

package/src/server/testcase/run-finalize.ts

@@ -57,12 +57,28 @@ export function computeRunDurationMs(
  * （如任务 15 abort 语义把余例置 skipped）不得把 aborted 覆盖为 completed。
  * 调用方须在自己更新 RunCase 状态的同一事务内调用本函数；running 下重复调用为
  * 幂等覆盖（summary/completedAt 重算）。
+ *
+ * 并发仲裁（2026-10 审计 🟡）：
+ * - 行锁串行化：READ COMMITTED 下两个并发 finalize 事务互不可见对方未提交的
+ *   RunCase 更新，可双双误判未完成 → run 永久停留 running（webhook/summary 丢失，
+ *   人工批次无回收兜底）。先对 run 行取 FOR UPDATE——第二个事务阻塞到首个提交后，
+ *   其后的 findMany 以新快照重读，能看到对方已提交的终态。sqlite（桌面端）不支持
+ *   FOR UPDATE、单测 fake tx 无 $queryRaw：抛错降级无锁判定（桌面端单写入进程，
+ *   竞态窗口可接受），与原行为一致。
+ * - updateMany arbiter：summary 落账以 status='running' 条件更新仲裁，并发双过
+ *   判定时只有一方写入（count=0 即放弃），杜绝 summary 双写/覆盖。
  */
 export async function finalizeRunIfComplete(
   tx: Prisma.TransactionClient,
   runId: string,
   completedAt: Date,
 ): Promise<TestRunSummaryJson | null> {
+  // 串行化末例落账：物理表名 test_runs（schema @@map），参数化防注入
+  try {
+    await tx.$queryRaw`SELECT "id" FROM "test_runs" WHERE "id" = ${runId} FOR UPDATE`;
+  } catch {
+    /* sqlite / fake tx：无行锁，退回原判定 */
+  }
   const rows = await tx.testRunCase.findMany({
     where: { runId },
     select: { status: true },
@@ -80,8 +96,8 @@ export async function finalizeRunIfComplete(
     ...summarizeRunStatuses(statuses),
     durationMs: computeRunDurationMs(run.startedAt, completedAt),
   };
-  await tx.testRun.update({
-    where: { id: runId },
+  const arbitrated = await tx.testRun.updateMany({
+    where: { id: runId, status: "running" },
     data: {
       status: "completed",
       // Json 列写入 cast（testcase-crud steps 同款惯例；Prisma 仅 type-only import）
@@ -89,5 +105,6 @@ export async function finalizeRunIfComplete(
       completedAt,
     },
   });
+  if (arbitrated.count === 0) return null;
   return summary;
 }

package/src/server/testcase/run-webhook.ts

@@ -33,6 +33,7 @@ import {
   TEST_RUN_WEBHOOK_EVENT_RUN_COMPLETED,
 } from "@/server/serverFns/testcase/constants";
 import type { TestRunSummaryJson } from "./run-summary";
+import { decryptWebhookSecret, isEncryptedWebhookSecret, selfHealWebhookSecret } from "@/server/lib/webhook-secret";
 
 /** 投递超时（ms）：对端无响应 5s 放弃（规格 §12 与 BUG 模块同值） */
 export const TEST_RUN_WEBHOOK_TIMEOUT_MS = 5000;
@@ -145,7 +146,18 @@ async function deliverToTarget(
     const targetUrl = assertFetchableUrl(target.url);
     // 秒级 Unix 时间戳（GitHub webhook 同款惯例），随 X-Allblue-Timestamp 头外发供接收方验签
     const timestamp = Math.floor(Date.now() / 1000).toString();
-    const signature = createHmac("sha256", target.secret)
+    // 密钥静态加密（审计 A4x-3）：存量明文行由 decrypt 原样返回兼容；
+    // 解密失败（密钥轮换/密文损坏）跳过该端点，避免用错误密钥签名造成接收方静默拒收
+    const secret = decryptWebhookSecret(target.secret);
+    if (!secret) {
+      console.warn("[run-webhook] 端点密钥解密失败，跳过投递", { webhookId: target.id });
+      return;
+    }
+    if (!isEncryptedWebhookSecret(target.secret)) {
+      // 存量明文自愈：投递一次即加密回写（失败不影响本次投递）
+      void selfHealWebhookSecret(target.id, target.secret);
+    }
+    const signature = createHmac("sha256", secret)
       .update(`${timestamp}.${body}`)
       .digest("hex");
     // redirect:error 防 302 跳私网（webhook 接收端正常不重定向）

package/src/server/testcase/sandbox-runner.ts

@@ -220,7 +220,21 @@ async function resolveProvider(): Promise<{
     const resolved = await resolveSandboxProvider();
     return { kind: resolved.kind, provider: resolved.provider, degraded: false };
   } catch {
-    // 无沙箱环境降级：local-process 直建（临时目录工作区），结果标记 degraded
+    // 无沙箱环境降级门（2026-10 审计 🟠）：local-process 在宿主以服务端身份直接
+    // 执行 AI/用户生成 spec（等价运行任意第三方代码），隔离性未证实。静默降级为
+    // fail-open——现要求显式声明：desktop（单机自担）或 TESTCASE_ALLOW_LOCAL_SANDBOX=true；
+    // 其余 fail-closed 抛 SpecRunnerUnavailableError（调用方落 blocked，不误报断言）。
+    if (!isLocalSandboxDegradationAllowed()) {
+      throw new SpecRunnerUnavailableError(
+        "未配置沙箱 provider（VERCEL_TOKEN / DAYTONA_API_KEY / AI_SANDBOX_PROVIDER），" +
+          "且本部署形态未显式允许本地进程降级。" +
+          "自托管如接受宿主直执 spec 的隔离风险，请设 TESTCASE_ALLOW_LOCAL_SANDBOX=true（桌面端 DEPLOY_TARGET=desktop 默认允许）",
+      );
+    }
+    console.warn(
+      "[sandbox-runner] 未配置沙箱 provider，已降级 local-process 在宿主直接执行 spec" +
+        "（TESTCASE_ALLOW_LOCAL_SANDBOX/desktop 显式允许，隔离性自担）",
+    );
     return {
       kind: "local-process",
       provider: localProcessSandbox({ root: DEGRADED_SANDBOX_ROOT }),
@@ -229,6 +243,12 @@ async function resolveProvider(): Promise<{
   }
 }
 
+/** 降级 local-process 的显式声明（desktop 用户自担 / 自托管显式逃生门） */
+function isLocalSandboxDegradationAllowed(): boolean {
+  if ((process.env.DEPLOY_TARGET ?? "").trim() === "desktop") return true;
+  return process.env.TESTCASE_ALLOW_LOCAL_SANDBOX === "true";
+}
+
 async function destroyQuietly(handle: SandboxHandle): Promise<void> {
   try {
     await handle.destroy();

package/src/server/testcase/triage.ts

@@ -189,7 +189,10 @@ export async function triageFailedRunCase(runCaseId: string): Promise<TriageResu
   const verdict = await classifyFailure(runCase, report);
 
   if (verdict.category !== "env_issue") {
-    await persistTriage(runCase.execRunId, report, verdict);
+    // 落账竞态收窄（审计 🟡）：并发 triage（单例 + scanTriageQueue）双双通过幂等
+    // 守卫后，落账前事务内重读 report——已归因即放弃（零副作用，与幂等守卫同口径）
+    const persisted = await persistTriage(runCase.execRunId, verdict);
+    if (!persisted) return null;
     // 任务 34 接线：归因完成后指纹判重 → 命中关联既有 Bug / 未命中 AI 起草
     // （pendingConfirm 闸门）。autoBugForTrialedRunCase 顶层全吞异常，不反噬
     // triage 主链路（triage 已落账，人工转单兜底仍在）；env_issue 不进 bug 链。
@@ -200,7 +203,7 @@ export async function triageFailedRunCase(runCaseId: string): Promise<TriageResu
   // env_issue：persist + 翻转 + summary 重算单事务原子——persist 若先提交而翻转
   // 失败（死锁/断连），重试会被 report.triage 幂等守卫永久拦截，blocked 翻转与
   // 通知静默丢失；折进同一事务后失败整体回滚，重试重新走全流程（AI 调用留事务外）
-  const blocked = await persistAndFlipToBlocked(prisma, runCase.execRunId, runCase, report, verdict);
+  const blocked = await persistAndFlipToBlocked(prisma, runCase.execRunId, runCase, verdict);
   if (!blocked) return { ...verdict, blocked: false, notified: false };
   await notifyEnvIssue(runCase, verdict);
   return { ...verdict, blocked: true, notified: true };
@@ -245,21 +248,35 @@ async function classifyFailure(
   }
 }
 
-/** report 合并写 triage（不覆盖 perStep/consoleLog/networkLog/finalVerdict 等既有证据） */
+/**
+ * report 合并写 triage（不覆盖 perStep/consoleLog/networkLog/finalVerdict 等既有证据）。
+ * 幂等闸收窄（2026-10 审计 🟡）：入口守卫读 report 在 LLM 调用（秒级）之前，并发
+ * triage 可双双通过——落账前事务内重读 report，已归因即放弃（返回 false，调用方
+ * 零副作用退出）。竞态窗从「AI 调用时长」压到毫秒级；彻底仲裁需独立 triagedAt 列
+ * （schema 变更四件套，见审计待决策）。
+ */
 async function persistTriage(
   execRunId: string,
-  report: Record<string, unknown>,
   verdict: TriageReportEntry,
-): Promise<void> {
+): Promise<boolean> {
   const prisma = await getPrisma();
-  await prisma.testExecRun.update({
-    where: { id: execRunId },
-    data: {
-      report: {
-        ...report,
-        triage: verdict,
-      } as unknown as Prisma.InputJsonValue,
-    },
+  return prisma.$transaction(async (tx) => {
+    const fresh = await tx.testExecRun.findUnique({
+      where: { id: execRunId },
+      select: { report: true },
+    });
+    const freshReport = (fresh?.report ?? {}) as Record<string, unknown>;
+    if (freshReport.triage !== undefined) return false;
+    await tx.testExecRun.update({
+      where: { id: execRunId },
+      data: {
+        report: {
+          ...freshReport,
+          triage: verdict,
+        } as unknown as Prisma.InputJsonValue,
+      },
+    });
+    return true;
   });
 }
 
@@ -273,15 +290,21 @@ async function persistAndFlipToBlocked(
   prisma: Awaited<ReturnType<typeof getPrisma>>,
   execRunId: string,
   runCase: { id: string; runId: string },
-  report: Record<string, unknown>,
   verdict: TriageReportEntry,
 ): Promise<boolean> {
   return prisma.$transaction(async (tx) => {
+    // 幂等闸收窄（审计 🟡，同 persistTriage）：落账前事务内重读，并发已归因即放弃
+    const fresh = await tx.testExecRun.findUnique({
+      where: { id: execRunId },
+      select: { report: true },
+    });
+    const freshReport = (fresh?.report ?? {}) as Record<string, unknown>;
+    if (freshReport.triage !== undefined) return false;
     await tx.testExecRun.update({
       where: { id: execRunId },
       data: {
         report: {
-          ...report,
+          ...freshReport,
           triage: verdict,
         } as unknown as Prisma.InputJsonValue,
       },

package/src/server/web-search.ts

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+export type SearchResult = {
+  title: string
+  url: string
+  content: string
+  engine: string
+  score: number
+}
+
+export type SearchResponse = {
+  results: SearchResult[]
+  answers: string[]
+  suggestions: string[]
+}
+
+/**
+ * SearXNG 未配置时快速失败，避免每次时间敏感搜索白等超时。
+ * Vercel 生产默认未部署 SearXNG，靠原生 provider 搜索兜底。
+ */
+export function isSearxngEnabled(): boolean {
+  return Boolean(process.env.SEARXNG_BASE_URL)
+}
+
+export class SearxngDisabledError extends Error {
+  constructor() {
+    super("SearXNG not configured")
+    this.name = "SearxngDisabledError"
+  }
+}
+
+export async function searchWeb(query: string, limit = 8): Promise<SearchResponse> {
+  const baseUrl = process.env.SEARXNG_BASE_URL
+  if (!baseUrl) throw new SearxngDisabledError()
+
+  const url = new URL(`${baseUrl}/search`)
+  url.searchParams.set("format", "json")
+  url.searchParams.set("q", query)
+  url.searchParams.set("language", "zh-CN")
+  url.searchParams.set("categories", "general")
+  url.searchParams.set("pageno", "1")
+
+  const res = await fetch(url.toString(), {
+    signal: AbortSignal.timeout(8000),
+    headers: { Accept: "application/json" },
+  })
+
+  if (!res.ok) {
+    throw new Error(`SearXNG 搜索失败: ${res.status} ${res.statusText}`)
+  }
+
+  const data = await res.json()
+
+  const results: SearchResult[] = (data.results || [])
+    .filter((r: { content?: string }) => r.content)
+    .slice(0, limit)
+    .map((r: { title?: string; url?: string; content?: string; engine?: string; score?: number }) => ({
+      title: r.title || "",
+      url: r.url || "",
+      content: r.content || "",
+      engine: r.engine || "",
+      score: r.score || 0,
+    }))
+
+  return {
+    results,
+    answers: data.answers || [],
+    suggestions: data.suggestions || [],
+  }
+}

package/src/server-entry.ts

@@ -73,11 +73,17 @@ export default {
       console.error("[scheduled] 跳过 cron 触发：APP_URL 未配置（wrangler vars 需回填），表达式:", event.cron)
       return
     }
+    if (!env.CRON_SECRET) {
+      // 与 APP_URL 对称（审计 🟡）：缺 secret 时仍发空 Bearer 自调用只会静默 401，
+      // 显式报错让配置遗漏一眼可见
+      console.error("[scheduled] 跳过 cron 触发：CRON_SECRET 未配置（wrangler vars 需回填），表达式:", event.cron)
+      return
+    }
     // globalThis.fetch：模块级 const fetch（start handler）遮蔽了全局 fetch，
     // 这里必须显式走全局对象，否则类型与运行时都会错
     ctx.waitUntil(
       globalThis.fetch(`${env.APP_URL}${path}`, {
-        headers: { Authorization: `Bearer ${env.CRON_SECRET ?? ""}` },
+        headers: { Authorization: `Bearer ${env.CRON_SECRET}` },
       }).then((res: Response) => {
         if (!res.ok) console.error("[scheduled] cron 路由返回非 2xx:", path, res.status)
       })

package/src/shared/ai-cli/__tests__/adapter.test.ts

@@ -1,22 +1,17 @@
 import { describe, expect, it, beforeEach, vi } from "vitest"
 import type { CLIAgentInfo } from "@allbluecn/kernel"
 
+// adapter 已改异步 execFile（原 execFileSync 同步子进程阻塞事件循环，审计 🟡）：
+// 无 shell 注入不变量改由「execFile 数组参数 + execSync/execFileSync 零调用」锁定
+const execFileMock = vi.hoisted(() => vi.fn())
 const execFileSyncMock = vi.hoisted(() => vi.fn())
 const execSyncMock = vi.hoisted(() => vi.fn())
 
-vi.mock("node:child_process", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("node:child_process")>()
-  return {
-    ...actual,
-    execFileSync: execFileSyncMock,
-    execSync: execSyncMock,
-  }
-})
-
 vi.mock("child_process", async (importOriginal) => {
   const actual = await importOriginal<typeof import("child_process")>()
   return {
     ...actual,
+    execFile: execFileMock,
     execFileSync: execFileSyncMock,
     execSync: execSyncMock,
   }
@@ -32,36 +27,63 @@ const testAgent: CLIAgentInfo = {
 
 describe("executeViaAgent 命令执行安全", () => {
   beforeEach(() => {
+    execFileMock.mockReset()
     execFileSyncMock.mockReset()
     execSyncMock.mockReset()
     vi.resetModules()
   })
 
-  it("用 execFileSync 数组参数调用 CLI（无 shell 拼接）", async () => {
-    execFileSyncMock.mockReturnValue("  hello response  \n")
+  it("用 execFile 数组参数调用 CLI（无 shell 拼接）", async () => {
+    execFileMock.mockImplementation(
+      (_file: string, _args: string[], _opts: unknown, cb: (err: unknown, stdout: string) => void) =>
+        cb(null, "  hello response  \n"),
+    )
     const { executeViaAgent } = await import("../adapter")
     const result = await executeViaAgent(testAgent, "你好", {} as never)
     expect(result).toBe("hello response")
-    expect(execFileSyncMock).toHaveBeenCalledWith(
+    expect(execFileMock).toHaveBeenCalledWith(
       "claude",
       ["-p", "你好"],
-      expect.objectContaining({ timeout: 60000, encoding: "utf-8" })
+      expect.objectContaining({ timeout: 60000, encoding: "utf-8" }),
+      expect.any(Function),
     )
   })
 
-  it("execSync 未被调用（锁定无 shell 注入不变量）", async () => {
-    execFileSyncMock.mockReturnValue("ok")
+  it("execSync / execFileSync 未被调用（锁定无 shell 注入与无同步阻塞不变量）", async () => {
+    execFileMock.mockImplementation(
+      (_file: string, _args: string[], _opts: unknown, cb: (err: unknown, stdout: string) => void) =>
+        cb(null, "ok"),
+    )
     const { executeViaAgent } = await import("../adapter")
     await executeViaAgent(testAgent, "test", {} as never)
     expect(execSyncMock).not.toHaveBeenCalled()
+    expect(execFileSyncMock).not.toHaveBeenCalled()
   })
 
   it("prompt 中的 shell 元字符作为字面量传递（防注入回归）", async () => {
     const dangerous = `"; rm -rf /; echo $(whoami) \`id\`" && whoami`
-    execFileSyncMock.mockReturnValue("safe")
+    execFileMock.mockImplementation(
+      (_file: string, _args: string[], _opts: unknown, cb: (err: unknown, stdout: string) => void) =>
+        cb(null, "safe"),
+    )
     const { executeViaAgent } = await import("../adapter")
     await executeViaAgent(testAgent, dangerous, {} as never)
-    expect(execFileSyncMock.mock.calls[0]![1]).toEqual(["-p", dangerous])
+    expect(execFileMock.mock.calls[0]![1]).toEqual(["-p", dangerous])
     expect(execSyncMock).not.toHaveBeenCalled()
   })
+
+  it("openai-api 分支：非 2xx 抛错保留上游信息、非 2xx 不解析 choices", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: false,
+      status: 500,
+      text: () => Promise.resolve("boom"),
+    })
+    vi.stubGlobal("fetch", fetchMock)
+    process.env.OPENAI_API_KEY = "sk-test"
+    const { executeViaAgent } = await import("../adapter")
+    await expect(
+      executeViaAgent({ ...testAgent, id: "openai-api", binary: "api" }, "x", {} as never),
+    ).rejects.toThrow(/boom/)
+    vi.unstubAllGlobals()
+  })
 })