fix(httpapi): align default backend parity

kitlangton · kitlangton · commit 9616f48e70b6 · 2026-04-28T17:33:52.000-04:00
diff --git a/packages/opencode/src/server/backend.ts b/packages/opencode/src/server/backend.ts
@@ -1,10 +1,10 @@
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { InstallationChannel, InstallationVersion } from "@opencode-ai/core/installation/version"
 
-export type Runtime = "effect-httpapi" | "hono"
+export type Backend = "effect-httpapi" | "hono"
 
 export type Selection = {
-  runtime: Runtime
+  backend: Backend
   reason: "env" | "channel" | "stable" | "explicit"
 }
 
@@ -18,23 +18,23 @@ const channelDefaultsToHttpApi = () =>
   InstallationVersion.includes("-beta")
 
 export function select(): Selection {
-  if (Flag.OPENCODE_EXPERIMENTAL_HTTPAPI) return { runtime: "effect-httpapi", reason: "env" }
-  if (channelDefaultsToHttpApi()) return { runtime: "effect-httpapi", reason: "channel" }
-  return { runtime: "hono", reason: "stable" }
+  if (Flag.OPENCODE_EXPERIMENTAL_HTTPAPI) return { backend: "effect-httpapi", reason: "env" }
+  if (channelDefaultsToHttpApi()) return { backend: "effect-httpapi", reason: "channel" }
+  return { backend: "hono", reason: "stable" }
 }
 
 export function attributes(selection: Selection): Record<string, string> {
   return {
-    "opencode.server.runtime": selection.runtime,
-    "opencode.server.runtime.reason": selection.reason,
+    "opencode.server.backend": selection.backend,
+    "opencode.server.backend.reason": selection.reason,
     "opencode.installation.channel": InstallationChannel,
     "opencode.installation.version": InstallationVersion,
   }
 }
 
-export function force(selection: Selection, runtime: Runtime): Selection {
+export function force(selection: Selection, backend: Backend): Selection {
   return {
-    runtime,
-    reason: selection.runtime === runtime ? selection.reason : "explicit",
+    backend,
+    reason: selection.backend === backend ? selection.reason : "explicit",
   }
 }
diff --git a/packages/opencode/src/server/middleware.ts b/packages/opencode/src/server/middleware.ts
@@ -10,7 +10,7 @@ import { Flag } from "@opencode-ai/core/flag/flag"
 import { basicAuth } from "hono/basic-auth"
 import { cors } from "hono/cors"
 import { compress } from "hono/compress"
-import * as ServerRuntime from "./runtime"
+import * as ServerBackend from "./backend"
 
 const log = Log.create({ service: "server" })
 
@@ -50,14 +50,14 @@ export const AuthMiddleware: MiddlewareHandler = (c, next) => {
   return basicAuth({ username, password })(c, next)
 }
 
-export function LoggerMiddleware(runtimeAttributes: ServerRuntime.Attributes): MiddlewareHandler {
+export function LoggerMiddleware(backendAttributes: ServerBackend.Attributes): MiddlewareHandler {
   return async (c, next) => {
     const skip = c.req.path === "/log"
     if (skip) return next()
     const attributes = {
       method: c.req.method,
       path: c.req.path,
-      ...runtimeAttributes,
+      ...backendAttributes,
     }
     log.info("request", attributes)
     const timer = log.time("request", attributes)
diff --git a/packages/opencode/src/server/routes/instance/httpapi/lifecycle.ts b/packages/opencode/src/server/routes/instance/httpapi/lifecycle.ts
@@ -3,7 +3,6 @@ import { Effect } from "effect"
 import { HttpEffect, HttpMiddleware, HttpServerRequest } from "effect/unstable/http"
 
 const disposeAfterResponse = new WeakMap<object, InstanceContext>()
-const reloadAfterResponse = new WeakMap<object, InstanceContext & { next: Parameters<typeof Instance.reload>[0] }>()
 
 export const markInstanceForDisposal = (ctx: InstanceContext) =>
   HttpEffect.appendPreResponseHandler((request, response) =>
@@ -14,27 +13,17 @@ export const markInstanceForDisposal = (ctx: InstanceContext) =>
   )
 
 export const markInstanceForReload = (ctx: InstanceContext, next: Parameters<typeof Instance.reload>[0]) =>
-  HttpEffect.appendPreResponseHandler((request, response) =>
-    Effect.sync(() => {
-      reloadAfterResponse.set(request.source, { ...ctx, next })
-      return response
-    }),
+  HttpEffect.appendPreResponseHandler((_request, response) =>
+    Effect.as(Effect.uninterruptible(Effect.promise(() => Instance.restore(ctx, () => Instance.reload(next)))), response),
   )
 
 export const disposeMiddleware: HttpMiddleware.HttpMiddleware = (effect) =>
   Effect.gen(function* () {
     const response = yield* effect
     const request = yield* HttpServerRequest.HttpServerRequest
-    const reload = reloadAfterResponse.get(request.source)
-    if (reload) {
-      reloadAfterResponse.delete(request.source)
-      yield* Effect.promise(() => Instance.restore(reload, () => Instance.reload(reload.next)))
-      return response
-    }
-
     const ctx = disposeAfterResponse.get(request.source)
     if (!ctx) return response
     disposeAfterResponse.delete(request.source)
-    yield* Effect.promise(() => Instance.restore(ctx, () => Instance.dispose()))
+    yield* Effect.uninterruptible(Effect.promise(() => Instance.restore(ctx, () => Instance.dispose())))
     return response
   })
diff --git a/packages/opencode/src/server/routes/instance/httpapi/server.ts b/packages/opencode/src/server/routes/instance/httpapi/server.ts
@@ -55,7 +55,7 @@ import { TuiApi, tuiHandlers } from "./tui"
 import { WorkspaceApi, workspaceHandlers } from "./workspace"
 import { disposeMiddleware } from "./lifecycle"
 import { memoMap } from "@opencode-ai/core/effect/memo-map"
-import * as ServerRuntime from "@/server/runtime"
+import * as ServerBackend from "@/server/backend"
 
 const Query = Schema.Struct({
   directory: Schema.optional(Schema.String),
@@ -78,13 +78,21 @@ function decode(input: string) {
   }
 }
 
+function currentDirectory() {
+  try {
+    return Instance.directory
+  } catch {
+    return process.cwd()
+  }
+}
+
 const instance = HttpRouter.middleware()(
   Effect.gen(function* () {
     return (effect) =>
       Effect.gen(function* () {
         const query = yield* HttpServerRequest.schemaSearchParams(Query)
         const headers = yield* HttpServerRequest.schemaHeaders(Headers)
-        const raw = query.directory || headers["x-opencode-directory"] || process.cwd()
+        const raw = query.directory || headers["x-opencode-directory"] || currentDirectory()
         const workspace = query.workspace || undefined
         const ctx = yield* Effect.promise(() =>
           Instance.provide({
@@ -103,9 +111,9 @@ const instance = HttpRouter.middleware()(
 const runtime = HttpRouter.middleware()(
   Effect.succeed((effect) =>
     Effect.gen(function* () {
-      const selected = ServerRuntime.select()
+      const selected = ServerBackend.select()
       yield* Effect.annotateCurrentSpan(
-        ServerRuntime.attributes(ServerRuntime.force(selected, "effect-httpapi")),
+        ServerBackend.attributes(ServerBackend.force(selected, "effect-httpapi")),
       )
       return yield* effect
     }),
diff --git a/packages/opencode/src/server/routes/instance/httpapi/session.ts b/packages/opencode/src/server/routes/instance/httpapi/session.ts
@@ -19,6 +19,7 @@ import { SessionSummary } from "@/session/summary"
 import { Todo } from "@/session/todo"
 import { MessageID, PartID, SessionID } from "@/session/schema"
 import { Snapshot } from "@/snapshot"
+import { NotFoundError } from "@/storage/storage"
 import * as Log from "@opencode-ai/core/util/log"
 import { NamedError } from "@opencode-ai/core/util/error"
 import { Effect, Schema, SchemaGetter, Struct } from "effect"
@@ -191,7 +192,7 @@ export const SessionApi = HttpApi.make("session")
           params: { sessionID: SessionID },
           query: MessagesQuery,
           success: Schema.Array(MessageV2.WithParts),
-          error: HttpApiError.BadRequest,
+          error: [HttpApiError.BadRequest, HttpApiError.NotFound],
         }).annotateMerge(
           OpenApi.annotations({
             identifier: "session.messages",
@@ -480,37 +481,47 @@ export const sessionHandlers = HttpApiBuilder.group(SessionApi, "session", (hand
       params: { sessionID: SessionID }
       query: typeof MessagesQuery.Type
     }) {
-      if (ctx.query.before && ctx.query.limit === undefined) return yield* new HttpApiError.BadRequest({})
-      if (ctx.query.before) {
-        const before = ctx.query.before
-        yield* Effect.try({
-          try: () => MessageV2.cursor.decode(before),
-          catch: () => new HttpApiError.BadRequest({}),
-        })
-      }
-      if (ctx.query.limit === undefined || ctx.query.limit === 0) {
-        yield* session.get(ctx.params.sessionID)
-        return yield* session.messages({ sessionID: ctx.params.sessionID })
-      }
+      return yield* Effect.gen(function* () {
+        if (ctx.query.before && ctx.query.limit === undefined) return yield* new HttpApiError.BadRequest({})
+        if (ctx.query.before) {
+          const before = ctx.query.before
+          yield* Effect.try({
+            try: () => MessageV2.cursor.decode(before),
+            catch: () => new HttpApiError.BadRequest({}),
+          })
+        }
+        if (ctx.query.limit === undefined || ctx.query.limit === 0) {
+          yield* session.get(ctx.params.sessionID)
+          return yield* session.messages({ sessionID: ctx.params.sessionID })
+        }
 
-      const page = MessageV2.page({
-        sessionID: ctx.params.sessionID,
-        limit: ctx.query.limit,
-        before: ctx.query.before,
-      })
-      if (!page.cursor) return page.items
-
-      const request = yield* HttpServerRequest.HttpServerRequest
-      const url = new URL(request.url, "http://localhost")
-      url.searchParams.set("limit", ctx.query.limit.toString())
-      url.searchParams.set("before", page.cursor)
-      return HttpServerResponse.jsonUnsafe(page.items, {
-        headers: {
-          "Access-Control-Expose-Headers": "Link, X-Next-Cursor",
-          Link: `<${url.toString()}>; rel="next"`,
-          "X-Next-Cursor": page.cursor,
-        },
-      })
+        yield* session.get(ctx.params.sessionID)
+        const page = MessageV2.page({
+          sessionID: ctx.params.sessionID,
+          limit: ctx.query.limit,
+          before: ctx.query.before,
+        })
+        if (!page.cursor) return page.items
+
+        const request = yield* HttpServerRequest.HttpServerRequest
+        const url = new URL(request.url, "http://localhost")
+        url.searchParams.set("limit", ctx.query.limit.toString())
+        url.searchParams.set("before", page.cursor)
+        return HttpServerResponse.jsonUnsafe(page.items, {
+          headers: {
+            "Access-Control-Expose-Headers": "Link, X-Next-Cursor",
+            Link: `<${url.toString()}>; rel="next"`,
+            "X-Next-Cursor": page.cursor,
+          },
+        })
+      }).pipe(
+        Effect.catchIf(NotFoundError.isInstance, () => Effect.fail(new HttpApiError.NotFound({}))),
+        Effect.catchDefect((error) =>
+          NotFoundError.isInstance(error)
+            ? Effect.fail(new HttpApiError.NotFound({}))
+            : Effect.die(error),
+        ),
+      )
     })
 
     const message = Effect.fn("SessionHttpApi.message")(function* (ctx: {
diff --git a/packages/opencode/src/server/routes/instance/httpapi/tui.ts b/packages/opencode/src/server/routes/instance/httpapi/tui.ts
@@ -254,6 +254,7 @@ export const tuiHandlers = HttpApiBuilder.group(TuiApi, "tui", (handlers) =>
     const selectSession = Effect.fn("TuiHttpApi.selectSession")(function* (ctx: {
       payload: typeof TuiEvent.SessionSelect.properties.Type
     }) {
+      if (!ctx.payload.sessionID.startsWith("ses")) return yield* new HttpApiError.BadRequest({})
       const row = yield* Effect.sync(() =>
         Database.use((db) =>
           db.select({ id: SessionTable.id }).from(SessionTable).where(eq(SessionTable.id, ctx.payload.sessionID)).get(),
diff --git a/packages/opencode/src/server/server.ts b/packages/opencode/src/server/server.ts
@@ -17,7 +17,7 @@ import { WorkspaceRouterMiddleware } from "./workspace"
 import { InstanceMiddleware } from "./routes/instance/middleware"
 import { WorkspaceRoutes } from "./routes/control/workspace"
 import { ExperimentalHttpApiServer } from "./routes/instance/httpapi/server"
-import * as ServerRuntime from "./runtime"
+import * as ServerBackend from "./backend"
 
 // @ts-ignore This global is needed to prevent ai-sdk from logging warnings to stdout https://github.com/vercel/ai/blob/2dc67e0ef538307f21368db32d5a12345d98831b/packages/ai/src/logger/log-warnings.ts#L85
 globalThis.AI_SDK_LOG_WARNINGS = false
@@ -38,37 +38,37 @@ type ServerApp = {
   request(input: string | URL | Request, init?: RequestInit): Response | Promise<Response>
 }
 
-const DefaultHono = lazy(() => withRuntime({ runtime: "hono", reason: "stable" }, createHono({}, { runtime: "hono", reason: "stable" })))
+const DefaultHono = lazy(() => withBackend({ backend: "hono", reason: "stable" }, createHono({}, { backend: "hono", reason: "stable" })))
 const DefaultHttpApi = lazy(() => createDefaultHttpApi())
 
 function select() {
-  return ServerRuntime.select()
+  return ServerBackend.select()
 }
 
-export const runtime = select
+export const backend = select
 
 export const Default = () => {
   const selected = select()
-  return selected.runtime === "effect-httpapi" ? DefaultHttpApi() : DefaultHono()
+  return selected.backend === "effect-httpapi" ? DefaultHttpApi() : DefaultHono()
 }
 
 function create(opts: { cors?: string[] }) {
   const selected = select()
-  return selected.runtime === "effect-httpapi"
-    ? withRuntime(selected, createHttpApi())
-    : withRuntime(selected, createHono(opts, selected))
+  return selected.backend === "effect-httpapi"
+    ? withBackend(selected, createHttpApi())
+    : withBackend(selected, createHono(opts, selected))
 }
 
 export function Legacy(opts: { cors?: string[] } = {}) {
-  return withRuntime({ runtime: "hono", reason: "explicit" }, createHono(opts, { runtime: "hono", reason: "explicit" }))
+  return withBackend({ backend: "hono", reason: "explicit" }, createHono(opts, { backend: "hono", reason: "explicit" }))
 }
 
 function createDefaultHttpApi() {
-  return withRuntime(select(), createHttpApi())
+  return withBackend(select(), createHttpApi())
 }
 
-function withRuntime<T extends { app: ServerApp; runtime: unknown }>(selection: ServerRuntime.Selection, built: T) {
-  log.info("server runtime selected", ServerRuntime.attributes(selection))
+function withBackend<T extends { app: ServerApp; runtime: unknown }>(selection: ServerBackend.Selection, built: T) {
+  log.info("server backend selected", ServerBackend.attributes(selection))
   return built
 }
 
@@ -86,12 +86,12 @@ function createHttpApi() {
   }
 }
 
-function createHono(opts: { cors?: string[] }, selection: ServerRuntime.Selection = ServerRuntime.force(select(), "hono")) {
-  const runtimeAttributes = ServerRuntime.attributes(selection)
+function createHono(opts: { cors?: string[] }, selection: ServerBackend.Selection = ServerBackend.force(select(), "hono")) {
+  const backendAttributes = ServerBackend.attributes(selection)
   const app = new Hono()
     .onError(ErrorMiddleware)
     .use(AuthMiddleware)
-    .use(LoggerMiddleware(runtimeAttributes))
+    .use(LoggerMiddleware(backendAttributes))
     .use(CompressionMiddleware)
     .use(CorsMiddleware(opts))
     .route("/global", GlobalRoutes())
diff --git a/packages/opencode/test/server/httpapi-bridge.test.ts b/packages/opencode/test/server/httpapi-bridge.test.ts
@@ -146,9 +146,9 @@ afterEach(async () => {
 })
 
 describe("HttpApi server", () => {
-  test("defaults local/dev builds to the Effect HttpApi runtime", () => {
+  test("defaults local/dev builds to the Effect HttpApi backend", () => {
     Flag.OPENCODE_EXPERIMENTAL_HTTPAPI = false
-    expect(Server.runtime().runtime).toBe("effect-httpapi")
+    expect(Server.backend().backend).toBe("effect-httpapi")
   })
 
   test("covers every generated OpenAPI route with Effect HttpApi contracts", async () => {
