From 82c183b61c110bba007a198e6de65bb5c3a59b1c Mon Sep 17 00:00:00 2001 From: Benteng Sun <51025843+SMARK2022@users.noreply.github.com> Date: Thu, 12 Nov 2026 00:54:35 +0800 Subject: [PATCH] =?UTF-8?q?fix(ci):=20=E4=BF=AE=E5=A4=8D=E5=85=B1=E4=BA=AB?= =?UTF-8?q?=E8=B5=84=E6=BA=90=E4=B8=8E=E5=AE=88=E6=8A=A4=E8=BF=9B=E7=A8=8B?= =?UTF-8?q?=E7=94=9F=E5=91=BD=E5=91=A8=E6=9C=9F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- bun.lock | 1 + package.json | 1 + packages/codemode/src/interpreter/runtime.ts | 20 ++- packages/codemode/test/codemode.test.ts | 94 ++++++++++- packages/opencode/src/cli/tui/worker.ts | 5 +- .../instance/httpapi/handlers/global.ts | 5 + .../server/routes/instance/httpapi/server.ts | 3 +- packages/opencode/src/server/server.ts | 3 +- .../test/cli/run/lazy-runtime.test.ts | 10 +- packages/opencode/test/cli/tui/daemon.test.ts | 113 ++++++------- .../test/server/app-layer-sharing.test.ts | 44 +++++ .../opencode/test/server/httpapi-cors.test.ts | 9 +- .../opencode/test/server/httpapi-file.test.ts | 158 +++++++++++------- .../httpapi-instance-route-auth.test.ts | 14 +- .../test/server/httpapi-listen.test.ts | 52 +++++- .../test/server/httpapi-session.test.ts | 13 +- .../opencode/test/server/httpapi-ui.test.ts | 97 ++++++++--- .../cmd/tui/session-message-render.test.tsx | 10 +- packages/tui/test/fixture/tui-sdk.ts | 3 + .../session/auto-review-render.test.tsx | 8 +- patches/@opentui%2Fsolid@0.4.3-smark.13.patch | 28 ++++ turbo.json | 5 +- 22 files changed, 510 insertions(+), 186 deletions(-) create mode 100644 patches/@opentui%2Fsolid@0.4.3-smark.13.patch diff --git a/bun.lock b/bun.lock index 2331982f7434..b35bae8de253 100644 --- a/bun.lock +++ b/bun.lock @@ -1080,6 +1080,7 @@ "electron" ], "patchedDependencies": { + "@opentui/solid@https://github.com/SMARK2022/opentui/releases/download/v0.4.3-smark.13/opentui-solid-0.4.3-smark.13.tgz": "patches/@opentui%2Fsolid@0.4.3-smark.13.patch", "@opentui/core@https://github.com/SMARK2022/opentui/releases/download/v0.4.3-smark.13/opentui-core-0.4.3-smark.13.tgz": "patches/@opentui%2Fcore@0.4.3-smark.13.patch", "@pierre/trees@1.0.0-beta.4": "patches/@pierre%2Ftrees@1.0.0-beta.4.patch", "@tanstack/virtual-core@3.17.3": "patches/@tanstack%2Fvirtual-core@3.17.3.patch", diff --git a/package.json b/package.json index 12a92adeee17..a583ddddf9a7 100644 --- a/package.json +++ b/package.json @@ -158,6 +158,7 @@ "poe-oauth": "0.0.6" }, "patchedDependencies": { + "@opentui/solid@https://github.com/SMARK2022/opentui/releases/download/v0.4.3-smark.13/opentui-solid-0.4.3-smark.13.tgz": "patches/@opentui%2Fsolid@0.4.3-smark.13.patch", "@opentui/core@https://github.com/SMARK2022/opentui/releases/download/v0.4.3-smark.13/opentui-core-0.4.3-smark.13.tgz": "patches/@opentui%2Fcore@0.4.3-smark.13.patch", "@dnd-kit/dom@0.5.0": "patches/@dnd-kit%2Fdom@0.5.0.patch", "@npmcli/agent@4.0.2": "patches/@npmcli%2Fagent@4.0.2.patch", diff --git a/packages/codemode/src/interpreter/runtime.ts b/packages/codemode/src/interpreter/runtime.ts index 34280f30a388..7ce693b5d3df 100644 --- a/packages/codemode/src/interpreter/runtime.ts +++ b/packages/codemode/src/interpreter/runtime.ts @@ -1,6 +1,5 @@ import { parse } from "acorn" import { Cause, Effect, Exit, Fiber, Scope } from "effect" // 根 Scope 统一拥有 Promise 生产者;许可移交真实工具入口。 -import { DiagnosticCategory, ModuleKind, ScriptTarget, flattenDiagnosticMessageText, transpileModule } from "typescript" import { copyIn, copyOut, @@ -117,7 +116,9 @@ import { // 仅缓存纯语法树,不携带环境或能力;八项同时容纳用户源码与 fetch 的常量工厂。 const programs = new Map() -const parseProgram = (code: string): ProgramNode => { +// 两处转译共用实际加载的 TypeScript;仅传递依赖,不改语法缓存或诊断处理。 +const parseProgram = (code: string, typescript: typeof import("typescript")): ProgramNode => { + const { DiagnosticCategory, ModuleKind, ScriptTarget, flattenDiagnosticMessageText, transpileModule } = typescript const cached = programs.get(code) if (cached) return cached // 保存真实包装长度,解析诊断才能区分用户源码与解释器添加的内容。 @@ -715,6 +716,7 @@ class Interpreter { ) {} static make( + typescript: typeof import("typescript"), execution: Execution, hasFetch: boolean, environment = new Environment(), @@ -767,7 +769,7 @@ class Interpreter { return { url: data.url, status: data.status, statusText: data.statusText, ok: data.ok, redirected: data.redirected, headers: { get: name => data.headers[name.toLowerCase()] ?? null, has: name => Object.keys(data.headers).includes(name.toLowerCase()), entries: () => Object.entries(data.headers) }, text: async () => data.text, json: async () => JSON.parse(data.text), bytes: async () => data.bytes }; - }`).body[0], "fetch response") + }`, typescript).body[0], "fetch response") // 响应闭包与普通函数共用全局能力,异步读方法不创建第二套宿主状态。 execution.fetchResponse = new CodeModeFunction( getArray(factory, "params").map((param) => asNode(param, "params")), @@ -3482,19 +3484,21 @@ export const executeWithLimits = >( }) } - const operation = Effect.gen(function* () { + // 目录读取不执行程序;编译器在实际运行时加载,不改变工具、回调和空代码的构造时点。 + const operation = (typescript: typeof import("typescript")) => Effect.gen(function* () { // 先让外层 race 登记根 Fiber,再进入脚本;脚本内部仍同步启动每个 Promise。 yield* Effect.yieldNow const environment = options.snapshotEnvironment && options.environment ? snapshotEnvironment(options.environment) : options.environment - const program = parseProgram(options.code) + const program = parseProgram(options.code, typescript) const promises: Array = [] let unobservedFailure = false // 正常 return 也关闭仍在运行的生产者;已完成的宿主副作用保持原样。 const value = yield* Effect.scopedWith((scope) => Interpreter.make( + typescript, { invokeTool: tools.invoke, toolKeys: tools.keys, @@ -3557,9 +3561,7 @@ export const executeWithLimits = >( } satisfies Result), ), ) - }) - - return operation.pipe( + }).pipe( Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.interrupt @@ -3572,6 +3574,8 @@ export const executeWithLimits = >( ), Effect.map((result) => (limits.maxOutputBytes === undefined ? result : boundOutput(result, limits.maxOutputBytes))), ) + // 原预算仍只约束解析和执行;导入不计入预算,也不转成脚本可消费的失败诊断。 + return Effect.promise(() => import("typescript")).pipe(Effect.flatMap(operation)) } const utf8ByteLength = (value: string): number => new TextEncoder().encode(value).byteLength diff --git a/packages/codemode/test/codemode.test.ts b/packages/codemode/test/codemode.test.ts index 0f210be1d7e3..bddf88ec48eb 100644 --- a/packages/codemode/test/codemode.test.ts +++ b/packages/codemode/test/codemode.test.ts @@ -1,6 +1,6 @@ import { describe, expect, test } from "bun:test" // 参数形式回归沿用真实转换型 Schema,避免只测展示用 JSON。 -import { Cause, Deferred, Effect, Exit, Fiber, Schema, SchemaGetter } from "effect" +import { Cause, Clock, Deferred, Duration, Effect, Exit, Fiber, Scheduler, Schema, SchemaGetter } from "effect" import { TestClock } from "effect/testing" import { CodeMode, Tool, toolError } from "../src/index.js" @@ -859,6 +859,72 @@ describe("CodeMode public contract", () => { const input: CodeMode.Input = { code: source } expect(Schema.decodeUnknownSync(CodeMode.Input)(input)).toStrictEqual(input) expect(Schema.decodeUnknownSync(CodeMode.Result)(JSON.parse(JSON.stringify(reusable)))).toStrictEqual(reusable) + + // 同一执行契约内用新进程检查冷加载边界,不新增测试注册。 + const child = Bun.spawn( + [ + process.execPath, + "--no-install", + "--eval", + ` + const { CodeMode } = await import(${JSON.stringify(new URL("../src/index.ts", import.meta.url).href)}) + const { Effect } = await import("effect") + // resolve 只定位已安装编译器;cache 观察不能为检查而提前执行模块。 + const compiler = require.resolve("typescript") + const loaded = () => Boolean(require.cache[compiler]) + // 库导入、目录渲染和两种 Effect 构造都不执行程序,分别检查资源边界。 + const states = [loaded()] + const runtime = CodeMode.make() + const metadata = { catalog: runtime.catalog(), hasInstructions: runtime.instructions().length > 0 } + states.push(loaded()) + const prepared = runtime.execute("const answer: number = 42; return answer") + // fetch 只取本地 Effect 数据;响应 json 方法仍经过解释器的第二处真实转译。 + const direct = CodeMode.execute({ + code: 'const response: object = await fetch("https://example.invalid"); return { url: response.url, status: response.status, body: await response.json() }', + fetch: (url) => Effect.succeed({ url, status: 200, statusText: "OK", ok: true, + redirected: false, headers: {}, text: "2", bytes: [50] }), + }) + states.push(loaded()) + // 真实类型注解要求两入口仍使用同一编译器,不能通过跳过执行获得轻量结果。 + const values = await Promise.all([Effect.runPromise(prepared), Effect.runPromise(direct)]) + console.log(JSON.stringify({ states, loaded: loaded(), metadata, values })) + `, + ], + { + cwd: import.meta.dir, + stdin: "ignore", + stdout: "pipe", + stderr: "pipe", + // 子进程四秒预算短于既有用例默认五秒,保留回收时间;不放宽原用例期限。 + timeout: 4_000, + }, + ) + try { + // 同时消费两条管道并等待退出,防止资源探针自身因输出反压而挂起。 + const [exit, stdout, stderr] = await Promise.all([ + child.exited, + new Response(child.stdout).text(), + new Response(child.stderr).text(), + ]) + expect({ exit, stderr }).toEqual({ exit: 0, stderr: "" }) + expect(JSON.parse(stdout)).toStrictEqual({ + states: [false, false, false], + loaded: true, + metadata: { catalog: [], hasInstructions: true }, + values: [ + { ok: true, value: 42, toolCalls: [] }, + { + ok: true, + value: { url: "https://example.invalid", status: 200, body: 2 }, + toolCalls: [{ name: "$codemode.fetch" }], + }, + ], + }) + } finally { + // 即使读取或断言失败,本测试也负责终止并收完自己创建的进程。 + if (child.exitCode === null) child.kill() + await child.exited + } }) test("inlines a COMPLETE small catalog and keeps search registered but unadvertised", async () => { @@ -2802,11 +2868,35 @@ describe("CodeMode retained environments", () => { expect(calls).toEqual([1]) expect(yield* CodeMode.execute({ environment, code: "return count;" })).toMatchObject({ value: 0 }) + const base = yield* Clock.Clock + const ready = yield* Deferred.make() + const observed = { + // 显式转发原 Clock 方法,只观察本例的真实计时器,不替换默认 sleep 能力。 + currentTimeMillis: base.currentTimeMillis, + currentTimeNanos: base.currentTimeNanos, + currentTimeMillisUnsafe: () => base.currentTimeMillisUnsafe(), + currentTimeNanosUnsafe: () => base.currentTimeNanosUnsafe(), + sleep: (duration: Parameters[0]) => { + if (Duration.toMillis(duration) !== 100) return base.sleep(duration) + return Effect.gen(function* () { + // 仅计时器启动段禁自动让步;原 TestClock 入队后才允许父测试推进时间。 + const timer = yield* base.sleep(duration).pipe( + Effect.forkChild({ startImmediately: true }), + Effect.provideService(Scheduler.PreventSchedulerYield, true), + ) + yield* Deferred.succeed(ready, undefined) + // 结构化子任务仍随真实执行取消,解释器自身的调度策略不变。 + yield* Fiber.join(timer) + }) + }, + } const running = yield* CodeMode.execute({ environment, tools, code: "return await work();", - }).pipe(Effect.forkChild) + }).pipe(Effect.provideService(Clock.Clock, observed), Effect.forkChild) + // 动态导入可能先挂起;等待计时器实际登记,而不是假定 fork 后已经开始睡眠。 + yield* Deferred.await(ready) // 不靠墙钟猜测:推进到到期前一毫秒仍不能出现第二次真实调用。 yield* TestClock.adjust(99) expect(calls).toEqual([1]) diff --git a/packages/opencode/src/cli/tui/worker.ts b/packages/opencode/src/cli/tui/worker.ts index 7e8a09ac7e5b..ab95aaa129b5 100644 --- a/packages/opencode/src/cli/tui/worker.ts +++ b/packages/opencode/src/cli/tui/worker.ts @@ -295,11 +295,12 @@ if (isDaemon) { await reconcileStale({ kind: "exit-full" }, { budgetMs: remaining }).catch((error) => log.error("stale-turn exit-full failed", { error: String(error) })) } else log.info("stale-turn exit-full skipped: services unavailable or no cleanup budget") + // 主动停机让末帧走既有 HTTP 优雅窗口;其他退出仍强关,五秒硬截止不变。 // 监听资源归 daemon 所有,共享它的 TUI 退出只释放自己的连接。 const stopped = await Promise.allSettled([ Promise.resolve().then(() => controlServer?.stop(true)), - Promise.resolve().then(() => externalServer?.stop(true)), - Promise.resolve().then(() => internalServer?.stop(true)), + Promise.resolve().then(() => externalServer?.stop(reason !== DisposedReason.DaemonStop)), + Promise.resolve().then(() => internalServer?.stop(reason !== DisposedReason.DaemonStop)), ]) // scoped文件logger关闭即排空缓冲;等待仍受原五秒硬截止保护。 const runtime = await Promise.allSettled([AppRuntime.dispose(), daemonLogging.dispose()]) diff --git a/packages/opencode/src/server/routes/instance/httpapi/handlers/global.ts b/packages/opencode/src/server/routes/instance/httpapi/handlers/global.ts index 6e4d5668dec4..9cc3ca6690f0 100644 --- a/packages/opencode/src/server/routes/instance/httpapi/handlers/global.ts +++ b/packages/opencode/src/server/routes/instance/httpapi/handlers/global.ts @@ -14,6 +14,7 @@ import { RootHttpApi } from "../api" import { GlobalUpgradeInput } from "../groups/global" import { EventClients } from "@opencode-ai/server/event-clients" import { PartView } from "@opencode-ai/core/session/part-view" +import { DisposedReason, Event } from "@/server/event" import type { MessageV2 } from "@/session/message-v2" function eventData(data: unknown): Sse.Event { @@ -67,6 +68,10 @@ function eventResponse(clients: EventClients.Interface, viewer: boolean) { // 计数属于响应 body 的 scope;未消费响应不虚增,取消流自动释放。 Stream.unwrap(Effect.as(clients.acquire, Stream.make({ payload: { id: EventV2.ID.create(), type: "server.connected", properties: {} } }).pipe( Stream.concat(events.pipe(Stream.merge(heartbeat, { haltStrategy: "left" }))), + // 仅主动停机成为末帧;普通 dispose/凭证刷新仍保留同一订阅。 + Stream.takeUntil((event) => + event.payload?.type === Event.Disposed.type && event.payload.properties?.reason === DisposedReason.DaemonStop, + ), Stream.map((event) => eventData(viewer ? projectViewerEvent(event) : event)), Stream.pipeThroughChannel(Sse.encode()), Stream.encodeText, diff --git a/packages/opencode/src/server/routes/instance/httpapi/server.ts b/packages/opencode/src/server/routes/instance/httpapi/server.ts index 2e2d9c2eae39..efa938db5238 100644 --- a/packages/opencode/src/server/routes/instance/httpapi/server.ts +++ b/packages/opencode/src/server/routes/instance/httpapi/server.ts @@ -309,7 +309,8 @@ export function createSharedServices() { AppNodeBuilderV1.build(MoveSession.node, replacements), ).pipe(Layer.provideMerge(locationServiceMapV2)) })).pipe(Layer.provideMerge(legacyOwners)) - return { layer, memoMap } + // 复用组合根及其 scope;仅共享应用服务,listener 的认证与路由仍各自构建。 + return { layer: Layer.suspend(() => layer), memoMap } } export function createRoutes( diff --git a/packages/opencode/src/server/server.ts b/packages/opencode/src/server/server.ts index c8ba31526621..34bb33cee0b5 100644 --- a/packages/opencode/src/server/server.ts +++ b/packages/opencode/src/server/server.ts @@ -180,7 +180,8 @@ function makeStop(state: ListenerState, unpublishMdns: Effect.Effect, list return Effect.gen(function* () { const forceCloseOnce = yield* Effect.cached(forceClose(state).pipe(Effect.ignore)) const closeScopeOnce = yield* Effect.cached( - Scope.close(state.scope, Exit.void).pipe( + state.websockets.closeAll.pipe( + Effect.ensuring(Scope.close(state.scope, Exit.void)), Effect.ignore, Effect.ensuring( Effect.sync(() => { diff --git a/packages/opencode/test/cli/run/lazy-runtime.test.ts b/packages/opencode/test/cli/run/lazy-runtime.test.ts index 67687bf9a7f1..8d456c77db1a 100644 --- a/packages/opencode/test/cli/run/lazy-runtime.test.ts +++ b/packages/opencode/test/cli/run/lazy-runtime.test.ts @@ -4,11 +4,16 @@ import path from "path" test("importing the run command does not execute the interactive runtime module", async () => { // clearAll会连同preload的Solid转换一起清除;仅在子进程注册探针,父进程不改插件表。 // 子进程只导入命令元数据,runtime被替换为计数器,绝不执行交互handler。 + // 在命令依赖有机会触发转换前取样,验证全局插件注册不提前加载 Babel。 const child = Bun.spawn( [ process.execPath, "-e", - `const key = Symbol.for("opencode.test.run-runtime-loaded"); + `const { createRequire } = await import("node:module"); +const babelCoreLoaded = Object.keys(createRequire(import.meta.url).cache).some( + (file) => /[/\\\\]@babel[/\\\\]core[/\\\\]/.test(file), +); +const key = Symbol.for("opencode.test.run-runtime-loaded"); globalThis[key] = 0; Bun.plugin({ name: "run-runtime-eager-probe", @@ -21,7 +26,7 @@ Bun.plugin({ }); const command = await import("./src/cli/cmd/run"); await Bun.sleep(0); -console.log(JSON.stringify({ command: command.RunCommand.command, loaded: globalThis[key] }));`, +console.log(JSON.stringify({ command: command.RunCommand.command, loaded: globalThis[key], babelCoreLoaded }));`, ], { cwd: path.join(import.meta.dir, "../../.."), @@ -40,4 +45,5 @@ console.log(JSON.stringify({ command: command.RunCommand.command, loaded: global const result = JSON.parse(stdout.trim().split("\n").at(-1)!) expect(result.command).toContain("run") expect(result.loaded).toBe(0) + expect(result.babelCoreLoaded).toBe(false) }) diff --git a/packages/opencode/test/cli/tui/daemon.test.ts b/packages/opencode/test/cli/tui/daemon.test.ts index 406fb4129c28..e22beabe2b06 100644 --- a/packages/opencode/test/cli/tui/daemon.test.ts +++ b/packages/opencode/test/cli/tui/daemon.test.ts @@ -195,25 +195,24 @@ async function runDaemonMachine( return { exitCode, stdout, stderr } } -// 观察本用例worker已发布的信号;producer退出立即失败,不按宿主耗时推断行为。 +// 观察本用例worker已发布的信号;退出后的最终快照仍无信号才失败,不按宿主耗时推断行为。 async function waitForDaemonLog(lockPath: string, pid: number, marker: string) { const file = path.join(path.dirname(lockPath), "share", "opencode", "log", "opencode.log") const deadline = Date.now() + DAEMON_START_TIMEOUT_MS while (Date.now() < deadline) { - if (!ServerLock.alive(pid)) throw new Error(`Daemon exited before publishing ${marker}`) + // 先采样存活再读日志;死亡后的读取才是最终快照,避免漏掉读取期间发布的末条事件。 + const alive = ServerLock.alive(pid) const text = await Bun.file(file).text().catch(() => "") if (text.includes(marker)) return + if (!alive) throw new Error(`Daemon exited before publishing ${marker}`) await Bun.sleep(POLL_INTERVAL_MS) } throw new Error(`Daemon did not publish ${marker}`) } -/** - * 在临时目录中启动守护进程,轮询直到锁文件出现且 HTTP 服务器响应。 - * 返回运行中的进程和锁文件内容。 - */ -async function spawnDaemon(lockPath: string, env: Record = {}) { - const proc = spawnBackground([process.execPath, WORKER_TS], { +// 进程创建与活体就绪分开:预期立即退出的生命周期不应要求父进程抢到短暂健康窗口。 +function startDaemon(lockPath: string, env: Record = {}) { + return spawnBackground([process.execPath, WORKER_TS], { env: { ...isolatedDaemonEnv(lockPath, env), OPENCODE_PROCESS_ROLE: "worker", @@ -222,6 +221,14 @@ async function spawnDaemon(lockPath: string, env: Record = {}) { stdout: "ignore", stderr: "ignore", }) +} + +/** + * 在临时目录中启动守护进程,轮询直到锁文件出现且 HTTP 服务器响应。 + * 返回运行中的进程和锁文件内容。 + */ +async function spawnDaemon(lockPath: string, env: Record = {}) { + const proc = startDaemon(lockPath, env) // 锁文件存在不足以交付 fixture;真实子 PID 与受保护的 HTTP health 必须同时成立。 const deadline = Date.now() + DAEMON_START_TIMEOUT_MS @@ -1051,6 +1058,8 @@ describe("daemon lifecycle", () => { if (lock?.pid === proc.pid) break await Bun.sleep(25) } + expect(await ServerLock.read(lockPath)).toMatchObject({ pid: proc.pid, token, controlPort: expect.any(Number) }) + expect(ServerLock.alive(proc.pid)).toBe(true) const result = await runDaemonStop(lockPath) expect(result.exitCode).toBe(0) expect(result.stderr).toContain("Force-stopped opencode daemon.") @@ -1109,6 +1118,8 @@ describe("daemon lifecycle", () => { if (lock?.pid === proc.pid) break await Bun.sleep(25) } + expect(await ServerLock.read(lockPath)).toMatchObject({ pid: proc.pid, token, controlPort: expect.any(Number) }) + expect(ServerLock.alive(proc.pid)).toBe(true) ServerLock._setLockPath(lockPath) // 与下方 maintenance-idle 409 合同测试互为两个方向:应答拒绝与无应答都不构成条件式停机的 // 中断授权——无应答不等于空闲(控制面可能正被同步事务阻塞),只有 worker 明确接受才授权。 @@ -1377,7 +1388,13 @@ describe("daemon lifecycle", () => { expect(shutdownEvent).not.toBe("timeout") expect(String(shutdownEvent)).toContain("global.disposed") expect(String(shutdownEvent)).toContain("daemon-stop") - await stop + expect((await stop).exitCode).toBe(0) + // 同一订阅须自然 EOF;再核实正常退出和清锁,不能只收到关键字就通过。 + while (true) { + const chunk = await reader.read() + if (chunk.done) break + } + expect({ exit: await proc.exited, lock: await Bun.file(lockPath).exists() }).toEqual({ exit: 0, lock: false }) } finally { ctrl.abort() await reader.cancel().catch(() => undefined) @@ -1526,51 +1543,6 @@ describe("daemon lifecycle", () => { DAEMON_START_TIMEOUT_MS + DAEMON_STOP_TIMEOUT_MS, ) - test( - "daemon private status reports current TUI client count", - async () => { - await using tmp = await tmpdir() - const lockPath = path.join(tmp.path, "tui-server.json") - const { proc, lock } = await spawnDaemon(lockPath, { OPENCODE_DAEMON_IDLE_TIMEOUT_MS: "5000" }) - - try { - if (!lock.controlPort) throw new Error("missing control port") - const statusBefore = await fetch(`http://127.0.0.1:${lock.controlPort}${ServerLock.CONTROL_STATUS_PATH}`, { - headers: { [ServerLock.CONTROL_TOKEN_HEADER]: lock.token }, - }).then((x) => x.json() as Promise<{ tuiClients: number; sessionActivity: number }>) - expect(statusBefore.tuiClients).toBe(0) - expect(statusBefore.sessionActivity).toBe(0) - - const ctrl = new AbortController() - // SSE 与健康 fixture 共用显式认证,401 不能伪装成客户端计数没有增加。 - const res = await fetch(`http://127.0.0.1:${lock.port}/global/event`, { - signal: ctrl.signal, - headers: ServerLock.headers(credentials), - }) - expect(res.ok).toBe(true) - if (!res.body) throw new Error("missing SSE body") - const reader = res.body.pipeThrough(new TextDecoderStream()).getReader() - - try { - const first = await reader.read() - expect(first.value).toContain("server.connected") - const statusDuring = await fetch(`http://127.0.0.1:${lock.controlPort}${ServerLock.CONTROL_STATUS_PATH}`, { - headers: { [ServerLock.CONTROL_TOKEN_HEADER]: lock.token }, - }).then((x) => x.json() as Promise<{ tuiClients: number; sessionActivity: number }>) - expect(statusDuring.tuiClients).toBe(1) - } finally { - ctrl.abort() - await reader.cancel().catch(() => undefined) - reader.releaseLock() - } - } finally { - if (ServerLock.alive(proc.pid)) proc.kill("SIGTERM") - await proc.exited.catch(() => undefined) - } - }, - DAEMON_START_TIMEOUT_MS + 10_000, - ) - // #523:launcher Ctrl-C 测试——源仓用 Daemon.ensure;目标等价 seam 是 discoverOrSpawnDaemon。 // #523:真实 launcher 已完成 daemon 发现但未打开 SSE;启动期 Ctrl-C 后 worker 必须可被后续接管。 test( @@ -1936,7 +1908,7 @@ describe("daemon lifecycle", () => { await using tmp = await tmpdir() const lockPath = path.join(tmp.path, "tui-server.json") // #235:startup idle 250ms 远小于常规 idle——验证启动期保护独立生效 - const { proc } = await spawnDaemon(lockPath, { + const proc = startDaemon(lockPath, { OPENCODE_DAEMON_IDLE_TIMEOUT_MS: "5000", OPENCODE_DAEMON_STARTUP_IDLE_TIMEOUT_MS: "250", // #235:显式清零 launcher——宿主 opencode 会话注入的 LAUNCHER_PID 会让 startup idle 永久 skip @@ -1944,8 +1916,12 @@ describe("daemon lifecycle", () => { }) try { + // 启动证据来自锁发布后的既有日志;正常退出再快也不能被误报为未启动。 + await waitForDaemonLog(lockPath, proc.pid, "daemon startup idle shutdown scheduled") const exitCode = await Promise.race([proc.exited, Bun.sleep(5_000).then(() => "timeout" as const)]) expect(exitCode).toBe(0) + // 退出码本身不能证明空闲保护执行,须观察同一 worker 的实际退出原因。 + await waitForDaemonLog(lockPath, proc.pid, "reason=startup-idle-timeout") expect(await Bun.file(lockPath).text().catch(() => undefined)).toBeUndefined() } finally { if (ServerLock.alive(proc.pid)) proc.kill() @@ -1961,15 +1937,19 @@ describe("daemon lifecycle", () => { async () => { await using tmp = await tmpdir() const lockPath = path.join(tmp.path, "tui-server.json") - const { proc } = await spawnDaemon(lockPath, { + const proc = startDaemon(lockPath, { OPENCODE_DAEMON_IDLE_TIMEOUT_MS: "5000", OPENCODE_DAEMON_STARTUP_IDLE_TIMEOUT_MS: "5000", OPENCODE_DAEMON_LAUNCHER_PID: "987654321", }) try { + // launcher watcher 也是短命启动路径,观察已发布事件而非要求退出前仍可健康探测。 + await waitForDaemonLog(lockPath, proc.pid, "daemon launcher watcher started") const exitCode = await Promise.race([proc.exited, Bun.sleep(5_000).then(() => "timeout" as const)]) expect(exitCode).toBe(0) + // 区分 launcher 死亡与稍后的 startup idle,不能只凭相同零退出码通过。 + await waitForDaemonLog(lockPath, proc.pid, "reason=launcher-exited-before-first-client") expect(await Bun.file(lockPath).text().catch(() => undefined)).toBeUndefined() } finally { if (ServerLock.alive(proc.pid)) proc.kill() @@ -2049,7 +2029,7 @@ describe("daemon lifecycle", () => { ) // #173:短 idle 超时 + SSE 断开后守护进程应退出并清锁 test( - "daemon exits after the last SSE client disconnects", + "daemon reports TUI clients and exits after the last SSE client disconnects", async () => { await using tmp = await tmpdir() const lockPath = path.join(tmp.path, "tui-server.json") @@ -2061,6 +2041,14 @@ describe("daemon lifecycle", () => { }) try { + // 同一真实 worker 覆盖计数与 idle 退出,避免为相同 SSE 生命周期重复冷启动服务树。 + if (!lock.controlPort) throw new Error("missing control port") + const before = await controlRequest(lock, ServerLock.CONTROL_STATUS_PATH) + expect(before.ok).toBe(true) + const statusBefore = (await before.json()) as { tuiClients: number; sessionActivity: number } + expect(statusBefore.tuiClients).toBe(0) + expect(statusBefore.sessionActivity).toBe(0) + const ctrl = new AbortController() const res = await fetch(`http://127.0.0.1:${lock.port}/global/event`, { signal: ctrl.signal, @@ -2074,6 +2062,11 @@ describe("daemon lifecycle", () => { const first = await reader.read() // #173:先读到 connected,确认 SSE 计数已 +1 expect(first.value).toContain("server.connected") + // control token 与公开 SSE 凭证分别走生产认证;连接帧之后必须已发布 +1。 + const during = await controlRequest(lock, ServerLock.CONTROL_STATUS_PATH) + expect(during.ok).toBe(true) + const statusDuring = (await during.json()) as { tuiClients: number } + expect(statusDuring.tuiClients).toBe(1) // #173:连接期间必须仍存活,证明 idle 只在断开后计时 await Bun.sleep(750) expect(ServerLock.alive(proc.pid)).toBe(true) @@ -2091,9 +2084,9 @@ describe("daemon lifecycle", () => { expect(ServerLock.alive(proc.pid)).toBe(false) expect(await Bun.file(lockPath).exists()).toBe(false) } finally { - try { - proc.kill() - } catch {} + // 临时目录归还前等待真实子进程退出;kill 对已退出的 owned child 保持幂等。 + proc.kill() + await proc.exited } }, 15_000, diff --git a/packages/opencode/test/server/app-layer-sharing.test.ts b/packages/opencode/test/server/app-layer-sharing.test.ts index 57412dd64d52..1cc440288750 100644 --- a/packages/opencode/test/server/app-layer-sharing.test.ts +++ b/packages/opencode/test/server/app-layer-sharing.test.ts @@ -1,4 +1,6 @@ import { expect, test } from "bun:test" +import path from "node:path" +import { tmpdir } from "../fixture/fixture" import { ConfigProvider, Layer } from "effect" import { HttpRouter } from "effect/unstable/http" import { HttpApiApp } from "../../src/server/routes/instance/httpapi/server" @@ -32,6 +34,48 @@ test( await first.dispose() await second.dispose() } + + // 原共享层生命周期例同时验证失败后的重建;新进程隔离数据库路径。 + await using tmp = await tmpdir() + const child = Bun.spawn([process.execPath, "--no-install", "--eval", ` + const { mkdir, rm } = await import("node:fs/promises") + const { Context, Effect, Exit, Layer, Scope } = await import("effect") + const { HttpApiApp } = await import(${JSON.stringify(new URL("../../src/server/routes/instance/httpapi/server.ts", import.meta.url).href)}) + const { Database } = await import("@opencode-ai/core/database/database") + const shared = HttpApiApp.createSharedServices() + const scopes = [Scope.makeUnsafe(), Scope.makeUnsafe()] + try { + await mkdir(process.env.OPENCODE_DB) + const failed = await Effect.runPromiseExit(Layer.buildWithMemoMap(shared.layer, shared.memoMap, scopes[0])) + if (failed._tag !== "Failure") throw new Error("directory must reject SQLite open") + await Effect.runPromise(Scope.close(scopes[0], Exit.void)) + await rm(process.env.OPENCODE_DB, { recursive: true }) + const context = await Effect.runPromise(Layer.buildWithMemoMap(shared.layer, shared.memoMap, scopes[1])) + await Effect.runPromise(Context.get(context, Database.Service).db.run("SELECT 1")) + console.log("retried") + } finally { + await Promise.all(scopes.map(scope => Effect.runPromise(Scope.close(scope, Exit.void)))) + } + `], { + cwd: import.meta.dir, + env: { ...process.env, OPENCODE_DB: path.join(tmp.path, "retry.db"), OPENCODE_PURE: "1", OPENCODE_DISABLE_MODELS_FETCH: "1" }, + stdin: "ignore", + stdout: "pipe", + stderr: "pipe", + timeout: 50_000, + }) + try { + const [exit, stdout, stderr] = await Promise.all([ + child.exited, + new Response(child.stdout).text(), + new Response(child.stderr).text(), + ]) + expect({ exit, stderr }).toEqual({ exit: 0, stderr: "" }) + expect(stdout.split("\n")).toContain("retried") + } finally { + if (child.exitCode === null) child.kill() + await child.exited + } }, 60000, ) diff --git a/packages/opencode/test/server/httpapi-cors.test.ts b/packages/opencode/test/server/httpapi-cors.test.ts index 4e9680c7ce4b..c288e278d4f8 100644 --- a/packages/opencode/test/server/httpapi-cors.test.ts +++ b/packages/opencode/test/server/httpapi-cors.test.ts @@ -62,14 +62,17 @@ describe("HttpApi CORS", () => { it.live("adds CORS headers to unauthorized responses", () => Effect.gen(function* () { - const handler = HttpRouter.toWebHandler( + // NodeHttpServer 只拥有主测试 server,此处另建的 Web handler 需要独立的关闭责任。 + const web = HttpRouter.toWebHandler( HttpApiApp.createRoutes().pipe( Layer.provide(ConfigProvider.layer(ConfigProvider.fromUnknown({ OPENCODE_SERVER_PASSWORD: "secret" }))), ), { disableLogger: true }, - ).handler + ) + // body scope 先于 testStateLayer 关闭,避免数据库重置时仍留有 Web 层资源。 + yield* Effect.addFinalizer(() => Effect.promise(() => web.dispose())) const response = yield* Effect.promise(() => - handler( + web.handler( new Request(new URL("/global/config", "http://localhost"), { headers: { origin: "https://app.opencode.ai" }, }), diff --git a/packages/opencode/test/server/httpapi-file.test.ts b/packages/opencode/test/server/httpapi-file.test.ts index ed882ade4652..e95f735d3062 100644 --- a/packages/opencode/test/server/httpapi-file.test.ts +++ b/packages/opencode/test/server/httpapi-file.test.ts @@ -1,83 +1,115 @@ -import { afterEach, describe, expect, test } from "bun:test" -import { Context, Effect } from "effect" +import { NodeHttpServer, NodeServices } from "@effect/platform-node" +import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder" +import { LayerNode } from "@opencode-ai/core/effect/layer-node" +import { FSUtil } from "@opencode-ai/core/fs-util" +import { Ripgrep } from "@opencode-ai/core/ripgrep" +import { describe, expect } from "bun:test" +import { Effect, Layer, Schema } from "effect" +import { HttpClient, HttpClientResponse, HttpRouter } from "effect/unstable/http" +import { HttpApi, HttpApiBuilder } from "effect/unstable/httpapi" +import { layerWebSocketConstructorGlobal } from "effect/unstable/socket/Socket" import path from "path" -import { HttpApiApp } from "../../src/server/routes/instance/httpapi/server" -import { FilePaths } from "../../src/server/routes/instance/httpapi/groups/file" -import { resetDatabase } from "../fixture/db" -import { disposeAllInstances, tmpdir } from "../fixture/fixture" -import { pollWithTimeout } from "../lib/effect" +import { Workspace } from "../../src/control-plane/workspace" +import { ServerAuth } from "../../src/server/auth" +import { FileApi, FilePaths } from "../../src/server/routes/instance/httpapi/groups/file" +import { fileHandlers } from "../../src/server/routes/instance/httpapi/handlers/file" +import { authorizationLayer } from "../../src/server/routes/instance/httpapi/middleware/authorization" +import { instanceContextLayer } from "../../src/server/routes/instance/httpapi/middleware/instance-context" +import { schemaErrorLayer } from "../../src/server/routes/instance/httpapi/middleware/schema-error" +import { workspaceRoutingLayer } from "../../src/server/routes/instance/httpapi/middleware/workspace-routing" +import { Session } from "../../src/session/session" +import { testInstanceStoreLayer, tmpdirScoped } from "../fixture/fixture" +import { pollWithTimeout, testEffect } from "../lib/effect" -const context = Context.empty() as Context.Context +// 独立 layer scope 持有内存数据库与服务,不调用会启动全局 AppRuntime 的清理桥。 +// 使用仓库的 scoped runner 与真实 HTTP listener,不复用已关闭的全局 handler。 +const it = testEffect(Layer.mergeAll(NodeHttpServer.layerTest, NodeServices.layer)) + +// 只挂载 FileApi,省去旧 HttpApi 全量装配;LocationServiceMap 仍用生产实现。 +// 复用已有的无启动副作用 InstanceStore fixture;文件搜索仍走真实 FFF 与 rg。 +// 在目录之后构建此层,确保 native 索引与 watcher 先释放,再删除目录。 +// 沿用生产 handler 的 API 标识,只装配文件组,避免类型身份与运行时路由键脱节。 +const serveFiles = HttpApiBuilder.layer(HttpApi.make("opencode-instance").addHttpApi(FileApi)).pipe( + Layer.provide(fileHandlers), + Layer.provide([instanceContextLayer, workspaceRoutingLayer, authorizationLayer, schemaErrorLayer]), + Layer.provide([ServerAuth.Config.layer, layerWebSocketConstructorGlobal]), + // 先展开请求期依赖,再由同一服务层同时满足路由构建与请求执行。 + HttpRouter.serve, + Layer.provide([ + testInstanceStoreLayer, + AppNodeBuilder.build(LayerNode.group([Workspace.node, Session.node, Ripgrep.node, FSUtil.node])), + ]), + Layer.build, +) function request(route: string, directory: string, query?: Record) { - const url = new URL(`http://localhost${route}`) - for (const [key, value] of Object.entries(query ?? {})) { - url.searchParams.set(key, value) - } - return HttpApiApp.webHandler().handler( - new Request(url, { - headers: { - "x-opencode-directory": directory, - }, - }), - context, - ) + return HttpClient.get(route, { headers: { "x-opencode-directory": directory }, urlParams: query }) } -afterEach(async () => { - await disposeAllInstances() - await resetDatabase() -}) - describe("file HttpApi", () => { - test("serves read endpoints", async () => { - await using tmp = await tmpdir({ git: true }) - await Bun.write(path.join(tmp.path, "hello.txt"), "hello") + it.live("serves read endpoints", () => + Effect.gen(function* () { + // 读取用例继续覆盖 git 项目的目录上下文,不把所有请求缩成普通目录。 + const dir = yield* tmpdirScoped({ git: true }) + yield* Effect.promise(() => Bun.write(path.join(dir, "hello.txt"), "hello")) + yield* serveFiles - const [list, content, status] = await Promise.all([ - request(FilePaths.list, tmp.path, { path: "." }), - request(FilePaths.content, tmp.path, { path: "hello.txt" }), - request(FilePaths.status, tmp.path), - ]) + // 保持原有并发请求,验证同目录共享上下文而不是人为串行规避竞争。 + const [list, content, status] = yield* Effect.all( + [ + request(FilePaths.list, dir, { path: "." }), + request(FilePaths.content, dir, { path: "hello.txt" }), + request(FilePaths.status, dir), + ], + { concurrency: "unbounded" }, + ) - expect(list.status).toBe(200) - expect(await list.json()).toContainEqual( - expect.objectContaining({ name: "hello.txt", path: "hello.txt", type: "file" }), - ) + expect(list.status).toBe(200) + expect(yield* list.json).toContainEqual( + expect.objectContaining({ name: "hello.txt", path: "hello.txt", type: "file" }), + ) - expect(content.status).toBe(200) - expect(await content.json()).toMatchObject({ type: "text", content: "hello" }) + expect(content.status).toBe(200) + expect(yield* content.json).toMatchObject({ type: "text", content: "hello" }) - expect(status.status).toBe(200) - expect(await status.json()).toEqual([]) - }) + expect(status.status).toBe(200) + expect(yield* status.json).toEqual([]) + }), + ) - test("serves search endpoints", async () => { - await using tmp = await tmpdir({ git: true }) - await Bun.write(path.join(tmp.path, "hello.txt"), "needle") + it.live("serves search endpoints", () => + Effect.gen(function* () { + // 文件名和文本搜索不依赖 git 提交,省去此用例的七次 git 准备进程。 + const dir = yield* tmpdirScoped() + yield* Effect.promise(() => Bun.write(path.join(dir, "hello.txt"), "needle")) + yield* serveFiles - const [text, symbols] = await Promise.all([ - request(FilePaths.findText, tmp.path, { pattern: "needle" }), - request(FilePaths.findSymbol, tmp.path, { query: "hello" }), - ]) - const files = await Effect.runPromise( - pollWithTimeout( - Effect.promise(async () => { - const response = await request(FilePaths.findFile, tmp.path, { query: "hello", type: "file" }) - const body = await response.json() + const [text, symbols] = yield* Effect.all( + [ + request(FilePaths.findText, dir, { pattern: "needle" }), + request(FilePaths.findSymbol, dir, { query: "hello" }), + ], + { concurrency: "unbounded" }, + ) + // 先校验字符串数组,错误响应直接失败;只为合法结果尚未入索引保留五秒轮询。 + const files = yield* pollWithTimeout( + Effect.gen(function* () { + const response = yield* request(FilePaths.findFile, dir, { query: "hello", type: "file" }) + const body = yield* HttpClientResponse.schemaBodyJson(Schema.Array(Schema.String))(response) return body.includes("hello.txt") ? { response, body } : undefined }), "file search index was not ready", - ), - ) + ) - expect(text.status).toBe(200) - expect(await text.json()).toContainEqual(expect.objectContaining({ line_number: 1 })) + expect(text.status).toBe(200) + expect(yield* text.json).toContainEqual(expect.objectContaining({ line_number: 1 })) - expect(files.response.status).toBe(200) - expect(files.body).toContain("hello.txt") + expect(files.response.status).toBe(200) + expect(files.body).toContain("hello.txt") - expect(symbols.status).toBe(200) - expect(await symbols.json()).toEqual([]) - }) + // 保留当前符号端点的空结果契约,不用替身制造预期输出。 + expect(symbols.status).toBe(200) + expect(yield* symbols.json).toEqual([]) + }), + ) }) diff --git a/packages/opencode/test/server/httpapi-instance-route-auth.test.ts b/packages/opencode/test/server/httpapi-instance-route-auth.test.ts index 9933a28bdc8e..ad5264cc300f 100644 --- a/packages/opencode/test/server/httpapi-instance-route-auth.test.ts +++ b/packages/opencode/test/server/httpapi-instance-route-auth.test.ts @@ -10,7 +10,7 @@ import { resetDatabase } from "../fixture/db" import { disposeAllInstances, tmpdir } from "../fixture/fixture" function app(input: { password?: string; username?: string }) { - const handler = HttpRouter.toWebHandler( + const web = HttpRouter.toWebHandler( HttpApiApp.routes.pipe( Layer.provide( ConfigProvider.layer( @@ -22,10 +22,13 @@ function app(input: { password?: string; username?: string }) { ), ), { disableLogger: true }, - ).handler + ) return { - fetch: (request: Request) => handler(request, HttpApiApp.context), + // 取消 SSE 响应只结束请求流,不会释放 toWebHandler 建立的应用层 scope。 + // 全局实例仍由 afterEach 清理;这里仅释放该 factory 创建并持有的 Web 层。 + [Symbol.asyncDispose]: () => web.dispose(), + fetch: (request: Request) => web.handler(request, HttpApiApp.context), request(input: string | URL | Request, init?: RequestInit) { return this.fetch(input instanceof Request ? input : new Request(new URL(input, "http://localhost"), init)) }, @@ -45,10 +48,11 @@ afterEach(async () => { await resetDatabase() }) +// server 后于 tmp 声明,确保先关 Web scope,再删临时目录和执行 afterEach 的数据库重置。 describe("HttpApi instance route authorization", () => { test("requires configured auth before opening the instance event stream", async () => { await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } }) - const server = app({ password: "secret" }) + await using server = app({ password: "secret" }) const headers = { "x-opencode-directory": tmp.path } const missing = await server.request(EventPaths.event, { headers }) @@ -64,7 +68,7 @@ describe("HttpApi instance route authorization", () => { test("requires configured auth before resolving the PTY websocket route", async () => { await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } }) - const server = app({ password: "secret" }) + await using server = app({ password: "secret" }) const route = PtyPaths.connect.replace(":ptyID", PtyID.ascending()) const headers = { "x-opencode-directory": tmp.path } diff --git a/packages/opencode/test/server/httpapi-listen.test.ts b/packages/opencode/test/server/httpapi-listen.test.ts index f7535e8f2ef9..6c40b8a4b070 100644 --- a/packages/opencode/test/server/httpapi-listen.test.ts +++ b/packages/opencode/test/server/httpapi-listen.test.ts @@ -4,6 +4,8 @@ import path from "node:path" import { pathToFileURL } from "node:url" import { Flag } from "@opencode-ai/core/flag/flag" import { Server } from "../../src/server/server" +import { HttpApiApp } from "../../src/server/routes/instance/httpapi/server" +import { GlobalBus } from "../../src/bus/global" import { EventClients } from "@opencode-ai/server/event-clients" import { PtyPaths } from "../../src/server/routes/instance/httpapi/groups/pty" import { withTimeout } from "../../src/util/timeout" @@ -38,12 +40,12 @@ async function startListener() { return Server.listen({ hostname: "127.0.0.1", port: 0 }) } -async function startNoAuthListener(eventClients?: EventClients.Interface) { +async function startNoAuthListener(options: Partial[0]> = {}) { Flag.OPENCODE_SERVER_PASSWORD = undefined Flag.OPENCODE_SERVER_USERNAME = auth.username delete process.env.OPENCODE_SERVER_PASSWORD process.env.OPENCODE_SERVER_USERNAME = auth.username - return Server.listen({ hostname: "127.0.0.1", port: 0, eventClients }) + return Server.listen({ hostname: "127.0.0.1", port: 0, ...options }) } function authorization() { @@ -215,8 +217,11 @@ describe("HttpApi Server.listen", () => { // 必须先观察建立再观察清零,避免初始零连接让清理断言空通过。 if (connected && count === 0) drained.resolve() }) - const listener = await startNoAuthListener(eventClients) + const sharedServices = HttpApiApp.createSharedServices() + const listener = await startNoAuthListener({ eventClients, sharedServices, cors: ["https://first.test"] }) const socket = net.connect(listener.port, "127.0.0.1") + let second: Server.Listener | undefined + let events: ReadableStreamDefaultReader | undefined try { const response = await withTimeout( new Promise((resolve, reject) => { @@ -236,18 +241,53 @@ describe("HttpApi Server.listen", () => { ) expect(response).toContain("HTTP/1.1 200 OK") expect(response).toContain("text/event-stream") + // 应用层可共享,第二监听的认证、CORS 和 SSE 计数必须仍各自拥有。 + process.env.OPENCODE_SERVER_PASSWORD = auth.password + second = await Server.listen({ hostname: "127.0.0.1", port: 0, ephemeral: true, sharedServices, cors: ["https://second.test"] }) + const stream = await fetch(new URL("/global/event", second.url), { + headers: { authorization: authorization(), origin: "https://second.test" }, + }) + expect(stream.status).toBe(200) + expect(stream.headers.get("access-control-allow-origin")).toBe("https://second.test") + events = stream.body!.pipeThrough(new TextDecoderStream()).getReader() + // SSE 帧可能分块或先收到心跳;总期限内累积到目标事件,不以一次 read 作为帧边界。 + const readEvent = (marker: string) => withTimeout( + (async () => { + let received = "" + while (!received.includes(marker)) { + const chunk = await events!.read() + if (chunk.done) throw new Error(`second SSE ended before ${marker}`) + received += chunk.value + } + return received + })(), + 5_000, + `second SSE did not emit ${marker}`, + ) + expect(await readEvent("server.connected")).toContain("server.connected") + expect((await fetch(new URL("/global/health", second.url))).status).toBe(401) socket.destroy() // 等待生产收尾通知,不用固定 sleep 假定 fiber、heartbeat 与订阅已经释放。 await withTimeout(drained.promise, 5_000, "SSE client count did not return to zero") expect(connected).toBe(true) // 断开流式连接后 listener 仍服务普通请求;读取正文也完成后继请求的生命周期。 - const health = await fetch(new URL("/global/health", listener.url)) + const health = await fetch(new URL("/global/health", listener.url), { headers: { origin: "https://first.test" } }) expect(health.status).toBe(200) + expect(health.headers.get("access-control-allow-origin")).toBe("https://first.test") expect(await health.json()).toMatchObject({ healthy: true }) + await stop(listener, "timed out stopping first shared listener") + GlobalBus.emit("event", { directory: "global", payload: { type: "global.disposed", properties: {} } }) + GlobalBus.emit("event", { payload: { type: "server.heartbeat", properties: { marker: "second-survives" } } }) + expect(await readEvent("second-survives")).toContain("second-survives") } finally { socket.destroy() // 观察者随本listener服务释放,不修改其他连接持有的计数服务。 - await stop(listener, "timed out cleaning up SSE listener") + await Promise.all([ + stop(listener, "timed out cleaning up SSE listener"), + second ? stop(second, "timed out cleaning up second shared listener") : undefined, + events?.cancel().catch(() => undefined), + ]) + events?.releaseLock() } }, 15_000) @@ -280,7 +320,7 @@ describe("HttpApi Server.listen", () => { ws.send("ping-listen\n") expect(await message).toContain("ping-listen") - await stop(listener, "timed out waiting for listener.stop(true)") + await withTimeout(listener.stop(), 10_000, "timed out waiting for listener.stop()") stopped = true await withTimeout(closed, 5_000, "timed out waiting for websocket close") expect(ws.readyState).toBe(WebSocket.CLOSED) diff --git a/packages/opencode/test/server/httpapi-session.test.ts b/packages/opencode/test/server/httpapi-session.test.ts index 58d492b5d848..ddfce4c034d0 100644 --- a/packages/opencode/test/server/httpapi-session.test.ts +++ b/packages/opencode/test/server/httpapi-session.test.ts @@ -253,7 +253,7 @@ describe("session HttpApi", () => { "shares session ownership and cancels V1 runs across service contexts", () => Effect.gen(function* () { - const shared = HttpApiApp.createSharedServices() + const shared = { ...HttpApiApp.createSharedServices(), memoMap: Layer.makeMemoMapUnsafe() } const scope = yield* Scope.Scope const firstScope = yield* Scope.fork(scope) const secondScope = yield* Scope.fork(scope) @@ -329,6 +329,17 @@ describe("session HttpApi", () => { yield* Scope.close(firstScope, Exit.succeed(undefined)) // 第一scope退出不关闭第二scope仍持有的应用服务。 expect((yield* Context.get(second, Session.Service).get(session.id).pipe(Effect.provide(second))).id).toBe(session.id) + // 隔离的 memoMap 使此处确实释放最后 owner,不借用测试外层的数据库引用。 + yield* Effect.promise(() => Promise.all(handlers.map(entry => entry.web.dispose()))) + yield* Scope.close(secondScope, Exit.void) + yield* Scope.close(runtimeScope, Exit.void) + const previousDatabase = Context.get(first, Database.Service) + expect(Exit.isFailure(yield* previousDatabase.db.run("SELECT 1").pipe(Effect.exit))).toBe(true) + const rebuiltScope = yield* Scope.fork(scope) + const rebuilt = yield* Layer.buildWithMemoMap(shared.layer, shared.memoMap, rebuiltScope) + const database = Context.get(rebuilt, Database.Service) + expect(database).not.toBe(previousDatabase) + yield* database.db.run("SELECT 1") }), ) diff --git a/packages/opencode/test/server/httpapi-ui.test.ts b/packages/opencode/test/server/httpapi-ui.test.ts index 1a7ccc60dab2..b5af1a096424 100644 --- a/packages/opencode/test/server/httpapi-ui.test.ts +++ b/packages/opencode/test/server/httpapi-ui.test.ts @@ -1,7 +1,7 @@ import { createHash } from "node:crypto" import { describe, expect } from "bun:test" import { Flag } from "@opencode-ai/core/flag/flag" -import { ConfigProvider, Effect, Layer, Option } from "effect" +import { ConfigProvider, Effect, Exit, Layer, Option } from "effect" import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder" import { HttpClient, @@ -58,8 +58,9 @@ function restoreEnv(key: string, value: string | undefined) { process.env[key] = value } -function app(input?: { password?: string; username?: string }) { - const handler = HttpRouter.toWebHandler( +// Web 层在首次请求时才构建;factory 返回前登记清理,调用方 yield 后才能发请求。 +const app = Effect.fnUntraced(function* (input?: { password?: string; username?: string }) { + const { handler, dispose } = HttpRouter.toWebHandler( HttpApiApp.routes.pipe( Layer.provide( ConfigProvider.layer( @@ -71,7 +72,8 @@ function app(input?: { password?: string; username?: string }) { ), ), { disableLogger: true }, - ).handler + ) + yield* Effect.addFinalizer(() => Effect.promise(dispose)) return { request(input: string | URL | Request, init?: RequestInit) { return Effect.promise(() => @@ -84,15 +86,16 @@ function app(input?: { password?: string; username?: string }) { ) }, } -} +}) -function uiApp(input?: { +// 每个 UI app 归当前测试的 body scope 所有,断言失败也先释放资源,再恢复全局 flag。 +const uiApp = Effect.fnUntraced(function* (input?: { password?: string username?: string client?: Layer.Layer disableEmbeddedWebUi?: boolean }) { - const handler = HttpRouter.toWebHandler( + const { handler, dispose } = HttpRouter.toWebHandler( HttpRouter.use((router) => Effect.gen(function* () { const fs = yield* FSUtil.Service @@ -112,7 +115,8 @@ function uiApp(input?: { ]), ), { disableLogger: true }, - ).handler + ) + yield* Effect.addFinalizer(() => Effect.promise(dispose)) return { request(input: string | URL | Request, init?: RequestInit) { return Effect.promise(() => @@ -125,11 +129,12 @@ function uiApp(input?: { ) }, } -} +}) -function routeOrderingApp() { +// 与 UI factory 保持相同归属,不让路由顺序测试的客户端层逃出测试 scope。 +const routeOrderingApp = Effect.fnUntraced(function* () { let proxiedUrl: string | undefined - const handler = HttpRouter.toWebHandler( + const { handler, dispose } = HttpRouter.toWebHandler( HttpRouter.use((router) => Effect.gen(function* () { const fs = yield* FSUtil.Service @@ -153,7 +158,8 @@ function routeOrderingApp() { ]), ), { disableLogger: true }, - ).handler + ) + yield* Effect.addFinalizer(() => Effect.promise(dispose)) return { proxiedUrl: () => proxiedUrl, request(input: string | URL | Request, init?: RequestInit) { @@ -167,7 +173,7 @@ function routeOrderingApp() { ) }, } -} +}) function httpClient(response: Response, onRequest?: (request: HttpClientRequest.HttpClientRequest) => void) { return Layer.succeed( @@ -188,7 +194,7 @@ describe("HttpApi UI fallback", () => { Effect.gen(function* () { let proxiedUrl: string | undefined - const response = yield* uiApp({ + const server = yield* uiApp({ disableEmbeddedWebUi: true, client: httpClient( new Response("opencode", { headers: { "content-type": "text/html" } }), @@ -196,12 +202,42 @@ describe("HttpApi UI fallback", () => { proxiedUrl = request.url }, ), - }).request("/") + }) + const response = yield* server.request("/") expect(response.status).toBe(200) expect(response.headers.get("content-type")).toContain("text/html") expect(yield* responseText(response)).toBe("opencode") expect(proxiedUrl).toBe("https://app.opencode.ai/") + // 沿同一真实 UI 服务例覆盖成功和失败的释放出口,不新增独立用例。 + for (const fail of [false, true]) { + const events: string[] = [] + // 固定哨兵区分故意失败与请求断言异常,避免把所有 failure 都误当作预期结果。 + const failure = new Error("intentional body failure") + // 先关闭子 scope 再捕获 Exit,使释放阶段的异常也进入检查,不能提前记录成功。 + const exit = yield* Effect.gen(function* () { + const server = yield* uiApp({ + disableEmbeddedWebUi: true, + client: httpClient(new Response("scope probe")).pipe( + // 必须由真实请求触发层构建,防止从未使用 handler 的空 scope 通过清理检查。 + Layer.tap(() => + Effect.acquireRelease( + Effect.sync(() => events.push("acquired")), + () => Effect.sync(() => events.push("disposed")), + ), + ), + ), + }) + const response = yield* server.request("/") + expect(response.status).toBe(200) + expect(yield* responseText(response)).toBe("scope probe") + expect(events).toEqual(["acquired"]) + if (fail) yield* Effect.die(failure) + }).pipe(Effect.scoped, Effect.exit) + + expect(exit).toEqual(fail ? Exit.die(failure) : Exit.void) + expect(events).toEqual(["acquired", "disposed"]) + } }), ) @@ -358,7 +394,7 @@ describe("HttpApi UI fallback", () => { it.live("keeps matched API routes ahead of the UI fallback", () => Effect.gen(function* () { - const server = routeOrderingApp() + const server = yield* routeOrderingApp() const response = yield* server.request("/session/ses_nope") expect(response.status).toBe(404) @@ -368,11 +404,12 @@ describe("HttpApi UI fallback", () => { it.live("requires server password for the web UI", () => Effect.gen(function* () { - const response = yield* uiApp({ + const server = yield* uiApp({ password: "secret", username: "opencode", disableEmbeddedWebUi: true, - }).request("/") + }) + const response = yield* server.request("/") expect(response.status).toBe(401) expect(response.headers.get("www-authenticate")).toBe('Basic realm="Secure Area"') @@ -381,12 +418,13 @@ describe("HttpApi UI fallback", () => { it.live("accepts auth token for the web UI", () => Effect.gen(function* () { - const response = yield* uiApp({ + const server = yield* uiApp({ password: "secret", username: "opencode", disableEmbeddedWebUi: true, client: httpClient(new Response("opencode", { headers: { "content-type": "text/html" } })), - }).request(`/?auth_token=${btoa("opencode:secret")}`) + }) + const response = yield* server.request(`/?auth_token=${btoa("opencode:secret")}`) expect(response.status).toBe(200) expect(yield* responseText(response)).toBe("opencode") @@ -395,11 +433,12 @@ describe("HttpApi UI fallback", () => { it.live("accepts basic auth for the web UI", () => Effect.gen(function* () { - const response = yield* uiApp({ + const server = yield* uiApp({ password: "secret", username: "opencode", disableEmbeddedWebUi: true, - }).request("/", { + }) + const response = yield* server.request("/", { headers: { authorization: `Basic ${btoa("opencode:secret")}` }, }) @@ -409,11 +448,12 @@ describe("HttpApi UI fallback", () => { it.live("accepts basic auth passwords containing colons for the web UI", () => Effect.gen(function* () { - const response = yield* uiApp({ + const server = yield* uiApp({ password: "sec:ret", username: "opencode", disableEmbeddedWebUi: true, - }).request("/", { + }) + const response = yield* server.request("/", { headers: { authorization: `Basic ${btoa("opencode:sec:ret")}` }, }) @@ -428,13 +468,15 @@ describe("HttpApi UI fallback", () => { // should bypass auth. it.live("serves the PWA manifest without auth even when a server password is set", () => Effect.gen(function* () { + // 每个资源使用独立客户端层,全部 handler 都归本例 scope,不能只释放最后创建的一份。 for (const path of ["/site.webmanifest", "/web-app-manifest-192x192.png", "/web-app-manifest-512x512.png"]) { - const response = yield* uiApp({ + const server = yield* uiApp({ password: "secret", username: "opencode", disableEmbeddedWebUi: true, client: httpClient(new Response("ok")), - }).request(path) + }) + const response = yield* server.request(path) expect(response.status).not.toBe(401) } }), @@ -442,7 +484,8 @@ describe("HttpApi UI fallback", () => { it.live("allows web UI preflight without auth", () => Effect.gen(function* () { - const response = yield* app({ password: "secret", username: "opencode" }).request("/", { + const server = yield* app({ password: "secret", username: "opencode" }) + const response = yield* server.request("/", { method: "OPTIONS", headers: { origin: "http://localhost:3000", diff --git a/packages/tui/test/cli/cmd/tui/session-message-render.test.tsx b/packages/tui/test/cli/cmd/tui/session-message-render.test.tsx index e9f5ac4b038f..250307837d42 100644 --- a/packages/tui/test/cli/cmd/tui/session-message-render.test.tsx +++ b/packages/tui/test/cli/cmd/tui/session-message-render.test.tsx @@ -115,7 +115,11 @@ async function withRenderedSession(messages: Array , { ...size, footerHeight: 0, useThread: false }) try { - await waitForFrame(app, () => Boolean(ctx && ctx.sync.status === "complete" && ctx.local.model.ready && ctx.sync.data.message[sid]?.length)) + // 有用户历史时只恢复一次 model;等原子重命名完成后,临时目录才可被 teardown 删除。 + await waitForFrame(app, async () => + Boolean(ctx && ctx.sync.status === "complete" && ctx.local.model.ready && ctx.sync.data.message[sid]?.length) && + (!messages.some((message) => message.role === "user") || await Bun.file(`${tmp.path}/model.json`).exists()), + ) if (!ctx) throw new Error("Session harness did not mount") await run(app, events.emit, ctx) } finally { @@ -133,13 +137,13 @@ async function pumpFrames(app: App, rounds: number) { await Bun.sleep(0) } } -async function waitForFrame(app: App, predicate: (frame: string) => boolean) { +async function waitForFrame(app: App, predicate: (frame: string) => boolean | Promise) { // 单调时钟保证受控推进Date.now时也有真实超时,不把等待变成无界循环。 const start = performance.now() while (performance.now() - start < 5_000) { await pumpFrames(app, 1) const frame = app.captureCharFrame() - if (predicate(frame)) return frame + if (await predicate(frame)) return frame } throw new Error(`frame did not settle:\n${app.captureCharFrame()}`) } diff --git a/packages/tui/test/fixture/tui-sdk.ts b/packages/tui/test/fixture/tui-sdk.ts index ca54f7b379bd..c2053c1287a7 100644 --- a/packages/tui/test/fixture/tui-sdk.ts +++ b/packages/tui/test/fixture/tui-sdk.ts @@ -79,6 +79,9 @@ export function createFetch(override?: FetchHandler, events?: ReturnType { + await withRenderedReview([{ info, parts: [part] }], async (app, _route, _emit, _commands, sync) => { + // 通过真实 SDK 验证默认空问题列表,避免缺失请求产生的提示遮住审查标签。 + if (scenario === "read-error") { + await sync.question.sync(sessionID) + expect(sync.question.list(sessionID)).toEqual([]) + } await waitForReviewFrame(app, async (frame) => { if (plain ? frame.includes(patch ? "a.ts" : "config.ts") : frame.includes("@permission-reviewer")) return true await Bun.sleep(10) @@ -423,6 +428,7 @@ test.each(["read", "read-error", "generic", "edit", "write", "running-output", " await app.renderOnce() const lines = app.captureCharFrame().split("\n") const reviewRows = lines.filter((line) => line.includes("auto review")) + if (scenario === "read-error") expect(lines.join("\n")).not.toContain("unexpected request:") expect(reviewRows).toHaveLength(plain ? 0 : 1) // 缺省KV必须显示真实非空generic输出,空字符串不会经过被修改的分支。 if (scenario === "generic") expect(lines.join("\n")).toContain("GENERIC_OUTPUT") diff --git a/patches/@opentui%2Fsolid@0.4.3-smark.13.patch b/patches/@opentui%2Fsolid@0.4.3-smark.13.patch new file mode 100644 index 000000000000..00c2ede475bf --- /dev/null +++ b/patches/@opentui%2Fsolid@0.4.3-smark.13.patch @@ -0,0 +1,28 @@ +diff --git a/scripts/solid-transform.js b/scripts/solid-transform.js +--- a/scripts/solid-transform.js ++++ b/scripts/solid-transform.js +@@ -1,10 +1,3 @@ +-import { transformAsync } from "@babel/core"; +-// @ts-expect-error - Types not important. +-import ts from "@babel/preset-typescript"; +-// @ts-expect-error - Types not important. +-import moduleResolver from "babel-plugin-module-resolver"; +-// @ts-expect-error - Types not important. +-import solid from "babel-preset-solid"; + const nodeModulesPattern = /[/\\]node_modules[/\\]/; + const tsPattern = /\.[cm]?tsx?$/; + const jsxPattern = /\.[cm]?[jt]sx$/; +@@ -28,6 +21,13 @@ + } + } + export async function transformSolidSource(code, options) { ++ // 保持插件注册轻量,只有实际转换源码时才加载 Babel 依赖。 ++ const [{ transformAsync }, { default: ts }, { default: moduleResolver }, { default: solid }] = await Promise.all([ ++ import("@babel/core"), ++ import("@babel/preset-typescript"), ++ import("babel-plugin-module-resolver"), ++ import("babel-preset-solid"), ++ ]); + const filename = stripQueryAndHash(options.filename); + const plugins = options.resolvePath + ? [ diff --git a/turbo.json b/turbo.json index 867ba76371a7..0731f1fef4f1 100644 --- a/turbo.json +++ b/turbo.json @@ -21,7 +21,7 @@ "passThroughEnv": ["*"] }, "opencode#test:ci": { - "dependsOn": ["^build"], + "dependsOn": ["^build", "@opencode-ai/codemode#test"], "env": ["OPENCODE_TEST_SHARD"], "outputs": [".artifacts/unit/*.xml"], "passThroughEnv": ["*"] @@ -35,6 +35,9 @@ "dependsOn": ["^build"], "outputs": [] }, + "@opencode-ai/codemode#test": { + "cache": false + }, "@opencode-ai/function#test": { "outputs": [] },