soraacode 0.2.0 → 0.2.2

package/src/server/routes/instance/httpapi/groups/config.ts

@@ -1,65 +0,0 @@
-import { Config } from "@/config/config"
-import { ConfigV1 } from "@soraacode/core/v1/config/config"
-import { Provider } from "@/provider/provider"
-import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { Authorization } from "../middleware/authorization"
-import { InstanceContextMiddleware } from "../middleware/instance-context"
-import { WorkspaceRoutingMiddleware, WorkspaceRoutingQuery } from "../middleware/workspace-routing"
-import { described } from "./metadata"
-
-const root = "/config"
-
-export const ConfigApi = HttpApi.make("config")
-  .add(
-    HttpApiGroup.make("config")
-      .add(
-        HttpApiEndpoint.get("get", root, {
-          query: WorkspaceRoutingQuery,
-          success: described(ConfigV1.Info, "Get config info"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "config.get",
-            summary: "Get configuration",
-            description: "Retrieve the current OpenCode configuration settings and preferences.",
-          }),
-        ),
-        HttpApiEndpoint.patch("update", root, {
-          query: WorkspaceRoutingQuery,
-          payload: ConfigV1.Info,
-          success: described(ConfigV1.Info, "Successfully updated config"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "config.update",
-            summary: "Update configuration",
-            description: "Update OpenCode configuration settings and preferences.",
-          }),
-        ),
-        HttpApiEndpoint.get("providers", `${root}/providers`, {
-          query: WorkspaceRoutingQuery,
-          success: described(Provider.ConfigProvidersResult, "List of providers"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "config.providers",
-            summary: "List config providers",
-            description: "Get a list of all configured AI providers and their default models.",
-          }),
-        ),
-      )
-      .annotateMerge(
-        OpenApi.annotations({
-          title: "config",
-          description: "Experimental HttpApi config routes.",
-        }),
-      )
-      .middleware(InstanceContextMiddleware)
-      .middleware(WorkspaceRoutingMiddleware)
-      .middleware(Authorization),
-  )
-  .annotateMerge(
-    OpenApi.annotations({
-      title: "opencode experimental HttpApi",
-      version: "0.0.1",
-      description: "Experimental HttpApi surface for selected instance routes.",
-    }),
-  )

package/src/server/routes/instance/httpapi/groups/control-plane.ts

@@ -1,35 +0,0 @@
-import { MoveSession } from "@soraacode/core/control-plane/move-session"
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { described } from "./metadata"
-
-const root = "/experimental/control-plane"
-export const MoveSessionPayload = Schema.Struct({ ...MoveSession.Input.fields })
-
-export class ApiMoveSessionError extends Schema.ErrorClass<ApiMoveSessionError>("MoveSessionError")(
-  {
-    name: Schema.Literal("MoveSessionError"),
-    data: Schema.Struct({
-      message: Schema.String,
-    }),
-  },
-  { httpApiStatus: 400 },
-) {}
-
-export const ControlPlaneApi = HttpApi.make("controlPlane").add(
-  HttpApiGroup.make("controlPlane")
-    .add(
-      HttpApiEndpoint.post("moveSession", `${root}/move-session`, {
-        payload: MoveSessionPayload,
-        success: described(HttpApiSchema.NoContent, "Session moved"),
-        error: ApiMoveSessionError,
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "experimental.controlPlane.moveSession",
-          summary: "Move session",
-          description: "Move a session to another project directory, optionally transferring local changes.",
-        }),
-      ),
-    )
-    .annotateMerge(OpenApi.annotations({ title: "controlPlane", description: "Control-plane orchestration routes." })),
-)

package/src/server/routes/instance/httpapi/groups/control.ts

@@ -1,76 +0,0 @@
-import { Auth } from "@/auth"
-
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { described } from "./metadata"
-import { ProviderV2 } from "@soraacode/core/provider"
-
-const AuthParams = Schema.Struct({
-  providerID: ProviderV2.ID,
-})
-
-const LogQuery = Schema.Struct({
-  directory: Schema.optional(Schema.String),
-  workspace: Schema.optional(Schema.String),
-})
-
-export const LogInput = Schema.Struct({
-  service: Schema.String.annotate({ description: "Service name for the log entry" }),
-  level: Schema.Union([
-    Schema.Literal("debug"),
-    Schema.Literal("info"),
-    Schema.Literal("error"),
-    Schema.Literal("warn"),
-  ]).annotate({ description: "Log level" }),
-  message: Schema.String.annotate({ description: "Log message" }),
-  extra: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)).annotate({
-    description: "Additional metadata for the log entry",
-  }),
-})
-
-export const ControlPaths = {
-  auth: "/auth/:providerID",
-  log: "/log",
-} as const
-
-export const ControlApi = HttpApi.make("control").add(
-  HttpApiGroup.make("control")
-    .add(
-      HttpApiEndpoint.put("authSet", ControlPaths.auth, {
-        params: AuthParams,
-        payload: Auth.Info,
-        success: described(Schema.Boolean, "Successfully set authentication credentials"),
-        error: HttpApiError.BadRequest,
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "auth.set",
-          summary: "Set auth credentials",
-          description: "Set authentication credentials",
-        }),
-      ),
-      HttpApiEndpoint.delete("authRemove", ControlPaths.auth, {
-        params: AuthParams,
-        success: described(Schema.Boolean, "Successfully removed authentication credentials"),
-        error: HttpApiError.BadRequest,
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "auth.remove",
-          summary: "Remove auth credentials",
-          description: "Remove authentication credentials",
-        }),
-      ),
-      HttpApiEndpoint.post("log", ControlPaths.log, {
-        query: LogQuery,
-        payload: LogInput,
-        success: described(Schema.Boolean, "Log entry written successfully"),
-        error: HttpApiError.BadRequest,
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "app.log",
-          summary: "Write log",
-          description: "Write a log entry to the server logs with specified level and metadata.",
-        }),
-      ),
-    )
-    .annotateMerge(OpenApi.annotations({ title: "control", description: "Control plane routes." })),
-)

package/src/server/routes/instance/httpapi/groups/event.ts

@@ -1,29 +0,0 @@
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { Authorization } from "../middleware/authorization"
-import { InstanceContextMiddleware } from "../middleware/instance-context"
-import { WorkspaceRoutingMiddleware, WorkspaceRoutingQuery } from "../middleware/workspace-routing"
-
-export const EventPaths = {
-  event: "/event",
-} as const
-
-export const EventApi = HttpApi.make("event").add(
-  HttpApiGroup.make("event")
-    .add(
-      HttpApiEndpoint.get("subscribe", EventPaths.event, {
-        query: WorkspaceRoutingQuery,
-        success: Schema.String.pipe(HttpApiSchema.asText({ contentType: "text/event-stream" })),
-      }).annotateMerge(
-        OpenApi.annotations({
-          identifier: "event.subscribe",
-          summary: "Subscribe to events",
-          description: "Get events",
-        }),
-      ),
-    )
-    .middleware(InstanceContextMiddleware)
-    .middleware(WorkspaceRoutingMiddleware)
-    .middleware(Authorization)
-    .annotateMerge(OpenApi.annotations({ title: "event", description: "Instance event stream route." })),
-)

package/src/server/routes/instance/httpapi/groups/experimental.ts

@@ -1,275 +0,0 @@
-import { AccountID, OrgID } from "@/account/schema"
-import { MCP } from "@/mcp"
-
-import { Session } from "@/session/session"
-import { SessionID } from "@/session/schema"
-import { Worktree } from "@/worktree"
-import { NonNegativeInt } from "@soraacode/core/schema"
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { Authorization } from "../middleware/authorization"
-import { InstanceContextMiddleware } from "../middleware/instance-context"
-import {
-  WorkspaceRoutingMiddleware,
-  WorkspaceRoutingQuery,
-  WorkspaceRoutingQueryFields,
-} from "../middleware/workspace-routing"
-import { described } from "./metadata"
-import { QueryBoolean } from "./query"
-import { ProviderV2 } from "@soraacode/core/provider"
-import { ModelV2 } from "@soraacode/core/model"
-
-const ConsoleStateResponse = Schema.Struct({
-  consoleManagedProviders: Schema.mutable(Schema.Array(Schema.String)),
-  activeOrgName: Schema.optionalKey(Schema.String),
-  switchableOrgCount: NonNegativeInt,
-}).annotate({ identifier: "ConsoleState" })
-
-const CapabilitiesResponse = Schema.Struct({
-  backgroundSubagents: Schema.Boolean,
-}).annotate({ identifier: "ExperimentalCapabilities" })
-
-const ConsoleOrgOption = Schema.Struct({
-  accountID: Schema.String,
-  accountEmail: Schema.String,
-  accountUrl: Schema.String,
-  orgID: Schema.String,
-  orgName: Schema.String,
-  active: Schema.Boolean,
-})
-
-const ConsoleOrgList = Schema.Struct({
-  orgs: Schema.Array(ConsoleOrgOption),
-})
-
-export const ConsoleSwitchPayload = Schema.Struct({
-  accountID: AccountID,
-  orgID: OrgID,
-})
-
-const ToolIDs = Schema.Array(Schema.String).annotate({ identifier: "ToolIDs" })
-const ToolListItem = Schema.Struct({
-  id: Schema.String,
-  description: Schema.String,
-  parameters: Schema.Unknown,
-}).annotate({ identifier: "ToolListItem" })
-const ToolList = Schema.Array(ToolListItem).annotate({ identifier: "ToolList" })
-export const ToolListQuery = Schema.Struct({
-  ...WorkspaceRoutingQueryFields,
-  provider: ProviderV2.ID,
-  model: ModelV2.ID,
-})
-
-const WorktreeList = Schema.Array(Schema.String)
-const WorktreeErrorName = Schema.Union([
-  Schema.Literal("WorktreeNotGitError"),
-  Schema.Literal("WorktreeNameGenerationFailedError"),
-  Schema.Literal("WorktreeCreateFailedError"),
-  Schema.Literal("WorktreeStartCommandFailedError"),
-  Schema.Literal("WorktreeRemoveFailedError"),
-  Schema.Literal("WorktreeResetFailedError"),
-  Schema.Literal("WorktreeListFailedError"),
-])
-export class WorktreeApiError extends Schema.ErrorClass<WorktreeApiError>("WorktreeError")(
-  {
-    name: WorktreeErrorName,
-    data: Schema.Struct({ message: Schema.String }),
-  },
-  { httpApiStatus: 400 },
-) {}
-export const SessionListQuery = Schema.Struct({
-  ...WorkspaceRoutingQueryFields,
-  roots: Schema.optional(QueryBoolean),
-  start: Schema.optional(Schema.NumberFromString),
-  cursor: Schema.optional(Schema.NumberFromString),
-  search: Schema.optional(Schema.String),
-  limit: Schema.optional(Schema.NumberFromString),
-  archived: Schema.optional(QueryBoolean),
-})
-
-export const ExperimentalPaths = {
-  capabilities: "/experimental/capabilities",
-  console: "/experimental/console",
-  consoleOrgs: "/experimental/console/orgs",
-  consoleSwitch: "/experimental/console/switch",
-  tool: "/experimental/tool",
-  toolIDs: "/experimental/tool/ids",
-  worktree: "/experimental/worktree",
-  worktreeReset: "/experimental/worktree/reset",
-  session: "/experimental/session",
-  sessionBackground: "/experimental/session/:sessionID/background",
-  resource: "/experimental/resource",
-} as const
-
-export const ExperimentalApi = HttpApi.make("experimental")
-  .add(
-    HttpApiGroup.make("experimental")
-      .add(
-        HttpApiEndpoint.get("capabilities", ExperimentalPaths.capabilities, {
-          query: WorkspaceRoutingQuery,
-          success: described(CapabilitiesResponse, "Experimental capabilities"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.capabilities.get",
-            summary: "Get experimental capabilities",
-            description: "Get experimental features enabled on the OpenCode server.",
-          }),
-        ),
-        HttpApiEndpoint.get("console", ExperimentalPaths.console, {
-          query: WorkspaceRoutingQuery,
-          success: described(ConsoleStateResponse, "Active Console provider metadata"),
-          error: HttpApiError.InternalServerError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.console.get",
-            summary: "Get active Console provider metadata",
-            description: "Get the active Console org name and the set of provider IDs managed by that Console org.",
-          }),
-        ),
-        HttpApiEndpoint.get("consoleOrgs", ExperimentalPaths.consoleOrgs, {
-          query: WorkspaceRoutingQuery,
-          success: described(ConsoleOrgList, "Switchable Console orgs"),
-          error: HttpApiError.InternalServerError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.console.listOrgs",
-            summary: "List switchable Console orgs",
-            description: "Get the available Console orgs across logged-in accounts, including the current active org.",
-          }),
-        ),
-        HttpApiEndpoint.post("consoleSwitch", ExperimentalPaths.consoleSwitch, {
-          query: WorkspaceRoutingQuery,
-          payload: ConsoleSwitchPayload,
-          success: described(Schema.Boolean, "Switch success"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.console.switchOrg",
-            summary: "Switch active Console org",
-            description: "Persist a new active Console account/org selection for the current local OpenCode state.",
-          }),
-        ),
-        HttpApiEndpoint.get("tool", ExperimentalPaths.tool, {
-          query: ToolListQuery,
-          success: described(ToolList, "Tools"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tool.list",
-            summary: "List tools",
-            description:
-              "Get a list of available tools with their JSON schema parameters for a specific provider and model combination.",
-          }),
-        ),
-        HttpApiEndpoint.get("toolIDs", ExperimentalPaths.toolIDs, {
-          query: WorkspaceRoutingQuery,
-          success: described(ToolIDs, "Tool IDs"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "tool.ids",
-            summary: "List tool IDs",
-            description:
-              "Get a list of all available tool IDs, including both built-in tools and dynamically registered tools.",
-          }),
-        ),
-        HttpApiEndpoint.get("worktree", ExperimentalPaths.worktree, {
-          query: WorkspaceRoutingQuery,
-          success: described(WorktreeList, "List of worktree directories"),
-          error: WorktreeApiError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "worktree.list",
-            summary: "List worktrees",
-            description: "List all sandbox worktrees for the current project.",
-          }),
-        ),
-        HttpApiEndpoint.post("worktreeCreate", ExperimentalPaths.worktree, {
-          disableCodecs: true,
-          query: WorkspaceRoutingQuery,
-          payload: [HttpApiSchema.NoContent, Worktree.CreateInput],
-          success: described(Worktree.Info, "Worktree created"),
-          error: WorktreeApiError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "worktree.create",
-            summary: "Create worktree",
-            description: "Create a new git worktree for the current project and run any configured startup scripts.",
-          }),
-        ),
-        HttpApiEndpoint.delete("worktreeRemove", ExperimentalPaths.worktree, {
-          query: WorkspaceRoutingQuery,
-          payload: Worktree.RemoveInput,
-          success: described(Schema.Boolean, "Worktree removed"),
-          error: WorktreeApiError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "worktree.remove",
-            summary: "Remove worktree",
-            description: "Remove a git worktree and delete its branch.",
-          }),
-        ),
-        HttpApiEndpoint.post("worktreeReset", ExperimentalPaths.worktreeReset, {
-          query: WorkspaceRoutingQuery,
-          payload: Worktree.ResetInput,
-          success: described(Schema.Boolean, "Worktree reset"),
-          error: WorktreeApiError,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "worktree.reset",
-            summary: "Reset worktree",
-            description: "Reset a worktree branch to the primary default branch.",
-          }),
-        ),
-        HttpApiEndpoint.get("session", ExperimentalPaths.session, {
-          query: SessionListQuery,
-          success: described(Schema.Array(Session.GlobalInfo), "List of sessions"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.session.list",
-            summary: "List sessions",
-            description:
-              "Get a list of all OpenCode sessions across projects, sorted by most recently updated. Archived sessions are excluded by default.",
-          }),
-        ),
-        HttpApiEndpoint.post("sessionBackground", ExperimentalPaths.sessionBackground, {
-          params: { sessionID: SessionID },
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Boolean, "Backgrounded subagents"),
-          error: HttpApiError.BadRequest,
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.session.background",
-            summary: "Background subagents",
-            description:
-              "Detach any synchronous subagents currently blocking the session and continue them in the background.",
-          }),
-        ),
-        HttpApiEndpoint.get("resource", ExperimentalPaths.resource, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Record(Schema.String, MCP.Resource), "MCP resources"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "experimental.resource.list",
-            summary: "Get MCP resources",
-            description: "Get all available MCP resources from connected servers. Optionally filter by name.",
-          }),
-        ),
-      )
-      .annotateMerge(
-        OpenApi.annotations({
-          title: "experimental",
-          description: "Experimental HttpApi read-only routes.",
-        }),
-      )
-      .middleware(InstanceContextMiddleware)
-      .middleware(WorkspaceRoutingMiddleware)
-      .middleware(Authorization),
-  )
-  .annotateMerge(
-    OpenApi.annotations({
-      title: "opencode experimental HttpApi",
-      version: "0.0.1",
-      description: "Experimental HttpApi surface for selected instance routes.",
-    }),
-  )

package/src/server/routes/instance/httpapi/groups/file.ts

@@ -1,185 +0,0 @@
-import { FileSystem } from "@soraacode/core/filesystem"
-import { NonNegativeInt } from "@soraacode/core/schema"
-import { LSP } from "@/lsp/lsp"
-import { Schema } from "effect"
-import { HttpApi, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
-import { Authorization } from "../middleware/authorization"
-import { InstanceContextMiddleware } from "../middleware/instance-context"
-import {
-  WorkspaceRoutingMiddleware,
-  WorkspaceRoutingQuery,
-  WorkspaceRoutingQueryFields,
-} from "../middleware/workspace-routing"
-import { described } from "./metadata"
-
-export const FileQuery = Schema.Struct({
-  ...WorkspaceRoutingQueryFields,
-  path: Schema.String,
-})
-
-export const FindTextQuery = Schema.Struct({
-  ...WorkspaceRoutingQueryFields,
-  pattern: Schema.String,
-})
-
-export const FindFileQuery = Schema.Struct({
-  ...WorkspaceRoutingQueryFields,
-  query: Schema.String,
-  dirs: Schema.optional(Schema.Literals(["true", "false"])),
-  type: Schema.optional(Schema.Literals(["file", "directory"])),
-  limit: Schema.optional(
-    Schema.NumberFromString.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(200)),
-  ),
-})
-
-export const FindSymbolQuery = Schema.Struct({
-  ...WorkspaceRoutingQueryFields,
-  query: Schema.String,
-})
-
-export const LegacyMatch = Schema.Struct({
-  path: Schema.Struct({ text: Schema.String }),
-  lines: Schema.Struct({ text: Schema.String }),
-  line_number: NonNegativeInt,
-  absolute_offset: NonNegativeInt,
-  submatches: Schema.Array(
-    Schema.Struct({
-      match: Schema.Struct({ text: Schema.String }),
-      start: NonNegativeInt,
-      end: NonNegativeInt,
-    }),
-  ),
-})
-
-export const LegacyEntry = Schema.Struct({
-  name: Schema.String,
-  path: Schema.String,
-  absolute: Schema.String,
-  type: Schema.Literals(["file", "directory"]),
-  ignored: Schema.Boolean,
-}).annotate({ identifier: "FileNode" })
-
-export const LegacyContent = Schema.Struct({
-  type: Schema.Literals(["text", "binary"]),
-  content: Schema.String,
-  diff: Schema.optional(Schema.String),
-  patch: Schema.optional(
-    Schema.Struct({
-      oldFileName: Schema.String,
-      newFileName: Schema.String,
-      oldHeader: Schema.optional(Schema.String),
-      newHeader: Schema.optional(Schema.String),
-      hunks: Schema.Array(
-        Schema.Struct({
-          oldStart: NonNegativeInt,
-          oldLines: NonNegativeInt,
-          newStart: NonNegativeInt,
-          newLines: NonNegativeInt,
-          lines: Schema.Array(Schema.String),
-        }),
-      ),
-      index: Schema.optional(Schema.String),
-    }),
-  ),
-  encoding: Schema.optional(Schema.Literal("base64")),
-  mimeType: Schema.optional(Schema.String),
-}).annotate({ identifier: "FileContent" })
-
-export const LegacyStatus = Schema.Struct({
-  path: Schema.String,
-  added: NonNegativeInt,
-  removed: NonNegativeInt,
-  status: Schema.Literals(["added", "deleted", "modified"]),
-}).annotate({ identifier: "File" })
-
-export const FilePaths = {
-  findText: "/find",
-  findFile: "/find/file",
-  findSymbol: "/find/symbol",
-  list: "/file",
-  content: "/file/content",
-  status: "/file/status",
-} as const
-
-export const FileApi = HttpApi.make("file")
-  .add(
-    HttpApiGroup.make("file")
-      .add(
-        HttpApiEndpoint.get("findText", FilePaths.findText, {
-          query: FindTextQuery,
-          success: described(Schema.Array(LegacyMatch), "Matches"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "find.text",
-            summary: "Find text",
-            description: "Search for text patterns across files in the project using ripgrep.",
-          }),
-        ),
-        HttpApiEndpoint.get("findFile", FilePaths.findFile, {
-          query: FindFileQuery,
-          success: described(Schema.Array(Schema.String), "File paths"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "find.files",
-            summary: "Find files",
-            description: "Search for files or directories by name or pattern in the project directory.",
-          }),
-        ),
-        HttpApiEndpoint.get("findSymbol", FilePaths.findSymbol, {
-          query: FindSymbolQuery,
-          success: described(Schema.Array(LSP.Symbol), "Symbols"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "find.symbols",
-            summary: "Find symbols",
-            description: "Search for workspace symbols like functions, classes, and variables using LSP.",
-          }),
-        ),
-        HttpApiEndpoint.get("list", FilePaths.list, {
-          query: FileQuery,
-          success: described(Schema.Array(LegacyEntry), "Files and directories"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "file.list",
-            summary: "List files",
-            description: "List files and directories in a specified path.",
-          }),
-        ),
-        HttpApiEndpoint.get("content", FilePaths.content, {
-          query: FileQuery,
-          success: described(LegacyContent, "File content"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "file.read",
-            summary: "Read file",
-            description: "Read the content of a specified file.",
-          }),
-        ),
-        HttpApiEndpoint.get("status", FilePaths.status, {
-          query: WorkspaceRoutingQuery,
-          success: described(Schema.Array(LegacyStatus), "File status"),
-        }).annotateMerge(
-          OpenApi.annotations({
-            identifier: "file.status",
-            summary: "Get file status",
-            description: "Get the git status of all files in the project.",
-          }),
-        ),
-      )
-      .annotateMerge(
-        OpenApi.annotations({
-          title: "file",
-          description: "Experimental HttpApi file routes.",
-        }),
-      )
-      .middleware(InstanceContextMiddleware)
-      .middleware(WorkspaceRoutingMiddleware)
-      .middleware(Authorization),
-  )
-  .annotateMerge(
-    OpenApi.annotations({
-      title: "opencode experimental HttpApi",
-      version: "0.0.1",
-      description: "Experimental HttpApi surface for selected instance routes.",
-    }),
-  )