import { Log } from "../util/log"

import { Bus } from "../bus"

import { describeRoute, generateSpecs, validator, resolver, openAPIRouteHandler } from "hono-openapi"

import { Hono } from "hono"

import { cors } from "hono/cors"

import { streamSSE } from "hono/streaming"

import { Session } from "../session"

import z from "zod/v4"

import { Provider } from "../provider/provider"

import { mapValues } from "remeda"

import { NamedError } from "../util/error"

import { ModelsDev } from "../provider/models"

import { Ripgrep } from "../file/ripgrep"

import { Config } from "../config/config"

import { File } from "../file"

import { LSP } from "../lsp"

import { MessageV2 } from "../session/message-v2"

import { callTui, TuiRoute } from "./tui"

import { Permission } from "../permission"

import { Instance } from "../project/instance"

import { Agent } from "../agent/agent"

import { Auth } from "../auth"

import { Command } from "../command"

import { Global } from "../global"

import { ProjectRoute } from "./project"

import { ToolRegistry } from "../tool/registry"

import { zodToJsonSchema } from "zod-to-json-schema"

import { SessionLock } from "../session/lock"

import { SessionPrompt } from "../session/prompt"

import { SessionCompaction } from "../session/compaction"

import { SessionRevert } from "../session/revert"

import { lazy } from "../util/lazy"

import { Todo } from "../session/todo"

import { InstanceBootstrap } from "../project/bootstrap"

import { MCP } from "../mcp"

import { Storage } from "../storage/storage"

import type { ContentfulStatusCode } from "hono/utils/http-status"

const ERRORS = {

400: {

description: "Bad request",

content: {

"application/json": {

schema: resolver(

z

.object({

data: z.any().nullable(),

errors: z.array(z.record(z.string(), z.any())),

success: z.literal(false),

})

.meta({

ref: "BadRequestError",

}),

),

},

},

},

404: {

description: "Not found",

content: {

"application/json": {

schema: resolver(Storage.NotFoundError.Schema),

},

},

},

} as const

function errors(...codes: number[]) {

return Object.fromEntries(codes.map((code) => [code, ERRORS[code as keyof typeof ERRORS]]))

}

export namespace Server {

const log = Log.create({ service: "server" })

export const Event = {

Connected: Bus.event("server.connected", z.object({})),

}

const app = new Hono()

export const App = lazy(() =>

app

.onError((err, c) => {

log.error("failed", {

error: err,

})

if (err instanceof NamedError) {

let status: ContentfulStatusCode

if (err instanceof Storage.NotFoundError) status = 404

else if (err instanceof Provider.ModelNotFoundError) status = 400

else status = 500

return c.json(err.toObject(), { status })

}

const message = err instanceof Error && err.stack ? err.stack : err.toString()

return c.json(new NamedError.Unknown({ message }).toObject(), {

status: 500,

})

})

.use(async (c, next) => {

const skipLogging = c.req.path === "/log"

if (!skipLogging) {

log.info("request", {

method: c.req.method,

path: c.req.path,

})

}

const start = Date.now()

await next()

if (!skipLogging) {

log.info("response", {

duration: Date.now() - start,

})

}

})

.use(async (c, next) => {

const directory = c.req.query("directory") ?? process.cwd()

return Instance.provide({

directory,

init: InstanceBootstrap,

async fn() {

return next()

},

})

})

.use(cors())

.get(

"/doc",

openAPIRouteHandler(app, {

documentation: {

info: {

title: "opencode",

version: "0.0.3",

description: "opencode api",

},

openapi: "3.1.1",

},

}),

)

.use(validator("query", z.object({ directory: z.string().optional() })))

.route("/project", ProjectRoute)

.get(

"/config",

describeRoute({

description: "Get config info",

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(

"/config",

describeRoute({

description: "Update config",

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(

"/experimental/tool/ids",

describeRoute({

description: "List all tool IDs (including built-in and dynamically registered)",

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(

"/experimental/tool",

describeRoute({

description: "List tools with JSON schema parameters for a provider/model",

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, model } = c.req.valid("query")

const tools = await ToolRegistry.tools(provider, model)

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,

})),

)

},

)

.get(

"/path",

describeRoute({

description: "Get the current path",

operationId: "path.get",

responses: {

200: {

description: "Path",

content: {

"application/json": {

schema: resolver(

z

.object({

state: z.string(),

config: z.string(),

worktree: z.string(),

directory: z.string(),

})

.meta({

ref: "Path",

}),

),

},

},

},

},

}),

async (c) => {

return c.json({

state: Global.Path.state,

config: Global.Path.config,

worktree: Instance.worktree,

directory: Instance.directory,

})

},

)

.get(

"/session",

describeRoute({

description: "List all sessions",

operationId: "session.list",

responses: {

200: {

description: "List of sessions",

content: {

"application/json": {

schema: resolver(Session.Info.array()),

},

},

},

},

}),

async (c) => {

const sessions = await Array.fromAsync(Session.list())

sessions.sort((a, b) => b.time.updated - a.time.updated)

return c.json(sessions)

},

)

.get(

"/session/:id",

describeRoute({

description: "Get session",

operationId: "session.get",

responses: {

200: {

description: "Get session",

content: {

"application/json": {

schema: resolver(Session.Info),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: Session.get.schema,

}),

),

async (c) => {

const sessionID = c.req.valid("param").id

const session = await Session.get(sessionID)

return c.json(session)

},

)

.get(

"/session/:id/children",

describeRoute({

description: "Get a session's children",

operationId: "session.children",

responses: {

200: {

description: "List of children",

content: {

"application/json": {

schema: resolver(Session.Info.array()),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: Session.children.schema,

}),

),

async (c) => {

const sessionID = c.req.valid("param").id

const session = await Session.children(sessionID)

return c.json(session)

},

)

.get(

"/session/:id/todo",

describeRoute({

description: "Get the todo list for a session",

operationId: "session.todo",

responses: {

200: {

description: "Todo list",

content: {

"application/json": {

schema: resolver(Todo.Info.array()),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: z.string().meta({ description: "Session ID" }),

}),

),

async (c) => {

const sessionID = c.req.valid("param").id

const todos = await Todo.get(sessionID)

return c.json(todos)

},

)

.post(

"/session",

describeRoute({

description: "Create a new session",

operationId: "session.create",

responses: {

...errors(400),

200: {

description: "Successfully created session",

content: {

"application/json": {

schema: resolver(Session.Info),

},

},

},

},

}),

validator("json", Session.create.schema.optional()),

async (c) => {

const body = c.req.valid("json") ?? {}

const session = await Session.create(body)

return c.json(session)

},

)

.delete(

"/session/:id",

describeRoute({

description: "Delete a session and all its data",

operationId: "session.delete",

responses: {

200: {

description: "Successfully deleted session",

content: {

"application/json": {

schema: resolver(z.boolean()),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: Session.remove.schema,

}),

),

async (c) => {

await Session.remove(c.req.valid("param").id)

return c.json(true)

},

)

.patch(

"/session/:id",

describeRoute({

description: "Update session properties",

operationId: "session.update",

responses: {

200: {

description: "Successfully updated session",

content: {

"application/json": {

schema: resolver(Session.Info),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: z.string(),

}),

),

validator(

"json",

z.object({

title: z.string().optional(),

}),

),

async (c) => {

const sessionID = c.req.valid("param").id

const updates = c.req.valid("json")

const updatedSession = await Session.update(sessionID, (session) => {

if (updates.title !== undefined) {

session.title = updates.title

}

})

return c.json(updatedSession)

},

)

.post(

"/session/:id/init",

describeRoute({

description: "Analyze the app and create an AGENTS.md file",

operationId: "session.init",

responses: {

200: {

description: "200",

content: {

"application/json": {

schema: resolver(z.boolean()),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: z.string().meta({ description: "Session ID" }),

}),

),

validator("json", Session.initialize.schema.omit({ sessionID: true })),

async (c) => {

const sessionID = c.req.valid("param").id

const body = c.req.valid("json")

await Session.initialize({ ...body, sessionID })

return c.json(true)

},

)

.post(

"/session/:id/fork",

describeRoute({

description: "Fork an existing session at a specific message",

operationId: "session.fork",

responses: {

200: {

description: "200",

content: {

"application/json": {

schema: resolver(Session.Info),

},

},

},

},

}),

validator(

"param",

z.object({

id: Session.fork.schema.shape.sessionID,

}),

),

validator("json", Session.fork.schema.omit({ sessionID: true })),

async (c) => {

const sessionID = c.req.valid("param").id

const body = c.req.valid("json")

const result = await Session.fork({ ...body, sessionID })

return c.json(result)

},

)

.post(

"/session/:id/abort",

describeRoute({

description: "Abort a session",

operationId: "session.abort",

responses: {

200: {

description: "Aborted session",

content: {

"application/json": {

schema: resolver(z.boolean()),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: z.string(),

}),

),

async (c) => {

return c.json(SessionLock.abort(c.req.valid("param").id))

},

)

.post(

"/session/:id/share",

describeRoute({

description: "Share a session",

operationId: "session.share",

responses: {

200: {

description: "Successfully shared session",

content: {

"application/json": {

schema: resolver(Session.Info),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: z.string(),

}),

),

async (c) => {

const id = c.req.valid("param").id

await Session.share(id)

const session = await Session.get(id)

return c.json(session)

},

)

.delete(

"/session/:id/share",

describeRoute({

description: "Unshare the session",

operationId: "session.unshare",

responses: {

200: {

description: "Successfully unshared session",

content: {

"application/json": {

schema: resolver(Session.Info),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: Session.unshare.schema,

}),

),

async (c) => {

const id = c.req.valid("param").id

await Session.unshare(id)

const session = await Session.get(id)

return c.json(session)

},

)

.post(

"/session/:id/summarize",

describeRoute({

description: "Summarize the session",

operationId: "session.summarize",

responses: {

200: {

description: "Summarized session",

content: {

"application/json": {

schema: resolver(z.boolean()),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: z.string().meta({ description: "Session ID" }),

}),

),

validator(

"json",

z.object({

providerID: z.string(),

modelID: z.string(),

}),

),

async (c) => {

const id = c.req.valid("param").id

const body = c.req.valid("json")

await SessionCompaction.run({ ...body, sessionID: id })

return c.json(true)

},

)

.get(

"/session/:id/message",

describeRoute({

description: "List messages for a session",

operationId: "session.messages",

responses: {

200: {

description: "List of messages",

content: {

"application/json": {

schema: resolver(MessageV2.WithParts.array()),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: z.string().meta({ description: "Session ID" }),

}),

),

async (c) => {

const messages = await Session.messages(c.req.valid("param").id)

return c.json(messages)

},

)

.get(

"/session/:id/message/:messageID",

describeRoute({

description: "Get a message from a session",

operationId: "session.message",

responses: {

200: {

description: "Message",

content: {

"application/json": {

schema: resolver(

z.object({

info: MessageV2.Info,

parts: MessageV2.Part.array(),

}),

),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: z.string().meta({ description: "Session ID" }),

messageID: z.string().meta({ description: "Message ID" }),

}),

),

async (c) => {

const params = c.req.valid("param")

const message = await Session.getMessage({ sessionID: params.id, messageID: params.messageID })

return c.json(message)

},

)

.post(

"/session/:id/message",

describeRoute({

description: "Create and send a new message to a session",

operationId: "session.prompt",

responses: {

200: {

description: "Created message",

content: {

"application/json": {

schema: resolver(

z.object({

info: MessageV2.Assistant,

parts: MessageV2.Part.array(),

}),

),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: z.string().meta({ description: "Session ID" }),

}),

),

validator("json", SessionPrompt.PromptInput.omit({ sessionID: true })),

async (c) => {

const sessionID = c.req.valid("param").id

const body = c.req.valid("json")

const msg = await SessionPrompt.prompt({ ...body, sessionID })

return c.json(msg)

},

)

.post(

"/session/:id/command",

describeRoute({

description: "Send a new command to a session",

operationId: "session.command",

responses: {

200: {

description: "Created message",

content: {

"application/json": {

schema: resolver(

z.object({

info: MessageV2.Assistant,

parts: MessageV2.Part.array(),

}),

),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: z.string().meta({ description: "Session ID" }),

}),

),

validator("json", SessionPrompt.CommandInput.omit({ sessionID: true })),

async (c) => {

const sessionID = c.req.valid("param").id

const body = c.req.valid("json")

const msg = await SessionPrompt.command({ ...body, sessionID })

return c.json(msg)

},

)

.post(

"/session/:id/shell",

describeRoute({

description: "Run a shell command",

operationId: "session.shell",

responses: {

200: {

description: "Created message",

content: {

"application/json": {

schema: resolver(MessageV2.Assistant),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: z.string().meta({ description: "Session ID" }),

}),

),

validator("json", SessionPrompt.ShellInput.omit({ sessionID: true })),

async (c) => {

const sessionID = c.req.valid("param").id

const body = c.req.valid("json")

const msg = await SessionPrompt.shell({ ...body, sessionID })

return c.json(msg)

},

)

.post(

"/session/:id/revert",

describeRoute({

description: "Revert a message",

operationId: "session.revert",

responses: {

200: {

description: "Updated session",

content: {

"application/json": {

schema: resolver(Session.Info),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: z.string(),

}),

),

validator("json", SessionRevert.RevertInput.omit({ sessionID: true })),

async (c) => {

const id = c.req.valid("param").id

log.info("revert", c.req.valid("json"))

const session = await SessionRevert.revert({ sessionID: id, ...c.req.valid("json") })

return c.json(session)

},

)

.post(

"/session/:id/unrevert",

describeRoute({

description: "Restore all reverted messages",

operationId: "session.unrevert",

responses: {

200: {

description: "Updated session",

content: {

"application/json": {

schema: resolver(Session.Info),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: z.string(),

}),

),

async (c) => {

const id = c.req.valid("param").id

const session = await SessionRevert.unrevert({ sessionID: id })

return c.json(session)

},

)

.post(

"/session/:id/permissions/:permissionID",

describeRoute({

description: "Respond to a permission request",

responses: {

200: {

description: "Permission processed successfully",

content: {

"application/json": {

schema: resolver(z.boolean()),

},

},

},

...errors(400, 404),

},

}),

validator(

"param",

z.object({

id: z.string(),

permissionID: z.string(),

}),

),

validator("json", z.object({ response: Permission.Response })),

async (c) => {

const params = c.req.valid("param")

const id = params.id

const permissionID = params.permissionID

Permission.respond({ sessionID: id, permissionID, response: c.req.valid("json").response })

return c.json(true)

},

)

.get(

"/command",

describeRoute({

description: "List all commands",

operationId: "command.list",

responses: {

200: {

description: "List of commands",

content: {

"application/json": {

schema: resolver(Command.Info.array()),

},

},

},

},

}),

async (c) => {

const commands = await Command.list()

return c.json(commands)

},

)

.get(

"/config/providers",

describeRoute({

description: "List all providers",

operationId: "config.providers",

responses: {

200: {

description: "List of providers",

content: {

"application/json": {

schema: resolver(

z.object({

providers: ModelsDev.Provider.array(),

default: z.record(z.string(), z.string()),

}),

),

},

},

},

},

}),

async (c) => {

const providers = await Provider.list().then((x) => mapValues(x, (item) => item.info))

return c.json({

providers: Object.values(providers),

default: mapValues(providers, (item) => Provider.sort(Object.values(item.models))[0].id),

})

},

)

.get(

"/find",

describeRoute({

description: "Find text in files",

operationId: "find.text",

responses: {

200: {

description: "Matches",

content: {

"application/json": {

schema: resolver(Ripgrep.Match.shape.data.array()),

},

},

},

},