saeeol 1.2.5 → 1.2.8

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

@@ -1,219 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { Flag } from "@saeeol/core/flag/flag"
-import { GlobalBus } from "@/bus/global"
-import { Instance } from "../../src/project/instance"
-import { Server } from "../../src/server/server"
-import { ExperimentalPaths } from "../../src/server/routes/instance/httpapi/groups/experimental"
-import { Session } from "@/session/session"
-import { Database } from "@/storage/db"
-import * as Log from "@saeeol/core/util/log"
-import { Worktree } from "../../src/worktree"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-
-void Log.init({ print: false })
-
-const original = Flag.SAEEOL_EXPERIMENTAL_HTTPAPI
-const testWorktreeMutations = process.platform === "win32" ? test.skip : test
-
-function app() {
-  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = true
-  return Server.Default().app
-}
-
-function runSession<A, E>(fx: Effect.Effect<A, E, Session.Service>) {
-  return Effect.runPromise(fx.pipe(Effect.provide(Session.defaultLayer)))
-}
-
-function createSession(input?: Session.CreateInput) {
-  return runSession(Session.Service.use((svc) => svc.create(input)))
-}
-
-async function waitReady(directory: string) {
-  return await new Promise<void>((resolve, reject) => {
-    const timer = setTimeout(() => {
-      GlobalBus.off("event", onEvent)
-      reject(new Error("timed out waiting for worktree.ready"))
-    }, 10_000)
-
-    function onEvent(event: { directory?: string; payload: { type?: string } }) {
-      if (event.payload.type !== Worktree.Event.Ready.type || event.directory !== directory) return
-      clearTimeout(timer)
-      GlobalBus.off("event", onEvent)
-      resolve()
-    }
-
-    GlobalBus.on("event", onEvent)
-  })
-}
-
-afterEach(async () => {
-  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = original
-  await disposeAllInstances()
-  await resetDatabase()
-})
-
-describe("experimental HttpApi", () => {
-  // The /experimental/tool handler 500s via the bridge (InstanceState/AsyncLocalStorage leak).
-  // Bridge is gated behind SAEEOL_EXPERIMENTAL_HTTPAPI, not enabled in any production client.
-  test.skip("serves read-only experimental endpoints through Hono bridge", async () => {
-    await using tmp = await tmpdir({
-      config: {
-        formatter: false,
-        lsp: false,
-        mcp: {
-          demo: {
-            type: "local",
-            command: ["echo", "demo"],
-            enabled: false,
-          },
-        },
-      },
-    })
-
-    const headers = { "x-saeeol-directory": tmp.path }
-    const [consoleState, consoleOrgs, toolList, toolIDs, worktrees, resources] = await Promise.all([
-      app().request(ExperimentalPaths.console, { headers }),
-      app().request(ExperimentalPaths.consoleOrgs, { headers }),
-      app().request(`${ExperimentalPaths.tool}?provider=saeeol&model=gpt-5`, { headers }),
-      app().request(ExperimentalPaths.toolIDs, { headers }),
-      app().request(ExperimentalPaths.worktree, { headers }),
-      app().request(ExperimentalPaths.resource, { headers }),
-    ])
-
-    expect(consoleState.status).toBe(200)
-    expect(await consoleState.json()).toEqual({
-      consoleManagedProviders: [],
-      switchableOrgCount: 0,
-    })
-
-    expect(consoleOrgs.status).toBe(200)
-    expect(await consoleOrgs.json()).toEqual({ orgs: [] })
-
-    expect(toolList.status).toBe(200)
-    expect(await toolList.json()).toContainEqual(
-      expect.objectContaining({
-        id: "bash",
-        description: expect.any(String),
-        parameters: expect.any(Object),
-      }),
-    )
-
-    expect(toolIDs.status).toBe(200)
-    expect(await toolIDs.json()).toContain("bash")
-
-    expect(worktrees.status).toBe(200)
-    expect(await worktrees.json()).toEqual([])
-
-    expect(resources.status).toBe(200)
-    expect(await resources.json()).toEqual({})
-  })
-
-  test("serves Console org switch through Hono bridge", async () => {
-    await using tmp = await tmpdir({ config: { formatter: false, lsp: false } })
-    Database.Client()
-      .$client.prepare(
-        "INSERT INTO account (id, email, url, access_token, refresh_token, time_created, time_updated) VALUES (?, ?, ?, ?, ?, ?, ?)",
-      )
-      .run(
-        "account-test",
-        "test@example.com",
-        "https://console.example.com",
-        "access",
-        "refresh",
-        Date.now(),
-        Date.now(),
-      )
-
-    const switched = await app().request(ExperimentalPaths.consoleSwitch, {
-      method: "POST",
-      headers: { "x-saeeol-directory": tmp.path, "content-type": "application/json" },
-      body: JSON.stringify({ accountID: "account-test", orgID: "org-test" }),
-    })
-
-    expect(switched.status).toBe(200)
-    expect(await switched.json()).toBe(true)
-  })
-
-  test("serves global session list through Hono bridge", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-
-    const first = await Instance.provide({
-      directory: tmp.path,
-      fn: async () => createSession({ title: "page-one" }),
-    })
-    await new Promise((resolve) => setTimeout(resolve, 5))
-    const second = await Instance.provide({
-      directory: tmp.path,
-      fn: async () => createSession({ title: "page-two" }),
-    })
-
-    const headers = { "x-saeeol-directory": tmp.path }
-    const page = await app().request(
-      `${ExperimentalPaths.session}?${new URLSearchParams({ directory: tmp.path, limit: "1" })}`,
-      { headers },
-    )
-    expect(page.status).toBe(200)
-    expect(page.headers.get("x-next-cursor")).toBeTruthy()
-
-    const body = (await page.json()) as Session.GlobalInfo[]
-    expect(body.map((session) => session.id)).toEqual([second.id])
-    expect(body[0].project?.id).toBe(second.projectID)
-
-    const next = await app().request(
-      `${ExperimentalPaths.session}?${new URLSearchParams({
-        directory: tmp.path,
-        limit: "10",
-        cursor: body[0].time.updated.toString(),
-      })}`,
-      { headers },
-    )
-    expect(next.status).toBe(200)
-    expect(((await next.json()) as Session.GlobalInfo[]).map((session) => session.id)).toContain(first.id)
-  })
-
-  testWorktreeMutations("serves worktree mutations through Hono bridge", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-
-    const headers = { "x-saeeol-directory": tmp.path, "content-type": "application/json" }
-    const created = await app().request(ExperimentalPaths.worktree, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({ name: "api-test" }),
-    })
-
-    expect(created.status).toBe(200)
-    const info = (await created.json()) as Worktree.Info
-    expect(info).toMatchObject({ name: "api-test", branch: "saeeol/api-test" })
-    await waitReady(info.directory)
-
-    const listed = await app().request(ExperimentalPaths.worktree, { headers })
-    expect(listed.status).toBe(200)
-    expect(await listed.json()).toContain(info.directory)
-
-    if (process.platform !== "win32") {
-      const reset = await app().request(ExperimentalPaths.worktreeReset, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({ directory: info.directory }),
-      })
-
-      expect(reset.status).toBe(200)
-      expect(await reset.json()).toBe(true)
-    }
-
-    const removed = await app().request(ExperimentalPaths.worktree, {
-      method: "DELETE",
-      headers,
-      body: JSON.stringify({ directory: info.directory }),
-    })
-
-    expect(removed.status).toBe(200)
-    expect(await removed.json()).toBe(true)
-
-    const afterRemove = await app().request(ExperimentalPaths.worktree, { headers })
-    expect(afterRemove.status).toBe(200)
-    expect(await afterRemove.json()).toEqual([])
-  })
-})

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

@@ -1,79 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Context } from "effect"
-import path from "path"
-import { ExperimentalHttpApiServer } from "../../src/server/routes/instance/httpapi/server"
-import { FilePaths } from "../../src/server/routes/instance/httpapi/groups/file"
-import { Instance } from "../../src/project/instance"
-import * as Log from "@saeeol/core/util/log"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-
-void Log.init({ print: false })
-
-const context = Context.empty() as Context.Context<unknown>
-
-function request(route: string, directory: string, query?: Record<string, string>) {
-  const url = new URL(`http://localhost${route}`)
-  for (const [key, value] of Object.entries(query ?? {})) {
-    url.searchParams.set(key, value)
-  }
-  return ExperimentalHttpApiServer.webHandler().handler(
-    new Request(url, {
-      headers: {
-        "x-saeeol-directory": directory,
-      },
-    }),
-    context,
-  )
-}
-
-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")
-
-    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),
-    ])
-
-    expect(list.status).toBe(200)
-    expect(await 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(status.status).toBe(200)
-    expect(await status.json()).toContainEqual({ path: "hello.txt", added: 1, removed: 0, status: "added" })
-  })
-  // Other platforms pass; bridge is gated behind SAEEOL_EXPERIMENTAL_HTTPAPI and not enabled in production.
-  // Tracked in SAEEOL/saeeol#9831.
-  const searchTest = process.platform === "win32" ? test.skip : test
-  searchTest("serves search endpoints", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Bun.write(path.join(tmp.path, "hello.txt"), "needle")
-
-    const [text, files, symbols] = await Promise.all([
-      request(FilePaths.findText, tmp.path, { pattern: "needle" }),
-      request(FilePaths.findFile, tmp.path, { query: "hello", type: "file" }),
-      request(FilePaths.findSymbol, tmp.path, { query: "hello" }),
-    ])
-
-    expect(text.status).toBe(200)
-    expect(await text.json()).toContainEqual(expect.objectContaining({ line_number: 1 }))
-
-    expect(files.status).toBe(200)
-    expect(await files.json()).toContain("hello.txt")
-
-    expect(symbols.status).toBe(200)
-    expect(await symbols.json()).toEqual([])
-  })
-})

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

@@ -1,237 +0,0 @@
-import { NodeHttpServer, NodeServices } from "@effect/platform-node"
-import { Flag } from "@saeeol/core/flag/flag"
-import { GlobalBus } from "@/bus/global"
-import { describe, expect } from "bun:test"
-import { Effect, Fiber, Layer } from "effect"
-import { HttpClient, HttpClientRequest, HttpRouter, HttpServerResponse } from "effect/unstable/http"
-import * as Socket from "effect/unstable/socket/Socket"
-import { mkdir } from "node:fs/promises"
-import path from "node:path"
-import { registerAdapter } from "../../src/control-plane/adapters"
-import type { WorkspaceAdapter } from "../../src/control-plane/types"
-import { Workspace } from "../../src/control-plane/workspace"
-import { InstanceRef, WorkspaceRef } from "../../src/effect/instance-ref"
-import { InstanceBootstrap } from "../../src/project/bootstrap"
-import { Instance } from "../../src/project/instance"
-import { InstanceStore } from "../../src/project/instance-store"
-import { Project } from "../../src/project/project"
-import { disposeMiddleware, markInstanceForDisposal } from "../../src/server/routes/instance/httpapi/lifecycle"
-import { instanceRouterMiddleware } from "../../src/server/routes/instance/httpapi/middleware/instance-context"
-import { workspaceRouterMiddleware } from "../../src/server/routes/instance/httpapi/middleware/workspace-routing"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, tmpdirScoped } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-const testStateLayer = Layer.effectDiscard(
-  Effect.gen(function* () {
-    const originalWorkspaces = Flag.SAEEOL_EXPERIMENTAL_WORKSPACES
-    yield* Effect.promise(() => resetDatabase())
-    Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = true
-    yield* Effect.addFinalizer(() =>
-      Effect.promise(async () => {
-        Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = originalWorkspaces
-        await disposeAllInstances()
-        await resetDatabase()
-      }),
-    )
-  }),
-)
-
-const it = testEffect(
-  Layer.mergeAll(
-    testStateLayer,
-    NodeHttpServer.layerTest,
-    NodeServices.layer,
-    InstanceBootstrap.defaultLayer,
-    InstanceStore.defaultLayer,
-    Project.defaultLayer,
-    Workspace.defaultLayer,
-  ),
-)
-
-const instanceContextTestLayer = instanceRouterMiddleware
-  .combine(workspaceRouterMiddleware)
-  .layer.pipe(Layer.provide(Socket.layerWebSocketConstructorGlobal))
-
-const localAdapter = (directory: string): WorkspaceAdapter => ({
-  name: "Local Test",
-  description: "Create a local test workspace",
-  configure: (info) => ({ ...info, name: "local-test", directory }),
-  create: async () => {
-    await mkdir(directory, { recursive: true })
-  },
-  async remove() {},
-  target: () => ({ type: "local" as const, directory }),
-})
-
-const createLocalWorkspace = (input: { projectID: Project.Info["id"]; type: string; directory: string }) =>
-  Effect.acquireRelease(
-    Effect.gen(function* () {
-      registerAdapter(input.projectID, input.type, localAdapter(input.directory))
-      const workspace = yield* Workspace.Service
-      return yield* workspace.create({
-        type: input.type,
-        branch: null,
-        extra: null,
-        projectID: input.projectID,
-      })
-    }),
-    (info) => Workspace.Service.use((workspace) => workspace.remove(info.id)).pipe(Effect.ignore),
-  )
-
-const probeInstanceContext = Effect.gen(function* () {
-  const instance = yield* InstanceRef
-  const workspaceID = yield* WorkspaceRef
-  return yield* HttpServerResponse.json({
-    directory: instance?.directory,
-    worktree: instance?.worktree,
-    projectID: instance?.project.id,
-    workspaceID,
-  })
-})
-
-const serveProbe = (probePath: HttpRouter.PathInput = "/probe") =>
-  HttpRouter.add("GET", probePath, probeInstanceContext).pipe(
-    Layer.provide(instanceContextTestLayer),
-    HttpRouter.serve,
-    Layer.build,
-  )
-
-const waitDisposedEvent = Effect.promise(
-  () =>
-    new Promise<{ directory?: string; workspace?: string }>((resolve, reject) => {
-      const timer = setTimeout(() => {
-        GlobalBus.off("event", onEvent)
-        reject(new Error("timed out waiting for instance disposal"))
-      }, 10_000)
-
-      function onEvent(event: { directory?: string; workspace?: string; payload: { type?: string } }) {
-        if (event.payload.type !== "server.instance.disposed") return
-        clearTimeout(timer)
-        GlobalBus.off("event", onEvent)
-        resolve({ directory: event.directory, workspace: event.workspace })
-      }
-
-      GlobalBus.on("event", onEvent)
-    }),
-)
-
-const serveDisposeProbe = () =>
-  HttpRouter.serve(
-    HttpRouter.add(
-      "POST",
-      "/dispose-probe",
-      Effect.gen(function* () {
-        const instance = yield* InstanceRef
-        if (!instance) return HttpServerResponse.empty({ status: 500 })
-        yield* markInstanceForDisposal(instance)
-        return yield* HttpServerResponse.json(true)
-      }),
-    ).pipe(Layer.provide(instanceContextTestLayer)),
-    { middleware: disposeMiddleware, disableListenLog: true, disableLogger: true },
-  ).pipe(Layer.build)
-
-describe("HttpApi instance context middleware", () => {
-  it.live("provides instance context from the routed directory", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      const project = yield* Project.use.fromDirectory(dir)
-      yield* serveProbe()
-
-      const response = yield* HttpClient.get(`/probe?directory=${encodeURIComponent(dir)}`)
-
-      expect(response.status).toBe(200)
-      expect(yield* response.json).toEqual({
-        directory: dir,
-        worktree: dir,
-        projectID: project.project.id,
-      })
-    }),
-  )
-
-  it.live("falls back to the raw directory when URI decoding fails", () =>
-    Effect.gen(function* () {
-      yield* serveProbe()
-
-      const response = yield* HttpClient.get("/probe?directory=%25E0%25A4%25A")
-
-      expect(response.status).toBe(200)
-      expect(yield* response.json).toMatchObject({
-        directory: path.join(process.cwd(), "%E0%A4%A"),
-      })
-    }),
-  )
-
-  it.live("provides selected workspace id on control-plane routes", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      const project = yield* Project.use.fromDirectory(dir)
-      const workspaceDir = path.join(dir, ".workspace-local")
-      const workspace = yield* createLocalWorkspace({
-        projectID: project.project.id,
-        type: "instance-context-workspace-ref",
-        directory: workspaceDir,
-      })
-      yield* serveProbe("/session")
-
-      const response = yield* HttpClientRequest.get(`/session?workspace=${workspace.id}`).pipe(
-        HttpClientRequest.setHeader("x-saeeol-directory", dir),
-        HttpClient.execute,
-      )
-
-      expect(response.status).toBe(200)
-      expect(yield* response.json).toMatchObject({
-        directory: dir,
-        workspaceID: workspace.id,
-      })
-    }),
-  )
-
-  it.live("uses workspace routing output instead of raw directory hints", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      const project = yield* Project.use.fromDirectory(dir)
-      const workspaceDir = path.join(dir, ".workspace-local")
-      const workspace = yield* createLocalWorkspace({
-        projectID: project.project.id,
-        type: "instance-context-routing-output",
-        directory: workspaceDir,
-      })
-      yield* serveProbe()
-
-      const response = yield* HttpClientRequest.get(`/probe?workspace=${workspace.id}`).pipe(
-        HttpClientRequest.setHeader("x-saeeol-directory", dir),
-        HttpClient.execute,
-      )
-
-      expect(response.status).toBe(200)
-      expect(yield* response.json).toMatchObject({
-        directory: workspaceDir,
-        workspaceID: workspace.id,
-      })
-    }),
-  )
-
-  it.live("preserves selected workspace id on instance disposal events", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-      const project = yield* Project.use.fromDirectory(dir)
-      const workspaceDir = path.join(dir, ".workspace-local")
-      const workspace = yield* createLocalWorkspace({
-        projectID: project.project.id,
-        type: "instance-context-dispose-event",
-        directory: workspaceDir,
-      })
-      yield* serveDisposeProbe()
-      const disposed = yield* waitDisposedEvent.pipe(Effect.forkScoped)
-
-      const response = yield* HttpClientRequest.post(`/dispose-probe?workspace=${workspace.id}`).pipe(
-        HttpClient.execute,
-      )
-
-      expect(response.status).toBe(200)
-      expect(yield* response.json).toBe(true)
-      expect(yield* Fiber.join(disposed)).toEqual({ directory: workspaceDir, workspace: workspace.id })
-    }),
-  )
-})

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

@@ -1,140 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Flag } from "@saeeol/core/flag/flag"
-import { GlobalBus } from "@/bus/global"
-import { Instance } from "../../src/project/instance"
-import { Server } from "../../src/server/server"
-import { InstancePaths } from "../../src/server/routes/instance/httpapi/groups/instance"
-import * as Log from "@saeeol/core/util/log"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-
-void Log.init({ print: false })
-
-const original = Flag.SAEEOL_EXPERIMENTAL_HTTPAPI
-
-function app() {
-  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = true
-  return Server.Default().app
-}
-
-async function waitDisposed(directory: string) {
-  return await new Promise<void>((resolve, reject) => {
-    const timer = setTimeout(() => {
-      GlobalBus.off("event", onEvent)
-      reject(new Error("timed out waiting for instance disposal"))
-    }, 10_000)
-
-    function onEvent(event: { directory?: string; payload: { type?: string } }) {
-      if (event.payload.type !== "server.instance.disposed" || event.directory !== directory) return
-      clearTimeout(timer)
-      GlobalBus.off("event", onEvent)
-      resolve()
-    }
-
-    GlobalBus.on("event", onEvent)
-  })
-}
-
-afterEach(async () => {
-  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = original
-  await disposeAllInstances()
-  await resetDatabase()
-})
-
-describe("instance HttpApi", () => {
-  // The /agent handler 500s via the bridge (agent.list's InstanceState lookup drops context mid-request).
-  // Bridge is gated behind SAEEOL_EXPERIMENTAL_HTTPAPI, not enabled in any production client.
-  test.skip("serves catalog read endpoints through Hono bridge", async () => {
-    await using tmp = await tmpdir({ config: { formatter: false, lsp: false } })
-
-    const [commands, agents, skills, lsp, formatter] = await Promise.all([
-      app().request(InstancePaths.command, { headers: { "x-saeeol-directory": tmp.path } }),
-      app().request(InstancePaths.agent, { headers: { "x-saeeol-directory": tmp.path } }),
-      app().request(InstancePaths.skill, { headers: { "x-saeeol-directory": tmp.path } }),
-      app().request(InstancePaths.lsp, { headers: { "x-saeeol-directory": tmp.path } }),
-      app().request(InstancePaths.formatter, { headers: { "x-saeeol-directory": tmp.path } }),
-    ])
-
-    expect(commands.status).toBe(200)
-    expect(await commands.json()).toContainEqual(expect.objectContaining({ name: "init", source: "command" }))
-
-    expect(agents.status).toBe(200)
-    expect(await agents.json()).toContainEqual(expect.objectContaining({ name: "build", mode: "primary" }))
-
-    expect(skills.status).toBe(200)
-    expect(await skills.json()).toBeArray()
-
-    expect(lsp.status).toBe(200)
-    expect(await lsp.json()).toEqual([])
-
-    expect(formatter.status).toBe(200)
-    expect(await formatter.json()).toEqual([])
-  })
-
-  test("serves project git init through Hono bridge", async () => {
-    await using tmp = await tmpdir({ config: { formatter: false, lsp: false } })
-    const disposed = waitDisposed(tmp.path)
-
-    const response = await app().request("/project/git/init", {
-      method: "POST",
-      headers: { "x-saeeol-directory": tmp.path },
-    })
-
-    expect(response.status).toBe(200)
-    expect(await response.json()).toMatchObject({ vcs: "git", worktree: tmp.path })
-    await disposed
-
-    const current = await app().request("/project/current", { headers: { "x-saeeol-directory": tmp.path } })
-    expect(current.status).toBe(200)
-    expect(await current.json()).toMatchObject({ vcs: "git", worktree: tmp.path })
-  })
-
-  test("serves project update through Hono bridge", async () => {
-    await using tmp = await tmpdir({ config: { formatter: false, lsp: false } })
-
-    const current = await app().request("/project/current", { headers: { "x-saeeol-directory": tmp.path } })
-    expect(current.status).toBe(200)
-    const project = (await current.json()) as { id: string }
-
-    const response = await app().request(`/project/${project.id}`, {
-      method: "PATCH",
-      headers: { "x-saeeol-directory": tmp.path, "content-type": "application/json" },
-      body: JSON.stringify({ name: "patched-project", commands: { start: "bun dev" } }),
-    })
-
-    expect(response.status).toBe(200)
-    expect(await response.json()).toMatchObject({
-      id: project.id,
-      name: "patched-project",
-      commands: { start: "bun dev" },
-    })
-
-    const list = await app().request("/project", { headers: { "x-saeeol-directory": tmp.path } })
-    expect(list.status).toBe(200)
-    expect(await list.json()).toContainEqual(
-      expect.objectContaining({ id: project.id, name: "patched-project", commands: { start: "bun dev" } }),
-    )
-  })
-
-  test("serves instance dispose through Hono bridge", async () => {
-    await using tmp = await tmpdir()
-
-    const disposed = new Promise<string | undefined>((resolve) => {
-      const onEvent = (event: { directory?: string; payload: { type?: string } }) => {
-        if (event.payload.type !== "server.instance.disposed") return
-        GlobalBus.off("event", onEvent)
-        resolve(event.directory)
-      }
-      GlobalBus.on("event", onEvent)
-    })
-
-    const response = await app().request(InstancePaths.dispose, {
-      method: "POST",
-      headers: { "x-saeeol-directory": tmp.path },
-    })
-
-    expect(response.status).toBe(200)
-    expect(await response.json()).toBe(true)
-    expect(await disposed).toBe(tmp.path)
-  })
-})