refactor: split up routes from server.ts into individual files

packages/opencode/src/server/routes/config.ts

@@ -0,0 +1,92 @@
+import { Hono } from "hono"
+import { describeRoute, validator, resolver } from "hono-openapi"
+import z from "zod"
+import { Config } from "../../config/config"
+import { Provider } from "../../provider/provider"
+import { mapValues } from "remeda"
+import { errors } from "../error"
+import { Log } from "../../util/log"
+import { lazy } from "../../util/lazy"
+
+const log = Log.create({ service: "server" })
+
+export const ConfigRoutes = lazy(() =>
+  new Hono()
+    .get(
+      "/",
+      describeRoute({
+        summary: "Get configuration",
+        description: "Retrieve the current OpenCode configuration settings and preferences.",
+        operationId: "config.get",
+        responses: {
+          200: {
+            description: "Get config info",
+            content: {
+              "application/json": {
+                schema: resolver(Config.Info),
+              },
+            },
+          },
+        },
+      }),
+      async (c) => {
+        return c.json(await Config.get())
+      },
+    )
+    .patch(
+      "/",
+      describeRoute({
+        summary: "Update configuration",
+        description: "Update OpenCode configuration settings and preferences.",
+        operationId: "config.update",
+        responses: {
+          200: {
+            description: "Successfully updated config",
+            content: {
+              "application/json": {
+                schema: resolver(Config.Info),
+              },
+            },
+          },
+          ...errors(400),
+        },
+      }),
+      validator("json", Config.Info),
+      async (c) => {
+        const config = c.req.valid("json")
+        await Config.update(config)
+        return c.json(config)
+      },
+    )
+    .get(
+      "/providers",
+      describeRoute({
+        summary: "List config providers",
+        description: "Get a list of all configured AI providers and their default models.",
+        operationId: "config.providers",
+        responses: {
+          200: {
+            description: "List of providers",
+            content: {
+              "application/json": {
+                schema: resolver(
+                  z.object({
+                    providers: Provider.Info.array(),
+                    default: z.record(z.string(), z.string()),
+                  }),
+                ),
+              },
+            },
+          },
+        },
+      }),
+      async (c) => {
+        using _ = log.time("providers")
+        const providers = await Provider.list().then((x) => mapValues(x, (item) => item))
+        return c.json({
+          providers: Object.values(providers),
+          default: mapValues(providers, (item) => Provider.sort(Object.values(item.models))[0].id),
+        })
+      },
+    ),
+)

packages/opencode/src/server/routes/experimental.ts

@@ -0,0 +1,156 @@
+import { Hono } from "hono"
+import { describeRoute, validator, resolver } from "hono-openapi"
+import z from "zod"
+import { ToolRegistry } from "../../tool/registry"
+import { Worktree } from "../../worktree"
+import { Instance } from "../../project/instance"
+import { Project } from "../../project/project"
+import { MCP } from "../../mcp"
+import { zodToJsonSchema } from "zod-to-json-schema"
+import { errors } from "../error"
+import { lazy } from "../../util/lazy"
+
+export const ExperimentalRoutes = lazy(() => new Hono()
+  .get(
+    "/tool/ids",
+    describeRoute({
+      summary: "List tool IDs",
+      description:
+        "Get a list of all available tool IDs, including both built-in tools and dynamically registered tools.",
+      operationId: "tool.ids",
+      responses: {
+        200: {
+          description: "Tool IDs",
+          content: {
+            "application/json": {
+              schema: resolver(z.array(z.string()).meta({ ref: "ToolIDs" })),
+            },
+          },
+        },
+        ...errors(400),
+      },
+    }),
+    async (c) => {
+      return c.json(await ToolRegistry.ids())
+    },
+  )
+  .get(
+    "/tool",
+    describeRoute({
+      summary: "List tools",
+      description:
+        "Get a list of available tools with their JSON schema parameters for a specific provider and model combination.",
+      operationId: "tool.list",
+      responses: {
+        200: {
+          description: "Tools",
+          content: {
+            "application/json": {
+              schema: resolver(
+                z
+                  .array(
+                    z
+                      .object({
+                        id: z.string(),
+                        description: z.string(),
+                        parameters: z.any(),
+                      })
+                      .meta({ ref: "ToolListItem" }),
+                  )
+                  .meta({ ref: "ToolList" }),
+              ),
+            },
+          },
+        },
+        ...errors(400),
+      },
+    }),
+    validator(
+      "query",
+      z.object({
+        provider: z.string(),
+        model: z.string(),
+      }),
+    ),
+    async (c) => {
+      const { provider } = c.req.valid("query")
+      const tools = await ToolRegistry.tools(provider)
+      return c.json(
+        tools.map((t) => ({
+          id: t.id,
+          description: t.description,
+          // Handle both Zod schemas and plain JSON schemas
+          parameters: (t.parameters as any)?._def ? zodToJsonSchema(t.parameters as any) : t.parameters,
+        })),
+      )
+    },
+  )
+  .post(
+    "/worktree",
+    describeRoute({
+      summary: "Create worktree",
+      description: "Create a new git worktree for the current project.",
+      operationId: "worktree.create",
+      responses: {
+        200: {
+          description: "Worktree created",
+          content: {
+            "application/json": {
+              schema: resolver(Worktree.Info),
+            },
+          },
+        },
+        ...errors(400),
+      },
+    }),
+    validator("json", Worktree.create.schema),
+    async (c) => {
+      const body = c.req.valid("json")
+      const worktree = await Worktree.create(body)
+      return c.json(worktree)
+    },
+  )
+  .get(
+    "/worktree",
+    describeRoute({
+      summary: "List worktrees",
+      description: "List all sandbox worktrees for the current project.",
+      operationId: "worktree.list",
+      responses: {
+        200: {
+          description: "List of worktree directories",
+          content: {
+            "application/json": {
+              schema: resolver(z.array(z.string())),
+            },
+          },
+        },
+      },
+    }),
+    async (c) => {
+      const sandboxes = await Project.sandboxes(Instance.project.id)
+      return c.json(sandboxes)
+    },
+  )
+  .get(
+    "/resource",
+    describeRoute({
+      summary: "Get MCP resources",
+      description: "Get all available MCP resources from connected servers. Optionally filter by name.",
+      operationId: "experimental.resource.list",
+      responses: {
+        200: {
+          description: "MCP resources",
+          content: {
+            "application/json": {
+              schema: resolver(z.record(z.string(), MCP.Resource)),
+            },
+          },
+        },
+      },
+    }),
+    async (c) => {
+      return c.json(await MCP.resources())
+    },
+  )
+)