refactor(server): canonicalize service API (#31049)

packages/server/src/middleware/authorization.ts

@@ -7,8 +7,8 @@ import { HttpApiMiddleware } from "effect/unstable/httpapi"
 const AUTH_TOKEN_QUERY = "auth_token"
 const WWW_AUTHENTICATE = 'Basic realm="Secure Area"'
 
-export class V2Authorization extends HttpApiMiddleware.Service<V2Authorization>()(
-  "@opencode/ExperimentalHttpApiV2Authorization",
+export class Authorization extends HttpApiMiddleware.Service<Authorization>()(
+  "@opencode/HttpApiAuthorization",
   {
     error: UnauthorizedError,
   },
@@ -40,12 +40,12 @@ function credentialFromRequest(request: HttpServerRequest.HttpServerRequest) {
   return Effect.succeed(emptyCredential())
 }
 
-export const v2AuthorizationLayer = Layer.effect(
-  V2Authorization,
+export const authorizationLayer = Layer.effect(
+  Authorization,
   Effect.gen(function* () {
     const config = yield* ServerAuth.Config
-    if (!ServerAuth.required(config)) return V2Authorization.of((effect) => effect)
-    return V2Authorization.of((effect) =>
+    if (!ServerAuth.required(config)) return Authorization.of((effect) => effect)
+    return Authorization.of((effect) =>
       Effect.gen(function* () {
         const request = yield* HttpServerRequest.HttpServerRequest
         const credential = yield* credentialFromRequest(request)

packages/server/src/middleware/session-location.ts

@@ -0,0 +1,66 @@
+import { Database } from "@opencode-ai/core/database/database"
+import { LocationServiceMap } from "@opencode-ai/core/location-layer"
+import { AbsolutePath } from "@opencode-ai/core/schema"
+import { SessionV2 } from "@opencode-ai/core/session"
+import { SessionTable } from "@opencode-ai/core/session/sql"
+import { WorkspaceV2 } from "@opencode-ai/core/workspace"
+import { eq } from "drizzle-orm"
+import { Effect, Layer, Schema } from "effect"
+import { HttpRouter } from "effect/unstable/http"
+import { HttpApiMiddleware } from "effect/unstable/httpapi"
+import { InvalidRequestError, SessionNotFoundError } from "../errors"
+import type { LocationServices } from "../groups/location"
+
+export class SessionLocationMiddleware extends HttpApiMiddleware.Service<
+  SessionLocationMiddleware,
+  {
+    provides: LocationServices
+  }
+>()("@opencode/HttpApiSessionLocation", {
+  error: [InvalidRequestError, SessionNotFoundError],
+}) {}
+
+const decodeSessionID = Schema.decodeUnknownEffect(SessionV2.ID)
+
+export const sessionLocationLayer = Layer.effect(
+  SessionLocationMiddleware,
+  Effect.gen(function* () {
+    const { db } = yield* Database.Service
+    const locations = yield* LocationServiceMap
+
+    return SessionLocationMiddleware.of((effect) =>
+      Effect.gen(function* () {
+        const route = yield* HttpRouter.RouteContext
+        const sessionID = yield* decodeSessionID(route.params.sessionID).pipe(
+          Effect.mapError(
+            () =>
+              new InvalidRequestError({
+                message: "Invalid session ID",
+                field: "sessionID",
+              }),
+          ),
+        )
+        const row = yield* db
+          .select({ directory: SessionTable.directory, workspaceID: SessionTable.workspace_id })
+          .from(SessionTable)
+          .where(eq(SessionTable.id, sessionID))
+          .get()
+          .pipe(Effect.orDie)
+        if (!row)
+          return yield* new SessionNotFoundError({
+            sessionID,
+            message: `Session not found: ${sessionID}`,
+          })
+
+        return yield* effect.pipe(
+          Effect.provide(
+            locations.get({
+              directory: AbsolutePath.make(row.directory),
+              workspaceID: row.workspaceID ? WorkspaceV2.ID.make(row.workspaceID) : undefined,
+            }),
+          ),
+        )
+      }),
+    )
+  }),
+)