saeeol 1.2.5 → 1.2.8

package/test/server/httpapi-instance.test.ts

@@ -1,83 +0,0 @@
-import { NodeHttpServer, NodeServices } from "@effect/platform-node"
-import { Flag } from "@saeeol/core/flag/flag"
-import { describe, expect } from "bun:test"
-import { Config, Effect, FileSystem, Layer, Path } from "effect"
-import { HttpClient, HttpClientRequest, HttpRouter, HttpServer } from "effect/unstable/http"
-import * as Socket from "effect/unstable/socket/Socket"
-import { InstancePaths } from "../../src/server/routes/instance/httpapi/groups/instance"
-import { ExperimentalHttpApiServer } from "../../src/server/routes/instance/httpapi/server"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, tmpdirScoped } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-// Flip the experimental HttpApi flag so backend selection telemetry on the
-// production routes reports the right backend, and reset the database around
-// the test so per-instance state does not leak between runs. resetDatabase()
-// already calls disposeAllInstances(), so we don't repeat it.
-const testStateLayer = Layer.effectDiscard(
-  Effect.gen(function* () {
-    const originalHttpApi = Flag.SAEEOL_EXPERIMENTAL_HTTPAPI
-    Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = true
-    yield* Effect.promise(() => resetDatabase())
-    yield* Effect.addFinalizer(() =>
-      Effect.promise(async () => {
-        Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = originalHttpApi
-        await resetDatabase()
-      }),
-    )
-  }),
-)
-
-// Mount the production HttpApi route tree on a real Node HTTP server bound to
-// 127.0.0.1:0 and a fetch-based HttpClient that prepends the server URL. This
-// keeps the test wired through the same route layer production uses, without
-// going through Server.Default()/Hono.
-const servedRoutes: Layer.Layer<never, Config.ConfigError, HttpServer.HttpServer> = HttpRouter.serve(
-  ExperimentalHttpApiServer.routes,
-  { disableListenLog: true, disableLogger: true },
-)
-
-const httpApiServerLayer = servedRoutes.pipe(
-  Layer.provide(Socket.layerWebSocketConstructorGlobal),
-  Layer.provideMerge(NodeHttpServer.layerTest),
-  Layer.provideMerge(NodeServices.layer),
-)
-
-const it = testEffect(Layer.mergeAll(testStateLayer, httpApiServerLayer))
-
-const directoryHeader = (dir: string) => HttpClientRequest.setHeader("x-saeeol-directory", dir)
-
-describe("instance HttpApi", () => {
-  it.live("serves path and VCS read endpoints", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      const fs = yield* FileSystem.FileSystem
-      const path = yield* Path.Path
-      yield* fs.writeFileString(path.join(dir, "changed.txt"), "hello")
-
-      const [paths, vcs, diff] = yield* Effect.all(
-        [
-          HttpClientRequest.get(InstancePaths.path).pipe(directoryHeader(dir), HttpClient.execute),
-          HttpClientRequest.get(InstancePaths.vcs).pipe(directoryHeader(dir), HttpClient.execute),
-          HttpClientRequest.get(InstancePaths.vcsDiff).pipe(
-            HttpClientRequest.setUrlParam("mode", "git"),
-            directoryHeader(dir),
-            HttpClient.execute,
-          ),
-        ],
-        { concurrency: "unbounded" },
-      )
-
-      expect(paths.status).toBe(200)
-      expect(yield* paths.json).toMatchObject({ directory: dir, worktree: dir })
-
-      expect(vcs.status).toBe(200)
-      expect(yield* vcs.json).toMatchObject({ branch: expect.any(String) })
-
-      expect(diff.status).toBe(200)
-      expect(yield* diff.json).toContainEqual(
-        expect.objectContaining({ file: "changed.txt", additions: 1, status: "added" }),
-      )
-    }),
-  )
-})

package/test/server/httpapi-json-parity.test.ts

@@ -1,263 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { Flag } from "@saeeol/core/flag/flag"
-import { ModelID, ProviderID } from "../../src/provider/schema"
-import { Instance } from "../../src/project/instance"
-import { Server } from "../../src/server/server"
-import { ExperimentalPaths } from "../../src/server/routes/instance/httpapi/groups/experimental"
-import { FilePaths } from "../../src/server/routes/instance/httpapi/groups/file"
-import { GlobalPaths } from "../../src/server/routes/instance/httpapi/groups/global"
-import { InstancePaths } from "../../src/server/routes/instance/httpapi/groups/instance"
-import { McpPaths } from "../../src/server/routes/instance/httpapi/groups/mcp"
-import { PtyPaths } from "../../src/server/routes/instance/httpapi/groups/pty"
-import { SessionPaths } from "../../src/server/routes/instance/httpapi/groups/session"
-import { MessageID, PartID } from "../../src/session/schema"
-import { Session } from "@/session/session"
-import * as Log from "@saeeol/core/util/log"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, provideInstance, tmpdir } from "../fixture/fixture"
-import { it } from "../lib/effect"
-
-void Log.init({ print: false })
-
-const original = Flag.SAEEOL_EXPERIMENTAL_HTTPAPI
-
-function app(experimental: boolean) {
-  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = experimental
-  return experimental ? Server.Default().app : Server.Legacy().app
-}
-type TestApp = ReturnType<typeof app>
-
-function pathFor(path: string, params: Record<string, string>) {
-  return Object.entries(params).reduce((result, [key, value]) => result.replace(`:${key}`, value), path)
-}
-
-const seedSessions = Effect.gen(function* () {
-  const svc = yield* Session.Service
-  const parent = yield* svc.create({ title: "parent" })
-  yield* svc.create({ title: "child", parentID: parent.id })
-  const message = yield* svc.updateMessage({
-    id: MessageID.ascending(),
-    role: "user",
-    sessionID: parent.id,
-    agent: "build",
-    model: { providerID: ProviderID.make("test"), modelID: ModelID.make("test") },
-    time: { created: Date.now() },
-  })
-  yield* svc.updatePart({
-    id: PartID.ascending(),
-    sessionID: parent.id,
-    messageID: message.id,
-    type: "text",
-    text: "hello",
-  })
-  return { parent, message }
-})
-
-function withTmp<A, E, R>(
-  options: Parameters<typeof tmpdir>[0],
-  fn: (tmp: Awaited<ReturnType<typeof tmpdir>>) => Effect.Effect<A, E, R>,
-) {
-  return Effect.acquireRelease(
-    Effect.promise(() => tmpdir(options)),
-    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-  ).pipe(Effect.flatMap((tmp) => fn(tmp).pipe(provideInstance(tmp.path))))
-}
-
-function readJson(label: string, serverApp: TestApp, path: string, headers: HeadersInit) {
-  return Effect.promise(async () => {
-    const response = await serverApp.request(path, { headers })
-    if (response.status !== 200) throw new Error(`${label} returned ${response.status}: ${await response.text()}`)
-    return await response.json()
-  })
-}
-
-function expectJsonParity(input: {
-  label: string
-  legacy: TestApp
-  httpapi: TestApp
-  path: string
-  headers: HeadersInit
-}) {
-  return Effect.gen(function* () {
-    const legacy = yield* readJson(input.label, input.legacy, input.path, input.headers)
-    const httpapi = yield* readJson(input.label, input.httpapi, input.path, input.headers)
-    expect({ label: input.label, body: httpapi }).toEqual({ label: input.label, body: legacy })
-    return httpapi
-  })
-}
-
-afterEach(async () => {
-  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = original
-  await disposeAllInstances()
-  await resetDatabase()
-})
-//   1. Effect's HttpApi runtime emits `field: null` for Schema.optional() values when
-//      the source data has the property as undefined. JSON.stringify (Hono) omits them.
-//      Many Saeeol-specific Model fields (ai_sdk_provider, prompt, recommendedIndex,
-//      isFree) and Command fields (agent, model, subtask) hit this.
-//   2. The two backends share Saeeol's ConfigService cache; reading /config twice in
-//      sequence (legacy then httpapi) can return different defaults as the cache
-//      mutates. Same for ModelsDev and provider lists.
-// The parity test is upstream-added and assumes saeeol's plain Schema shape.
-// Skip until either the Saeeol schemas migrate to NullOr or the parity test learns
-// to ignore Saeeol-specific extra fields.
-describe.skip("HttpApi JSON parity", () => {
-  it.live(
-    "matches legacy JSON shape for safe GET endpoints",
-    withTmp(
-      {
-        git: true,
-        config: {
-          formatter: false,
-          lsp: false,
-          mcp: {
-            demo: {
-              type: "local",
-              command: ["echo", "demo"],
-              enabled: false,
-            },
-          },
-        },
-      },
-      (tmp) =>
-        Effect.gen(function* () {
-          yield* Effect.promise(() => Bun.write(`${tmp.path}/hello.txt`, "hello\n"))
-
-          const headers = { "x-saeeol-directory": tmp.path }
-          const legacy = app(false)
-          const httpapi = app(true)
-
-          yield* Effect.forEach(
-            [
-              { label: "global.health", path: GlobalPaths.health, headers: {} },
-              { label: "global.config", path: GlobalPaths.config, headers: {} },
-              { label: "instance.path", path: InstancePaths.path, headers },
-              { label: "instance.vcs", path: InstancePaths.vcs, headers },
-              { label: "instance.vcsDiff", path: `${InstancePaths.vcsDiff}?mode=git`, headers },
-              { label: "instance.command", path: InstancePaths.command, headers },
-              { label: "instance.agent", path: InstancePaths.agent, headers },
-              { label: "instance.skill", path: InstancePaths.skill, headers },
-              { label: "instance.lsp", path: InstancePaths.lsp, headers },
-              { label: "instance.formatter", path: InstancePaths.formatter, headers },
-              { label: "config.get", path: "/config", headers },
-              { label: "config.providers", path: "/config/providers", headers },
-              { label: "project.list", path: "/project", headers },
-              { label: "project.current", path: "/project/current", headers },
-              { label: "provider.list", path: "/provider", headers },
-              { label: "provider.auth", path: "/provider/auth", headers },
-              { label: "permission.list", path: "/permission", headers },
-              { label: "question.list", path: "/question", headers },
-              { label: "mcp.status", path: McpPaths.status, headers },
-              { label: "pty.shells", path: PtyPaths.shells, headers },
-              { label: "pty.list", path: PtyPaths.list, headers },
-              { label: "file.list", path: `${FilePaths.list}?${new URLSearchParams({ path: "." })}`, headers },
-              {
-                label: "file.content",
-                path: `${FilePaths.content}?${new URLSearchParams({ path: "hello.txt" })}`,
-                headers,
-              },
-              { label: "file.status", path: FilePaths.status, headers },
-              {
-                label: "find.file",
-                path: `${FilePaths.findFile}?${new URLSearchParams({ query: "hello", dirs: "false" })}`,
-                headers,
-              },
-              {
-                label: "find.text",
-                path: `${FilePaths.findText}?${new URLSearchParams({ pattern: "hello" })}`,
-                headers,
-              },
-              {
-                label: "find.symbol",
-                path: `${FilePaths.findSymbol}?${new URLSearchParams({ query: "hello" })}`,
-                headers,
-              },
-              { label: "experimental.console", path: ExperimentalPaths.console, headers },
-              { label: "experimental.consoleOrgs", path: ExperimentalPaths.consoleOrgs, headers },
-              { label: "experimental.toolIDs", path: ExperimentalPaths.toolIDs, headers },
-              { label: "experimental.worktree", path: ExperimentalPaths.worktree, headers },
-              { label: "experimental.resource", path: ExperimentalPaths.resource, headers },
-            ],
-            (input) => expectJsonParity({ ...input, legacy, httpapi }),
-            { concurrency: 1 },
-          )
-        }),
-    ),
-  )
-
-  it.live(
-    "matches legacy JSON shape for session read endpoints",
-    withTmp({ git: true, config: { formatter: false, lsp: false } }, (tmp) =>
-      Effect.gen(function* () {
-        const headers = { "x-saeeol-directory": tmp.path }
-        const seeded = yield* seedSessions.pipe(Effect.provide(Session.defaultLayer))
-        const legacy = app(false)
-        const httpapi = app(true)
-
-        const rootsFalse = yield* expectJsonParity({
-          label: "session.list roots false",
-          legacy,
-          httpapi,
-          path: `${SessionPaths.list}?roots=false`,
-          headers,
-        })
-        expect((rootsFalse as Session.Info[]).map((session) => session.id)).toContain(seeded.parent.id)
-        expect((rootsFalse as Session.Info[]).length).toBe(2)
-
-        const experimentalRootsFalse = yield* expectJsonParity({
-          label: "experimental.session roots false",
-          legacy,
-          httpapi,
-          path: `${ExperimentalPaths.session}?${new URLSearchParams({ directory: tmp.path, limit: "10", roots: "false" })}`,
-          headers,
-        })
-        expect((experimentalRootsFalse as Session.GlobalInfo[]).length).toBe(2)
-
-        const experimentalArchivedFalse = yield* expectJsonParity({
-          label: "experimental.session archived false",
-          legacy,
-          httpapi,
-          path: `${ExperimentalPaths.session}?${new URLSearchParams({ directory: tmp.path, limit: "10", archived: "false" })}`,
-          headers,
-        })
-        expect((experimentalArchivedFalse as Session.GlobalInfo[]).length).toBe(2)
-
-        yield* Effect.forEach(
-          [
-            { label: "session.list roots", path: `${SessionPaths.list}?roots=true`, headers },
-            { label: "session.list all", path: SessionPaths.list, headers },
-            { label: "session.get", path: pathFor(SessionPaths.get, { sessionID: seeded.parent.id }), headers },
-            {
-              label: "session.children",
-              path: pathFor(SessionPaths.children, { sessionID: seeded.parent.id }),
-              headers,
-            },
-            {
-              label: "session.messages",
-              path: pathFor(SessionPaths.messages, { sessionID: seeded.parent.id }),
-              headers,
-            },
-            {
-              label: "session.messages empty before",
-              path: `${pathFor(SessionPaths.messages, { sessionID: seeded.parent.id })}?before=`,
-              headers,
-            },
-            {
-              label: "session.message",
-              path: pathFor(SessionPaths.message, { sessionID: seeded.parent.id, messageID: seeded.message.id }),
-              headers,
-            },
-            {
-              label: "experimental.session",
-              path: `${ExperimentalPaths.session}?${new URLSearchParams({ directory: tmp.path, limit: "10" })}`,
-              headers,
-            },
-          ],
-          (input) => expectJsonParity({ ...input, legacy, httpapi }),
-          { concurrency: 1 },
-        )
-      }),
-    ),
-  )
-})

package/test/server/httpapi-mcp-oauth.test.ts

@@ -1,76 +0,0 @@
-import { NodeHttpServer } from "@effect/platform-node"
-import { Session } from "@/session/session"
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { HttpClient, HttpClientRequest, HttpRouter } from "effect/unstable/http"
-import { HttpApi, HttpApiBuilder } from "effect/unstable/httpapi"
-import { McpApi, McpPaths } from "../../src/server/routes/instance/httpapi/groups/mcp"
-import { Authorization } from "../../src/server/routes/instance/httpapi/middleware/authorization"
-import { InstanceContextMiddleware } from "../../src/server/routes/instance/httpapi/middleware/instance-context"
-import {
-  WorkspaceRouteContext,
-  WorkspaceRoutingMiddleware,
-} from "../../src/server/routes/instance/httpapi/middleware/workspace-routing"
-import { testEffect } from "../lib/effect"
-
-const TestHttpApi = HttpApi.make("saeeol-instance").addHttpApi(McpApi)
-const fakeSession = Layer.mock(Session.Service)({})
-const testMcpHandlers = HttpApiBuilder.group(TestHttpApi, "mcp", (handlers) =>
-  Effect.succeed(
-    handlers
-      .handle("status", () => Effect.die("unexpected MCP status"))
-      .handle("add", () => Effect.die("unexpected MCP add"))
-      .handle("authStart", () =>
-        Effect.succeed({ authorizationUrl: "https://auth.example/start", oauthState: "state-123" }),
-      )
-      .handle("authCallback", () => Effect.die("unexpected MCP authCallback"))
-      .handle("authAuthenticate", () => Effect.die("unexpected MCP authAuthenticate"))
-      .handle("authRemove", () => Effect.die("unexpected MCP authRemove"))
-      .handle("connect", () => Effect.die("unexpected MCP connect"))
-      .handle("disconnect", () => Effect.die("unexpected MCP disconnect")),
-  ),
-)
-
-const passthroughAuthorization = Layer.succeed(
-  Authorization,
-  Authorization.of({
-    basic: (effect) => effect,
-    authToken: (effect) => effect,
-  }),
-)
-
-const passthroughInstanceContext = Layer.succeed(
-  InstanceContextMiddleware,
-  InstanceContextMiddleware.of((effect) => effect),
-)
-
-const testWorkspaceRouting = Layer.succeed(
-  WorkspaceRoutingMiddleware,
-  WorkspaceRoutingMiddleware.of((effect) =>
-    effect.pipe(Effect.provideService(WorkspaceRouteContext, WorkspaceRouteContext.of({ directory: process.cwd() }))),
-  ),
-)
-
-const it = testEffect(
-  HttpRouter.serve(
-    HttpApiBuilder.layer(TestHttpApi).pipe(
-      Layer.provide(testMcpHandlers),
-      Layer.provide([passthroughAuthorization, passthroughInstanceContext, testWorkspaceRouting, fakeSession]),
-    ),
-    { disableListenLog: true, disableLogger: true },
-  ).pipe(Layer.provideMerge(NodeHttpServer.layerTest)),
-)
-
-describe("mcp HttpApi OAuth", () => {
-  it.live("preserves oauth state when starting OAuth", () =>
-    Effect.gen(function* () {
-      const response = yield* HttpClientRequest.post(McpPaths.auth.replace(":name", "demo")).pipe(HttpClient.execute)
-
-      expect(response.status).toBe(200)
-      expect(yield* response.json).toEqual({
-        authorizationUrl: "https://auth.example/start",
-        oauthState: "state-123",
-      })
-    }),
-  )
-})

package/test/server/httpapi-mcp.test.ts

@@ -1,189 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Context, Effect, FileSystem, Layer, Path } from "effect"
-import { NodeFileSystem, NodePath } from "@effect/platform-node"
-import { Flag } from "@saeeol/core/flag/flag"
-import { ExperimentalHttpApiServer } from "../../src/server/routes/instance/httpapi/server"
-import { McpPaths } from "../../src/server/routes/instance/httpapi/groups/mcp"
-import { Instance } from "../../src/project/instance"
-import { InstanceStore } from "../../src/project/instance-store"
-import { Server } from "../../src/server/server"
-import * as Log from "@saeeol/core/util/log"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, provideInstance, tmpdir } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-void Log.init({ print: false })
-
-const original = Flag.SAEEOL_EXPERIMENTAL_HTTPAPI
-const context = Context.empty() as Context.Context<unknown>
-const it = testEffect(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer))
-
-function app(experimental: boolean) {
-  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = experimental
-  return experimental ? Server.Default().app : Server.Legacy().app
-}
-type TestApp = ReturnType<typeof app>
-
-function request(route: string, directory: string, init?: RequestInit) {
-  const headers = new Headers(init?.headers)
-  headers.set("x-saeeol-directory", directory)
-  return ExperimentalHttpApiServer.webHandler().handler(
-    new Request(`http://localhost${route}`, {
-      ...init,
-      headers,
-    }),
-    context,
-  )
-}
-
-function withMcpProject<A, E, R>(self: (dir: string) => Effect.Effect<A, E, R>) {
-  return Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem
-    const path = yield* Path.Path
-    const dir = yield* fs.makeTempDirectoryScoped({ prefix: "saeeol-test-" })
-
-    yield* fs.writeFileString(
-      path.join(dir, "saeeol.json"),
-      JSON.stringify({
-        $schema: "https://saeeol.ai/config.json",
-        formatter: false,
-        lsp: false,
-        mcp: {
-          demo: {
-            type: "local",
-            command: ["echo", "demo"],
-            enabled: false,
-          },
-        },
-      }),
-    )
-    yield* Effect.addFinalizer(() =>
-      Effect.promise(() =>
-        Instance.provide({ directory: dir, fn: () => InstanceStore.disposeInstance(Instance.current) }),
-      ).pipe(Effect.ignore),
-    )
-
-    return yield* self(dir).pipe(provideInstance(dir))
-  })
-}
-
-const readResponse = Effect.fnUntraced(function* (input: { app: TestApp; path: string; headers: HeadersInit }) {
-  const response = yield* Effect.promise(() =>
-    Promise.resolve(input.app.request(input.path, { method: "POST", headers: input.headers })),
-  )
-  return {
-    status: response.status,
-    body: yield* Effect.promise(() => response.text()),
-  }
-})
-
-afterEach(async () => {
-  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = original
-  await disposeAllInstances()
-  await resetDatabase()
-})
-
-describe("mcp HttpApi", () => {
-  test("serves status endpoint", async () => {
-    await using tmp = await tmpdir({
-      config: {
-        mcp: {
-          demo: {
-            type: "local",
-            command: ["echo", "demo"],
-            enabled: false,
-          },
-        },
-      },
-    })
-
-    const response = await request(McpPaths.status, tmp.path)
-    expect(response.status).toBe(200)
-    expect(await response.json()).toEqual({ demo: { status: "disabled" } })
-  })
-
-  test("serves add, connect, and disconnect endpoints", async () => {
-    await using tmp = await tmpdir({
-      config: {
-        mcp: {
-          demo: {
-            type: "local",
-            command: ["echo", "demo"],
-            enabled: false,
-          },
-        },
-      },
-    })
-
-    const added = await request(McpPaths.status, tmp.path, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({
-        name: "added",
-        config: {
-          type: "local",
-          command: ["echo", "added"],
-          enabled: false,
-        },
-      }),
-    })
-    expect(added.status).toBe(200)
-    expect(await added.json()).toMatchObject({ added: { status: "disabled" } })
-
-    const connected = await request("/mcp/demo/connect", tmp.path, { method: "POST" })
-    expect(connected.status).toBe(200)
-    expect(await connected.json()).toBe(true)
-
-    const disconnected = await request("/mcp/demo/disconnect", tmp.path, { method: "POST" })
-    expect(disconnected.status).toBe(200)
-    expect(await disconnected.json()).toBe(true)
-  })
-
-  test("serves deterministic OAuth endpoints", async () => {
-    await using tmp = await tmpdir({
-      config: {
-        mcp: {
-          demo: {
-            type: "local",
-            command: ["echo", "demo"],
-            enabled: false,
-          },
-        },
-      },
-    })
-
-    const start = await request("/mcp/demo/auth", tmp.path, { method: "POST" })
-    expect(start.status).toBe(400)
-
-    const authenticate = await request("/mcp/demo/auth/authenticate", tmp.path, { method: "POST" })
-    expect(authenticate.status).toBe(400)
-
-    const removed = await request("/mcp/demo/auth", tmp.path, { method: "DELETE" })
-    expect(removed.status).toBe(200)
-    expect(await removed.json()).toEqual({ success: true })
-  })
-
-  it.live(
-    "matches legacy unsupported OAuth error responses",
-    withMcpProject((dir) =>
-      Effect.gen(function* () {
-        const headers = { "x-saeeol-directory": dir }
-        const legacy = app(false)
-        const httpapi = app(true)
-
-        yield* Effect.forEach(["/mcp/demo/auth", "/mcp/demo/auth/authenticate"], (path) =>
-          Effect.gen(function* () {
-            const legacyResponse = yield* readResponse({ app: legacy, path, headers })
-            const httpapiResponse = yield* readResponse({ app: httpapi, path, headers })
-
-            expect(legacyResponse).toEqual({
-              status: 400,
-              body: JSON.stringify({ error: "MCP server demo does not support OAuth" }),
-            })
-            expect(httpapiResponse).toEqual(legacyResponse)
-          }),
-        )
-      }),
-    ),
-  )
-})