Kit Langton
b4836589f4
This reverts: -28b03595bresearch: delete Hono backend (do not merge) (#25667) -b24a4e897chore(server): clean up post-Hono-deletion scar tissue (#26542) v1.14.42 broke startup for users with plugins that depend on the Hono wire format (most visibly opencode-gemini-auth, see #26546). Restoring Hono as the default backend on stable channels while we investigate the actual plugin compatibility story. OPENCODE_EXPERIMENTAL_HTTPAPI flag and dual-backend selection come back. Stable installs default to Hono; dev/beta default to HTTP API. Conflict resolution: took the pre-deletion side for control-plane schemas and the seven test files where post-deletion follow-up PRs had also touched the conflicting lines. The HTTP API code added since the deletion (compression, cors-vary, fence, lifecycle log, account error mapping, etc.) is preserved as-is — those still apply on the HTTP API path for users on dev/beta channels.
503 lines
19 KiB
TypeScript
503 lines
19 KiB
TypeScript
import { describeRoute, resolver, validator } from "hono-openapi"
|
|
import { Hono } from "hono"
|
|
import type { UpgradeWebSocket } from "hono/ws"
|
|
import { Context, Effect } from "effect"
|
|
import { Flag } from "@opencode-ai/core/flag/flag"
|
|
import z from "zod"
|
|
import { Format } from "@/format"
|
|
import { TuiRoutes } from "./tui"
|
|
import { Instance } from "@/project/instance"
|
|
import { InstanceRuntime } from "@/project/instance-runtime"
|
|
import { Vcs } from "@/project/vcs"
|
|
import { Agent } from "@/agent/agent"
|
|
import { Skill } from "@/skill"
|
|
import { Global } from "@opencode-ai/core/global"
|
|
import { LSP } from "@/lsp/lsp"
|
|
import { Command } from "@/command"
|
|
import { QuestionRoutes } from "./question"
|
|
import { PermissionRoutes } from "./permission"
|
|
import { ProjectRoutes } from "./project"
|
|
import { SessionRoutes } from "./session"
|
|
import { PtyRoutes } from "./pty"
|
|
import { McpRoutes } from "./mcp"
|
|
import { FileRoutes } from "./file"
|
|
import { ConfigRoutes } from "./config"
|
|
import { ExperimentalRoutes } from "./experimental"
|
|
import { ProviderRoutes } from "./provider"
|
|
import { EventRoutes } from "./event"
|
|
import { SyncRoutes } from "./sync"
|
|
import { InstanceMiddleware } from "./middleware"
|
|
import { jsonRequest, runRequest } from "./trace"
|
|
import { ExperimentalHttpApiServer } from "./httpapi/server"
|
|
import { EventPaths } from "./httpapi/event"
|
|
import { ExperimentalPaths } from "./httpapi/groups/experimental"
|
|
import { FilePaths } from "./httpapi/groups/file"
|
|
import { InstancePaths } from "./httpapi/groups/instance"
|
|
import { McpPaths } from "./httpapi/groups/mcp"
|
|
import { PtyPaths } from "./httpapi/groups/pty"
|
|
import { SessionPaths } from "./httpapi/groups/session"
|
|
import { SyncPaths } from "./httpapi/groups/sync"
|
|
import { TuiPaths } from "./httpapi/groups/tui"
|
|
import { WorkspacePaths } from "./httpapi/groups/workspace"
|
|
import type { CorsOptions } from "@/server/cors"
|
|
import { errors } from "@/server/error"
|
|
|
|
export const InstanceRoutes = (upgrade: UpgradeWebSocket, opts?: CorsOptions): Hono => {
|
|
const app = new Hono()
|
|
const handler = ExperimentalHttpApiServer.webHandler(opts).handler
|
|
const context = Context.empty() as Context.Context<unknown>
|
|
|
|
app.all("/api/*", (c) => handler(c.req.raw, context))
|
|
|
|
if (Flag.OPENCODE_EXPERIMENTAL_HTTPAPI) {
|
|
app.get(EventPaths.event, (c) => handler(c.req.raw, context))
|
|
app.get("/question", (c) => handler(c.req.raw, context))
|
|
app.post("/question/:requestID/reply", (c) => handler(c.req.raw, context))
|
|
app.post("/question/:requestID/reject", (c) => handler(c.req.raw, context))
|
|
app.get("/permission", (c) => handler(c.req.raw, context))
|
|
app.post("/permission/:requestID/reply", (c) => handler(c.req.raw, context))
|
|
app.get("/config", (c) => handler(c.req.raw, context))
|
|
app.patch("/config", (c) => handler(c.req.raw, context))
|
|
app.get("/config/providers", (c) => handler(c.req.raw, context))
|
|
app.get(ExperimentalPaths.console, (c) => handler(c.req.raw, context))
|
|
app.get(ExperimentalPaths.consoleOrgs, (c) => handler(c.req.raw, context))
|
|
app.post(ExperimentalPaths.consoleSwitch, (c) => handler(c.req.raw, context))
|
|
app.get(ExperimentalPaths.tool, (c) => handler(c.req.raw, context))
|
|
app.get(ExperimentalPaths.toolIDs, (c) => handler(c.req.raw, context))
|
|
app.get(ExperimentalPaths.worktree, (c) => handler(c.req.raw, context))
|
|
app.post(ExperimentalPaths.worktree, (c) => handler(c.req.raw, context))
|
|
app.delete(ExperimentalPaths.worktree, (c) => handler(c.req.raw, context))
|
|
app.post(ExperimentalPaths.worktreeReset, (c) => handler(c.req.raw, context))
|
|
app.get(ExperimentalPaths.session, (c) => handler(c.req.raw, context))
|
|
app.get(ExperimentalPaths.resource, (c) => handler(c.req.raw, context))
|
|
app.get("/provider", (c) => handler(c.req.raw, context))
|
|
app.get("/provider/auth", (c) => handler(c.req.raw, context))
|
|
app.post("/provider/:providerID/oauth/authorize", (c) => handler(c.req.raw, context))
|
|
app.post("/provider/:providerID/oauth/callback", (c) => handler(c.req.raw, context))
|
|
app.get("/project", (c) => handler(c.req.raw, context))
|
|
app.get("/project/current", (c) => handler(c.req.raw, context))
|
|
app.post("/project/git/init", (c) => handler(c.req.raw, context))
|
|
app.patch("/project/:projectID", (c) => handler(c.req.raw, context))
|
|
app.get(FilePaths.findText, (c) => handler(c.req.raw, context))
|
|
app.get(FilePaths.findFile, (c) => handler(c.req.raw, context))
|
|
app.get(FilePaths.findSymbol, (c) => handler(c.req.raw, context))
|
|
app.get(FilePaths.list, (c) => handler(c.req.raw, context))
|
|
app.get(FilePaths.content, (c) => handler(c.req.raw, context))
|
|
app.get(FilePaths.status, (c) => handler(c.req.raw, context))
|
|
app.get(InstancePaths.path, (c) => handler(c.req.raw, context))
|
|
app.post(InstancePaths.dispose, (c) => handler(c.req.raw, context))
|
|
app.get(InstancePaths.vcs, (c) => handler(c.req.raw, context))
|
|
app.get(InstancePaths.vcsStatus, (c) => handler(c.req.raw, context))
|
|
app.get(InstancePaths.vcsDiff, (c) => handler(c.req.raw, context))
|
|
app.get(InstancePaths.vcsDiffRaw, (c) => handler(c.req.raw, context))
|
|
app.post(InstancePaths.vcsApply, (c) => handler(c.req.raw, context))
|
|
app.get(InstancePaths.command, (c) => handler(c.req.raw, context))
|
|
app.get(InstancePaths.agent, (c) => handler(c.req.raw, context))
|
|
app.get(InstancePaths.skill, (c) => handler(c.req.raw, context))
|
|
app.get(InstancePaths.lsp, (c) => handler(c.req.raw, context))
|
|
app.get(InstancePaths.formatter, (c) => handler(c.req.raw, context))
|
|
app.get(McpPaths.status, (c) => handler(c.req.raw, context))
|
|
app.post(McpPaths.status, (c) => handler(c.req.raw, context))
|
|
app.post(McpPaths.auth, (c) => handler(c.req.raw, context))
|
|
app.post(McpPaths.authCallback, (c) => handler(c.req.raw, context))
|
|
app.post(McpPaths.authAuthenticate, (c) => handler(c.req.raw, context))
|
|
app.delete(McpPaths.auth, (c) => handler(c.req.raw, context))
|
|
app.post(McpPaths.connect, (c) => handler(c.req.raw, context))
|
|
app.post(McpPaths.disconnect, (c) => handler(c.req.raw, context))
|
|
app.post(SyncPaths.start, (c) => handler(c.req.raw, context))
|
|
app.post(SyncPaths.replay, (c) => handler(c.req.raw, context))
|
|
app.post(SyncPaths.history, (c) => handler(c.req.raw, context))
|
|
app.get(PtyPaths.list, (c) => handler(c.req.raw, context))
|
|
app.post(PtyPaths.create, (c) => handler(c.req.raw, context))
|
|
app.get(PtyPaths.get, (c) => handler(c.req.raw, context))
|
|
app.put(PtyPaths.update, (c) => handler(c.req.raw, context))
|
|
app.delete(PtyPaths.remove, (c) => handler(c.req.raw, context))
|
|
app.post(PtyPaths.connectToken, (c) => handler(c.req.raw, context))
|
|
app.get(PtyPaths.connect, (c) => handler(c.req.raw, context))
|
|
app.get(SessionPaths.list, (c) => handler(c.req.raw, context))
|
|
app.get(SessionPaths.status, (c) => handler(c.req.raw, context))
|
|
app.get(SessionPaths.get, (c) => handler(c.req.raw, context))
|
|
app.get(SessionPaths.children, (c) => handler(c.req.raw, context))
|
|
app.get(SessionPaths.todo, (c) => handler(c.req.raw, context))
|
|
app.get(SessionPaths.diff, (c) => handler(c.req.raw, context))
|
|
app.get(SessionPaths.messages, (c) => handler(c.req.raw, context))
|
|
app.get(SessionPaths.message, (c) => handler(c.req.raw, context))
|
|
app.post(SessionPaths.create, (c) => handler(c.req.raw, context))
|
|
app.delete(SessionPaths.remove, (c) => handler(c.req.raw, context))
|
|
app.patch(SessionPaths.update, (c) => handler(c.req.raw, context))
|
|
app.post(SessionPaths.init, (c) => handler(c.req.raw, context))
|
|
app.post(SessionPaths.fork, (c) => handler(c.req.raw, context))
|
|
app.post(SessionPaths.abort, (c) => handler(c.req.raw, context))
|
|
app.post(SessionPaths.share, (c) => handler(c.req.raw, context))
|
|
app.delete(SessionPaths.share, (c) => handler(c.req.raw, context))
|
|
app.post(SessionPaths.summarize, (c) => handler(c.req.raw, context))
|
|
app.post(SessionPaths.prompt, (c) => handler(c.req.raw, context))
|
|
app.post(SessionPaths.promptAsync, (c) => handler(c.req.raw, context))
|
|
app.post(SessionPaths.command, (c) => handler(c.req.raw, context))
|
|
app.post(SessionPaths.shell, (c) => handler(c.req.raw, context))
|
|
app.post(SessionPaths.revert, (c) => handler(c.req.raw, context))
|
|
app.post(SessionPaths.unrevert, (c) => handler(c.req.raw, context))
|
|
app.post(SessionPaths.permissions, (c) => handler(c.req.raw, context))
|
|
app.delete(SessionPaths.deleteMessage, (c) => handler(c.req.raw, context))
|
|
app.delete(SessionPaths.deletePart, (c) => handler(c.req.raw, context))
|
|
app.patch(SessionPaths.updatePart, (c) => handler(c.req.raw, context))
|
|
app.post(TuiPaths.appendPrompt, (c) => handler(c.req.raw, context))
|
|
app.post(TuiPaths.openHelp, (c) => handler(c.req.raw, context))
|
|
app.post(TuiPaths.openSessions, (c) => handler(c.req.raw, context))
|
|
app.post(TuiPaths.openThemes, (c) => handler(c.req.raw, context))
|
|
app.post(TuiPaths.openModels, (c) => handler(c.req.raw, context))
|
|
app.post(TuiPaths.submitPrompt, (c) => handler(c.req.raw, context))
|
|
app.post(TuiPaths.clearPrompt, (c) => handler(c.req.raw, context))
|
|
app.post(TuiPaths.executeCommand, (c) => handler(c.req.raw, context))
|
|
app.post(TuiPaths.showToast, (c) => handler(c.req.raw, context))
|
|
app.post(TuiPaths.publish, (c) => handler(c.req.raw, context))
|
|
app.post(TuiPaths.selectSession, (c) => handler(c.req.raw, context))
|
|
app.get(TuiPaths.controlNext, (c) => handler(c.req.raw, context))
|
|
app.post(TuiPaths.controlResponse, (c) => handler(c.req.raw, context))
|
|
app.get(WorkspacePaths.adapters, (c) => handler(c.req.raw, context))
|
|
app.post(WorkspacePaths.list, (c) => handler(c.req.raw, context))
|
|
app.get(WorkspacePaths.list, (c) => handler(c.req.raw, context))
|
|
app.get(WorkspacePaths.status, (c) => handler(c.req.raw, context))
|
|
app.delete(WorkspacePaths.remove, (c) => handler(c.req.raw, context))
|
|
app.post(WorkspacePaths.warp, (c) => handler(c.req.raw, context))
|
|
}
|
|
|
|
return app
|
|
.route("/project", ProjectRoutes())
|
|
.route("/pty", PtyRoutes(upgrade, opts))
|
|
.route("/config", ConfigRoutes())
|
|
.route("/experimental", ExperimentalRoutes())
|
|
.route("/session", SessionRoutes())
|
|
.route("/permission", PermissionRoutes())
|
|
.route("/question", QuestionRoutes())
|
|
.route("/provider", ProviderRoutes())
|
|
.route("/sync", SyncRoutes())
|
|
.route("/", FileRoutes())
|
|
.route("/", EventRoutes())
|
|
.route("/mcp", McpRoutes())
|
|
.route("/tui", TuiRoutes())
|
|
.post(
|
|
"/instance/dispose",
|
|
describeRoute({
|
|
summary: "Dispose instance",
|
|
description: "Clean up and dispose the current OpenCode instance, releasing all resources.",
|
|
operationId: "instance.dispose",
|
|
responses: {
|
|
200: {
|
|
description: "Instance disposed",
|
|
content: {
|
|
"application/json": {
|
|
schema: resolver(z.boolean()),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
async (c) => {
|
|
await InstanceRuntime.disposeInstance(Instance.current)
|
|
return c.json(true)
|
|
},
|
|
)
|
|
.get(
|
|
"/path",
|
|
describeRoute({
|
|
summary: "Get paths",
|
|
description: "Retrieve the current working directory and related path information for the OpenCode instance.",
|
|
operationId: "path.get",
|
|
responses: {
|
|
200: {
|
|
description: "Path",
|
|
content: {
|
|
"application/json": {
|
|
schema: resolver(
|
|
z
|
|
.object({
|
|
home: z.string(),
|
|
state: z.string(),
|
|
config: z.string(),
|
|
worktree: z.string(),
|
|
directory: z.string(),
|
|
})
|
|
.meta({
|
|
ref: "Path",
|
|
}),
|
|
),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
async (c) => {
|
|
return c.json({
|
|
home: Global.Path.home,
|
|
state: Global.Path.state,
|
|
config: Global.Path.config,
|
|
worktree: Instance.worktree,
|
|
directory: Instance.directory,
|
|
})
|
|
},
|
|
)
|
|
.get(
|
|
"/vcs",
|
|
describeRoute({
|
|
summary: "Get VCS info",
|
|
description: "Retrieve version control system (VCS) information for the current project, such as git branch.",
|
|
operationId: "vcs.get",
|
|
responses: {
|
|
200: {
|
|
description: "VCS info",
|
|
content: {
|
|
"application/json": {
|
|
schema: resolver(Vcs.Info.zod),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
async (c) =>
|
|
jsonRequest("InstanceRoutes.vcs.get", c, function* () {
|
|
const vcs = yield* Vcs.Service
|
|
const [branch, default_branch] = yield* Effect.all([vcs.branch(), vcs.defaultBranch()], {
|
|
concurrency: 2,
|
|
})
|
|
return { branch, default_branch }
|
|
}),
|
|
)
|
|
.get(
|
|
"/vcs/diff",
|
|
describeRoute({
|
|
summary: "Get VCS diff",
|
|
description: "Retrieve the current git diff for the working tree or against the default branch.",
|
|
operationId: "vcs.diff",
|
|
responses: {
|
|
200: {
|
|
description: "VCS diff",
|
|
content: {
|
|
"application/json": {
|
|
schema: resolver(Vcs.FileDiff.zod.array()),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
validator(
|
|
"query",
|
|
z.object({
|
|
mode: Vcs.Mode.zod,
|
|
}),
|
|
),
|
|
async (c) =>
|
|
jsonRequest("InstanceRoutes.vcs.diff", c, function* () {
|
|
const vcs = yield* Vcs.Service
|
|
return yield* vcs.diff(c.req.valid("query").mode)
|
|
}),
|
|
)
|
|
.get(
|
|
"/vcs/status",
|
|
describeRoute({
|
|
summary: "Get VCS status",
|
|
description: "Retrieve changed files in the current working tree without patches.",
|
|
operationId: "vcs.status",
|
|
responses: {
|
|
200: {
|
|
description: "VCS status",
|
|
content: {
|
|
"application/json": {
|
|
schema: resolver(Vcs.FileStatus.zod.array()),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
async (c) =>
|
|
jsonRequest("InstanceRoutes.vcs.status", c, function* () {
|
|
const vcs = yield* Vcs.Service
|
|
return yield* vcs.status()
|
|
}),
|
|
)
|
|
.get(
|
|
"/vcs/diff/raw",
|
|
describeRoute({
|
|
summary: "Get raw VCS diff",
|
|
description: "Retrieve a raw patch for current uncommitted changes.",
|
|
operationId: "vcs.diff.raw",
|
|
responses: {
|
|
200: {
|
|
description: "Raw VCS diff",
|
|
content: {
|
|
"text/x-diff": {
|
|
schema: resolver(z.string()),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
async (c) => {
|
|
const patch = await runRequest(
|
|
"InstanceRoutes.vcs.diffRaw",
|
|
c,
|
|
Vcs.Service.use((vcs) => vcs.diffRaw()),
|
|
)
|
|
return c.text(patch, 200, { "content-type": "text/x-diff; charset=utf-8" })
|
|
},
|
|
)
|
|
.post(
|
|
"/vcs/apply",
|
|
describeRoute({
|
|
summary: "Apply VCS patch",
|
|
description: "Apply a raw patch to the current working tree.",
|
|
operationId: "vcs.apply",
|
|
responses: {
|
|
200: {
|
|
description: "VCS patch applied",
|
|
content: {
|
|
"application/json": {
|
|
schema: resolver(Vcs.ApplyResult.zod),
|
|
},
|
|
},
|
|
},
|
|
...errors(400),
|
|
},
|
|
}),
|
|
validator("json", Vcs.ApplyInput.zodObject),
|
|
async (c) => {
|
|
const result = await runRequest(
|
|
"InstanceRoutes.vcs.apply",
|
|
c,
|
|
Vcs.Service.use((vcs) => vcs.apply(c.req.valid("json") as Vcs.ApplyInput)).pipe(
|
|
Effect.match({
|
|
onFailure: (error) => ({ ok: false as const, error }),
|
|
onSuccess: (value) => ({ ok: true as const, value }),
|
|
}),
|
|
),
|
|
)
|
|
if (result.ok) return c.json(result.value)
|
|
return c.json(
|
|
{
|
|
name: "VcsApplyError",
|
|
data: {
|
|
message: result.error.message,
|
|
reason: result.error.reason,
|
|
},
|
|
},
|
|
400,
|
|
)
|
|
},
|
|
)
|
|
.get(
|
|
"/command",
|
|
describeRoute({
|
|
summary: "List commands",
|
|
description: "Get a list of all available commands in the OpenCode system.",
|
|
operationId: "command.list",
|
|
responses: {
|
|
200: {
|
|
description: "List of commands",
|
|
content: {
|
|
"application/json": {
|
|
schema: resolver(Command.Info.zod.array()),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
async (c) =>
|
|
jsonRequest("InstanceRoutes.command.list", c, function* () {
|
|
const svc = yield* Command.Service
|
|
return yield* svc.list()
|
|
}),
|
|
)
|
|
.get(
|
|
"/agent",
|
|
describeRoute({
|
|
summary: "List agents",
|
|
description: "Get a list of all available AI agents in the OpenCode system.",
|
|
operationId: "app.agents",
|
|
responses: {
|
|
200: {
|
|
description: "List of agents",
|
|
content: {
|
|
"application/json": {
|
|
schema: resolver(Agent.Info.zod.array()),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
async (c) =>
|
|
jsonRequest("InstanceRoutes.agent.list", c, function* () {
|
|
const svc = yield* Agent.Service
|
|
return yield* svc.list()
|
|
}),
|
|
)
|
|
.get(
|
|
"/skill",
|
|
describeRoute({
|
|
summary: "List skills",
|
|
description: "Get a list of all available skills in the OpenCode system.",
|
|
operationId: "app.skills",
|
|
responses: {
|
|
200: {
|
|
description: "List of skills",
|
|
content: {
|
|
"application/json": {
|
|
schema: resolver(Skill.Info.zod.array()),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
async (c) =>
|
|
jsonRequest("InstanceRoutes.skill.list", c, function* () {
|
|
const skill = yield* Skill.Service
|
|
return yield* skill.all()
|
|
}),
|
|
)
|
|
.get(
|
|
"/lsp",
|
|
describeRoute({
|
|
summary: "Get LSP status",
|
|
description: "Get LSP server status",
|
|
operationId: "lsp.status",
|
|
responses: {
|
|
200: {
|
|
description: "LSP server status",
|
|
content: {
|
|
"application/json": {
|
|
schema: resolver(LSP.Status.zod.array()),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
async (c) =>
|
|
jsonRequest("InstanceRoutes.lsp.status", c, function* () {
|
|
const lsp = yield* LSP.Service
|
|
return yield* lsp.status()
|
|
}),
|
|
)
|
|
.get(
|
|
"/formatter",
|
|
describeRoute({
|
|
summary: "Get formatter status",
|
|
description: "Get formatter status",
|
|
operationId: "formatter.status",
|
|
responses: {
|
|
200: {
|
|
description: "Formatter status",
|
|
content: {
|
|
"application/json": {
|
|
schema: resolver(Format.Status.zod.array()),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
async (c) =>
|
|
jsonRequest("InstanceRoutes.formatter.status", c, function* () {
|
|
const svc = yield* Format.Service
|
|
return yield* svc.status()
|
|
}),
|
|
)
|
|
}
|