import { WorkspaceID } from "@/control-plane/schema" import type { Target } from "@/control-plane/types" import { Workspace } from "@/control-plane/workspace" import { WorkspaceAdapterRuntime } from "@/control-plane/workspace-adapter-runtime" import { Session } from "@/session/session" import { HttpApiProxy } from "./proxy" import * as Fence from "@/server/shared/fence" import { getWorkspaceRouteSessionID, isLocalWorkspaceRoute, workspaceProxyURL } from "@/server/shared/workspace-routing" import { NotFoundError } from "@/storage/storage" import { Flag } from "@opencode-ai/core/flag/flag" import { Context, Data, Effect, Layer, Option, Schema } from "effect" import { HttpClient, HttpServerRequest, HttpServerResponse } from "effect/unstable/http" import { HttpApiMiddleware } from "effect/unstable/httpapi" import * as Socket from "effect/unstable/socket/Socket" import { InvalidRequestError } from "../errors" // Query fields this middleware reads from the URL. Spread into every // endpoint query schema in groups that apply WorkspaceRoutingMiddleware, // otherwise HttpApi rejects requests carrying these params with 400. // HttpApiMiddleware in effect-smol cannot declare query params today — // remove this once upstream supports middleware-declared query schemas. export const WorkspaceRoutingQueryFields = { directory: Schema.optional(Schema.String), workspace: Schema.optional(Schema.String), } export const WorkspaceRoutingQuery = Schema.Struct(WorkspaceRoutingQueryFields) type RemoteTarget = Extract type RequestPlan = Data.TaggedEnum<{ InvalidWorkspace: {} MissingWorkspace: { readonly workspaceID: WorkspaceID } Local: { readonly directory: string; readonly workspaceID?: WorkspaceID } Remote: { readonly request: HttpServerRequest.HttpServerRequest readonly workspace: Workspace.Info readonly target: RemoteTarget readonly url: URL } }> const RequestPlan = Data.taggedEnum() const InvalidWorkspaceID = Symbol("InvalidWorkspaceID") export class WorkspaceRouteContext extends Context.Service< WorkspaceRouteContext, { readonly directory: string readonly workspaceID?: WorkspaceID } >()("@opencode/ExperimentalHttpApiWorkspaceRouteContext") {} export class WorkspaceRoutingMiddleware extends HttpApiMiddleware.Service< WorkspaceRoutingMiddleware, { provides: WorkspaceRouteContext requires: Session.Service } >()("@opencode/ExperimentalHttpApiWorkspaceRouting") {} function requestURL(request: HttpServerRequest.HttpServerRequest): URL { return new URL(request.url, "http://localhost") } function configuredWorkspaceID(): WorkspaceID | undefined { return Flag.OPENCODE_WORKSPACE_ID ? WorkspaceID.make(Flag.OPENCODE_WORKSPACE_ID) : undefined } function selectedWorkspaceID(url: URL, sessionWorkspaceID?: WorkspaceID): WorkspaceID | undefined { const workspaceParam = url.searchParams.get("workspace") return sessionWorkspaceID ?? (workspaceParam ? WorkspaceID.make(workspaceParam) : undefined) } function selectedV2WorkspaceID( url: URL, sessionWorkspaceID?: WorkspaceID, ): WorkspaceID | typeof InvalidWorkspaceID | undefined { if (sessionWorkspaceID) return sessionWorkspaceID const workspaceParam = url.searchParams.get("workspace") if (!workspaceParam) return undefined const workspaceID = Schema.decodeUnknownOption(WorkspaceID)(workspaceParam) if (Option.isNone(workspaceID)) return InvalidWorkspaceID return workspaceID.value } function defaultDirectory(request: HttpServerRequest.HttpServerRequest, url: URL): string { return url.searchParams.get("directory") || request.headers["x-opencode-directory"] || process.cwd() } function shouldStayOnControlPlane(request: HttpServerRequest.HttpServerRequest, url: URL): boolean { return isLocalWorkspaceRoute(request.method, url.pathname) || url.pathname.startsWith("/console") } function resolveWorkspace( id: WorkspaceID | undefined, envWorkspaceID: WorkspaceID | undefined, ): Effect.Effect { if (!id || envWorkspaceID) return Effect.void return Workspace.Service.use((workspace) => workspace.get(id)) } function missingWorkspaceResponse(id: WorkspaceID): HttpServerResponse.HttpServerResponse { return HttpServerResponse.text(`Workspace not found: ${id}`, { status: 500, contentType: "text/plain; charset=utf-8", }) } function resolveTarget(workspace: Workspace.Info): Effect.Effect { return WorkspaceAdapterRuntime.target(workspace) } function proxyRemote( client: HttpClient.HttpClient, request: HttpServerRequest.HttpServerRequest, workspace: Workspace.Info, target: RemoteTarget, url: URL, ): Effect.Effect { return Effect.gen(function* () { const syncing = yield* Workspace.Service.use((svc) => svc.isSyncing(workspace.id)) if (!syncing) { return HttpServerResponse.text(`broken sync connection for workspace: ${workspace.id}`, { status: 503, contentType: "text/plain; charset=utf-8", }) } const proxyURL = workspaceProxyURL(target.url, url) const headers = request.headers as Record if (headers["upgrade"]?.toLowerCase() === "websocket") return yield* HttpApiProxy.websocket(request, proxyURL) const response = yield* HttpApiProxy.http(client, proxyURL, target.headers, request) const sync = Fence.parse(new Headers(response.headers)) if (sync) { const syncFailure = yield* Fence.wait( workspace.id, sync, request.source instanceof Request ? request.source.signal : undefined, ).pipe( Effect.as(undefined), Effect.catch((error) => Effect.succeed(HttpServerResponse.text(error.message, { status: 503 }))), ) if (syncFailure) return syncFailure } return response }) } function planWorkspaceRequest( request: HttpServerRequest.HttpServerRequest, url: URL, workspace: Workspace.Info, ): Effect.Effect { return Effect.gen(function* () { const target = yield* resolveTarget(workspace) if (target.type === "remote") return RequestPlan.Remote({ request, workspace, target, url }) return RequestPlan.Local({ directory: target.directory, workspaceID: workspace.id }) }) } function planRequest( request: HttpServerRequest.HttpServerRequest, session?: Session.Info, ): Effect.Effect { return Effect.gen(function* () { const url = requestURL(request) const envWorkspaceID = configuredWorkspaceID() const workspaceID = url.pathname.startsWith("/api/") ? selectedV2WorkspaceID(url, session?.workspaceID) : selectedWorkspaceID(url, session?.workspaceID) if (workspaceID === InvalidWorkspaceID) return RequestPlan.InvalidWorkspace() const workspace = yield* resolveWorkspace(workspaceID, envWorkspaceID) if (workspaceID && workspace === undefined && !envWorkspaceID) { return RequestPlan.MissingWorkspace({ workspaceID }) } if (workspace !== undefined && !envWorkspaceID && !shouldStayOnControlPlane(request, url)) { return yield* planWorkspaceRequest(request, url, workspace) } return RequestPlan.Local({ directory: session?.directory || defaultDirectory(request, url), workspaceID: envWorkspaceID ?? workspaceID, }) }) } function routeWorkspace( client: HttpClient.HttpClient, effect: Effect.Effect, plan: RequestPlan, ): Effect.Effect { return RequestPlan.$match(plan, { InvalidWorkspace: () => Effect.succeed( HttpServerResponse.jsonUnsafe( new InvalidRequestError({ message: "Invalid workspace query parameter", kind: "Query", field: "workspace", }), { status: 400 }, ), ), MissingWorkspace: ({ workspaceID }) => Effect.succeed(missingWorkspaceResponse(workspaceID)), Remote: ({ request, workspace, target, url }) => proxyRemote(client, request, workspace, target, url), Local: ({ directory, workspaceID }) => effect.pipe(Effect.provideService(WorkspaceRouteContext, WorkspaceRouteContext.of({ directory, workspaceID }))), }) } function routeHttpApiWorkspace( client: HttpClient.HttpClient, effect: Effect.Effect, ): Effect.Effect< HttpServerResponse.HttpServerResponse, E, Session.Service | Workspace.Service | HttpServerRequest.HttpServerRequest | Socket.WebSocketConstructor > { return Effect.gen(function* () { const request = yield* HttpServerRequest.HttpServerRequest const sessionID = getWorkspaceRouteSessionID(requestURL(request)) const session = sessionID ? yield* Session.Service.use((svc) => svc.get(sessionID)).pipe( Effect.catchIf( (error): error is NotFoundError => NotFoundError.isInstance(error), () => Effect.succeed(undefined), ), Effect.catchDefect(() => Effect.succeed(undefined)), ) : undefined const plan = yield* planRequest(request, session) return yield* routeWorkspace(client, effect, plan) }) } export const workspaceRoutingLayer = Layer.effect( WorkspaceRoutingMiddleware, Effect.gen(function* () { const makeWebSocket = yield* Socket.WebSocketConstructor const workspace = yield* Workspace.Service const client = yield* HttpClient.HttpClient return WorkspaceRoutingMiddleware.of((effect) => routeHttpApiWorkspace(client, effect).pipe( Effect.provideService(Socket.WebSocketConstructor, makeWebSocket), Effect.provideService(Workspace.Service, workspace), ), ) }), )