@happy-creative/iroder 1.0.0

package/src/runtime/ports.ts

@@ -0,0 +1,74 @@
+import { Server } from "@/server/server"
+import type { MCP } from "@/mcp"
+import type { Agent } from "@/agent/agent"
+import type { MessageV2 } from "@/session/message-v2"
+import type { SessionPrompt } from "@/session/prompt"
+import type { SessionRevert } from "@/session/revert"
+import type { SessionStatus } from "@/session/status"
+import type { SessionSummary } from "@/session/summary"
+import type { Skill } from "@/skill"
+import type { Todo } from "@/session/todo"
+import type { ProviderID, ModelID } from "@/provider/schema"
+import type { Session } from "@/session"
+
+export type SessionPort = {
+  list(input?: Parameters<typeof Session.list>[0]): Promise<Session.Info[]>
+  status(): Promise<Record<string, SessionStatus.Info>>
+  get(sessionID: Parameters<typeof Session.get>[0]): ReturnType<typeof Session.get>
+  children(sessionID: Parameters<typeof Session.children>[0]): ReturnType<typeof Session.children>
+  todo(sessionID: Parameters<typeof Todo.get>[0]): ReturnType<typeof Todo.get>
+  create(input: Parameters<typeof Session.create>[0]): ReturnType<typeof Session.create>
+  remove(sessionID: Parameters<typeof Session.remove>[0]): ReturnType<typeof Session.remove>
+  setTitle(input: Parameters<typeof Session.setTitle>[0]): ReturnType<typeof Session.setTitle>
+  setArchived(input: Parameters<typeof Session.setArchived>[0]): ReturnType<typeof Session.setArchived>
+  initialize(input: Parameters<typeof Session.initialize>[0]): ReturnType<typeof Session.initialize>
+  fork(input: Parameters<typeof Session.fork>[0]): ReturnType<typeof Session.fork>
+  cancel(sessionID: Parameters<typeof SessionPrompt.cancel>[0]): ReturnType<typeof SessionPrompt.cancel>
+  share(sessionID: Parameters<typeof Session.share>[0]): ReturnType<typeof Session.share>
+  unshare(sessionID: Parameters<typeof Session.unshare>[0]): ReturnType<typeof Session.unshare>
+  messageDiff(input: Parameters<typeof SessionSummary.diff>[0]): ReturnType<typeof SessionSummary.diff>
+  summarize(input: {
+    sessionID: Parameters<typeof Session.get>[0]
+    providerID: ProviderID
+    modelID: ModelID
+    auto?: boolean
+  }): Promise<void>
+  messages(input: Parameters<typeof Session.messages>[0]): ReturnType<typeof Session.messages>
+  message(input: Parameters<typeof MessageV2.get>[0]): ReturnType<typeof MessageV2.get>
+  page(input: Parameters<typeof MessageV2.page>[0]): ReturnType<typeof MessageV2.page>
+  assertNotBusy(sessionID: Parameters<typeof SessionPrompt.assertNotBusy>[0]): ReturnType<typeof SessionPrompt.assertNotBusy>
+  removeMessage(input: Parameters<typeof Session.removeMessage>[0]): ReturnType<typeof Session.removeMessage>
+  removePart(input: Parameters<typeof Session.removePart>[0]): ReturnType<typeof Session.removePart>
+  updatePart(input: MessageV2.Part): Promise<MessageV2.Part>
+  prompt(input: SessionPrompt.PromptInput): ReturnType<typeof SessionPrompt.prompt>
+  promptAsync(input: SessionPrompt.PromptInput): Promise<void>
+  command(input: SessionPrompt.CommandInput): ReturnType<typeof SessionPrompt.command>
+  shell(input: SessionPrompt.ShellInput): ReturnType<typeof SessionPrompt.shell>
+  revert(input: Parameters<typeof SessionRevert.revert>[0]): ReturnType<typeof SessionRevert.revert>
+  unrevert(input: Parameters<typeof SessionRevert.unrevert>[0]): ReturnType<typeof SessionRevert.unrevert>
+}
+
+export type AgentPort = {
+  list(): Promise<Agent.Info[]>
+  default(): Promise<string>
+}
+
+export type SkillPort = {
+  list(): Promise<Skill.Info[]>
+}
+
+export type McpPort = {
+  status(): ReturnType<typeof MCP.status>
+}
+
+export type TransportPort = {
+  listen(input: Parameters<typeof Server.listen>[0]): Promise<Server.Listener>
+}
+
+export type RuntimePorts = {
+  session: SessionPort
+  agent: AgentPort
+  skill: SkillPort
+  mcp: McpPort
+  transport: TransportPort
+}

package/src/server/error.ts

@@ -0,0 +1,36 @@
+import { resolver } from "hono-openapi"
+import z from "zod"
+import { NotFoundError } from "../storage/db"
+
+export const ERRORS = {
+  400: {
+    description: "Bad request",
+    content: {
+      "application/json": {
+        schema: resolver(
+          z
+            .object({
+              data: z.any(),
+              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(NotFoundError.Schema),
+      },
+    },
+  },
+} as const
+
+export function errors(...codes: number[]) {
+  return Object.fromEntries(codes.map((code) => [code, ERRORS[code as keyof typeof ERRORS]]))
+}

package/src/server/event.ts

@@ -0,0 +1,7 @@
+import { BusEvent } from "@/bus/bus-event"
+import z from "zod"
+
+export const Event = {
+  Connected: BusEvent.define("server.connected", z.object({})),
+  Disposed: BusEvent.define("global.disposed", z.object({})),
+}

package/src/server/instance.ts

@@ -0,0 +1,322 @@
+import { describeRoute, resolver, validator } from "hono-openapi"
+import { Hono } from "hono"
+import { proxy } from "hono/proxy"
+import type { UpgradeWebSocket } from "hono/ws"
+import z from "zod"
+import { createHash } from "node:crypto"
+import * as fs from "node:fs/promises"
+import { Log } from "../util/log"
+import { Format } from "../format"
+import { TuiRoutes } from "./routes/tui"
+import { Instance } from "../project/instance"
+import { Vcs } from "../project/vcs"
+import { Global } from "../global"
+import { LSP } from "../lsp"
+import { Command } from "../command"
+import { Flag } from "../flag/flag"
+import { QuestionRoutes } from "./routes/question"
+import { PermissionRoutes } from "./routes/permission"
+import { Snapshot } from "@/snapshot"
+import { ProjectRoutes } from "./routes/project"
+import { SessionRoutes } from "./routes/session"
+import { PtyRoutes } from "./routes/pty"
+import { McpRoutes } from "./routes/mcp"
+import { FileRoutes } from "./routes/file"
+import { ConfigRoutes } from "./routes/config"
+import { ExperimentalRoutes } from "./routes/experimental"
+import { ProviderRoutes } from "./routes/provider"
+import { EventRoutes } from "./routes/event"
+import { errorHandler } from "./middleware"
+import { getMimeType } from "hono/utils/mime"
+import { RuntimeFactory } from "@/runtime/factory"
+import { Agent } from "@/agent/agent"
+import { Skill } from "@/skill"
+import { Site } from "@/url/site"
+
+const log = Log.create({ service: "server" })
+
+const embeddedUIPromise = Flag.IRODER_DISABLE_EMBEDDED_WEB_UI
+  ? Promise.resolve(null)
+  : // @ts-expect-error - generated file at build time
+    import("iroder-web-ui.gen.ts").then((module) => module.default as Record<string, string>).catch(() => null)
+
+const DEFAULT_CSP =
+  "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; media-src 'self' data:; connect-src 'self' data:"
+
+const csp = (hash = "") =>
+  `default-src 'self'; script-src 'self' 'wasm-unsafe-eval'${hash ? ` 'sha256-${hash}'` : ""}; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; media-src 'self' data:; connect-src 'self' data:`
+
+export const InstanceRoutes = (upgrade: UpgradeWebSocket, app: Hono = new Hono()) =>
+  app
+    .onError(errorHandler(log))
+    .route("/project", ProjectRoutes())
+    .route("/pty", PtyRoutes(upgrade))
+    .route("/config", ConfigRoutes())
+    .route("/experimental", ExperimentalRoutes())
+    .route("/session", SessionRoutes())
+    .route("/permission", PermissionRoutes())
+    .route("/question", QuestionRoutes())
+    .route("/provider", ProviderRoutes())
+    .route("/", FileRoutes())
+    .route("/", EventRoutes())
+    .route("/mcp", McpRoutes())
+    .route("/tui", TuiRoutes())
+    .post(
+      "/instance/dispose",
+      describeRoute({
+        summary: "Dispose instance",
+        description: "Clean up and dispose the current Iroder instance, releasing all resources.",
+        operationId: "instance.dispose",
+        responses: {
+          200: {
+            description: "Instance disposed",
+            content: {
+              "application/json": {
+                schema: resolver(z.boolean()),
+              },
+            },
+          },
+        },
+      }),
+      async (c) => {
+        await Instance.dispose()
+        return c.json(true)
+      },
+    )
+    .get(
+      "/path",
+      describeRoute({
+        summary: "Get paths",
+        description: "Retrieve the current working directory and related path information for the Iroder 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),
+              },
+            },
+          },
+        },
+      }),
+      async (c) => {
+        const [branch, default_branch] = await Promise.all([Vcs.branch(), Vcs.defaultBranch()])
+        return c.json({
+          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.array()),
+              },
+            },
+          },
+        },
+      }),
+      validator(
+        "query",
+        z.object({
+          mode: Vcs.Mode,
+        }),
+      ),
+      async (c) => {
+        return c.json(await Vcs.diff(c.req.valid("query").mode))
+      },
+    )
+    .get(
+      "/command",
+      describeRoute({
+        summary: "List commands",
+        description: "Get a list of all available commands in the Iroder system.",
+        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(
+      "/agent",
+      describeRoute({
+        summary: "List agents",
+        description: "Get a list of all available AI agents in the Iroder system.",
+        operationId: "app.agents",
+        responses: {
+          200: {
+            description: "List of agents",
+            content: {
+              "application/json": {
+                schema: resolver(Agent.Info.array()),
+              },
+            },
+          },
+        },
+      }),
+      async (c) => {
+        const modes = await RuntimeFactory.service().agent.list()
+        return c.json(modes)
+      },
+    )
+    .get(
+      "/skill",
+      describeRoute({
+        summary: "List skills",
+        description: "Get a list of all available skills in the Iroder system.",
+        operationId: "app.skills",
+        responses: {
+          200: {
+            description: "List of skills",
+            content: {
+              "application/json": {
+                schema: resolver(Skill.Info.array()),
+              },
+            },
+          },
+        },
+      }),
+      async (c) => {
+        const skills = await RuntimeFactory.service().skill.list()
+        return c.json(skills)
+      },
+    )
+    .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.array()),
+              },
+            },
+          },
+        },
+      }),
+      async (c) => {
+        return c.json(await 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.array()),
+              },
+            },
+          },
+        },
+      }),
+      async (c) => {
+        return c.json(await Format.status())
+      },
+    )
+    .all("/*", async (c) => {
+      const embeddedWebUI = await embeddedUIPromise
+      const path = c.req.path
+
+      if (embeddedWebUI) {
+        const match = embeddedWebUI[path.replace(/^\//, "")] ?? embeddedWebUI["index.html"] ?? null
+        if (!match) return c.json({ error: "Not Found" }, 404)
+
+        if (await fs.exists(match)) {
+          const mime = getMimeType(match) ?? "text/plain"
+          c.header("Content-Type", mime)
+          if (mime.startsWith("text/html")) {
+            c.header("Content-Security-Policy", DEFAULT_CSP)
+          }
+          return c.body(new Uint8Array(await fs.readFile(match)))
+        } else {
+          return c.json({ error: "Not Found" }, 404)
+        }
+      } else {
+        const web = Site.web()
+        const host = new URL(web).host
+        const response = await proxy(`${web}${path}`, {
+          ...c.req,
+          headers: {
+            ...c.req.raw.headers,
+            host,
+          },
+        })
+        const match = response.headers.get("content-type")?.includes("text/html")
+          ? (await response.clone().text()).match(
+              /<script\b(?![^>]*\bsrc\s*=)[^>]*\bid=(['"])oc-theme-preload-script\1[^>]*>([\s\S]*?)<\/script>/i,
+            )
+          : undefined
+        const hash = match ? createHash("sha256").update(match[2]).digest("base64") : ""
+        response.headers.set("Content-Security-Policy", csp(hash))
+        return response
+      }
+    })

package/src/server/mdns.ts

@@ -0,0 +1,60 @@
+import { Log } from "@/util/log"
+import { Bonjour } from "bonjour-service"
+
+const log = Log.create({ service: "mdns" })
+
+export namespace MDNS {
+  let bonjour: Bonjour | undefined
+  let currentPort: number | undefined
+
+  export function publish(port: number, domain?: string) {
+    if (currentPort === port) return
+    if (bonjour) unpublish()
+
+    try {
+      const host = domain ?? "iroder.local"
+      const name = `iroder-${port}`
+      bonjour = new Bonjour()
+      const service = bonjour.publish({
+        name,
+        type: "http",
+        host,
+        port,
+        txt: { path: "/" },
+      })
+
+      service.on("up", () => {
+        log.info("mDNS service published", { name, port })
+      })
+
+      service.on("error", (err) => {
+        log.error("mDNS service error", { error: err })
+      })
+
+      currentPort = port
+    } catch (err) {
+      log.error("mDNS publish failed", { error: err })
+      if (bonjour) {
+        try {
+          bonjour.destroy()
+        } catch {}
+      }
+      bonjour = undefined
+      currentPort = undefined
+    }
+  }
+
+  export function unpublish() {
+    if (bonjour) {
+      try {
+        bonjour.unpublishAll()
+        bonjour.destroy()
+      } catch (err) {
+        log.error("mDNS unpublish failed", { error: err })
+      }
+      bonjour = undefined
+      currentPort = undefined
+      log.info("mDNS service unpublished")
+    }
+  }
+}

package/src/server/middleware.ts

@@ -0,0 +1,33 @@
+import { Provider } from "../provider/provider"
+import { NamedError } from "@happy-creative/util/error"
+import { NotFoundError } from "../storage/db"
+import { Session } from "../session"
+import type { ContentfulStatusCode } from "hono/utils/http-status"
+import type { ErrorHandler } from "hono"
+import { HTTPException } from "hono/http-exception"
+import type { Log } from "../util/log"
+
+export function errorHandler(log: Log.Logger): ErrorHandler {
+  return (err, c) => {
+    log.error("failed", {
+      error: err,
+    })
+    if (err instanceof NamedError) {
+      let status: ContentfulStatusCode
+      if (err instanceof NotFoundError) status = 404
+      else if (err instanceof Provider.ModelNotFoundError) status = 400
+      else if (err.name === "ProviderAuthValidationFailed") status = 400
+      else if (err.name.startsWith("Worktree")) status = 400
+      else status = 500
+      return c.json(err.toObject(), { status })
+    }
+    if (err instanceof Session.BusyError) {
+      return c.json(new NamedError.Unknown({ message: err.message }).toObject(), { status: 400 })
+    }
+    if (err instanceof HTTPException) return err.getResponse()
+    const message = err instanceof Error && err.stack ? err.stack : err.toString()
+    return c.json(new NamedError.Unknown({ message }).toObject(), {
+      status: 500,
+    })
+  }
+}

package/src/server/projectors.ts

@@ -0,0 +1,28 @@
+import z from "zod"
+import sessionProjectors from "../session/projectors"
+import { SyncEvent } from "@/sync"
+import { Session } from "@/session"
+import { SessionTable } from "@/session/session.sql"
+import { Database, eq } from "@/storage/db"
+
+export function initProjectors() {
+  SyncEvent.init({
+    projectors: sessionProjectors,
+    convertEvent: (type, data) => {
+      if (type === "session.updated") {
+        const id = (data as z.infer<typeof Session.Event.Updated.schema>).sessionID
+        const row = Database.use((db) => db.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
+
+        if (!row) return data
+
+        return {
+          sessionID: id,
+          info: Session.fromRow(row),
+        }
+      }
+      return data
+    },
+  })
+}
+
+initProjectors()

package/src/server/proxy.ts

@@ -0,0 +1,134 @@
+import type { Target } from "@/control-plane/types"
+import { Hono } from "hono"
+import type { UpgradeWebSocket } from "hono/ws"
+
+const hop = new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "proxy-connection",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "host",
+])
+
+type Msg = string | ArrayBuffer | Uint8Array
+type RemoteTarget = Extract<Target, { type: "remote-http" | "remote-acp" }>
+
+function headers(req: Request, extra?: HeadersInit) {
+  const out = new Headers(req.headers)
+  for (const key of hop) out.delete(key)
+  out.delete("x-iroder-directory")
+  out.delete("x-iroder-workspace")
+  if (!extra) return out
+  for (const [key, value] of new Headers(extra).entries()) {
+    out.set(key, value)
+  }
+  return out
+}
+
+function protocols(req: Request) {
+  const value = req.headers.get("sec-websocket-protocol")
+  if (!value) return []
+  return value
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean)
+}
+
+function socket(url: string | URL) {
+  const next = new URL(url)
+  if (next.protocol === "http:") next.protocol = "ws:"
+  if (next.protocol === "https:") next.protocol = "wss:"
+  return next.toString()
+}
+
+function send(ws: { send(data: string | ArrayBuffer | Uint8Array): void }, data: any) {
+  if (data instanceof Blob) {
+    return data.arrayBuffer().then((x) => ws.send(x))
+  }
+  return ws.send(data)
+}
+
+const app = (upgrade: UpgradeWebSocket) =>
+  new Hono().get(
+    "/__workspace_ws",
+    upgrade((c) => {
+      const url = c.req.header("x-iroder-proxy-url")
+      const queue: Msg[] = []
+      let remote: WebSocket | undefined
+      return {
+        onOpen(_, ws) {
+          if (!url) {
+            ws.close(1011, "missing proxy target")
+            return
+          }
+          remote = new WebSocket(url, protocols(c.req.raw))
+          remote.binaryType = "arraybuffer"
+          remote.onopen = () => {
+            for (const item of queue) remote?.send(item)
+            queue.length = 0
+          }
+          remote.onmessage = (event) => {
+            send(ws, event.data)
+          }
+          remote.onerror = () => {
+            ws.close(1011, "proxy error")
+          }
+          remote.onclose = (event) => {
+            ws.close(event.code, event.reason)
+          }
+        },
+        onMessage(event) {
+          const data = event.data
+          if (typeof data !== "string" && !(data instanceof Uint8Array) && !(data instanceof ArrayBuffer)) return
+          if (remote?.readyState === WebSocket.OPEN) {
+            remote.send(data)
+            return
+          }
+          queue.push(data)
+        },
+        onClose(event) {
+          remote?.close(event.code, event.reason)
+        },
+      }
+    }),
+  )
+
+export namespace ServerProxy {
+  export function http(target: RemoteTarget, req: Request) {
+    return fetch(
+      new Request(target.url, {
+        method: req.method,
+        headers: headers(req, target.headers),
+        body: req.method === "GET" || req.method === "HEAD" ? undefined : req.body,
+        redirect: "manual",
+        signal: req.signal,
+      }),
+    )
+  }
+
+  export function websocket(
+    upgrade: UpgradeWebSocket,
+    target: RemoteTarget,
+    req: Request,
+    env: unknown,
+  ) {
+    const url = new URL(req.url)
+    url.pathname = "/__workspace_ws"
+    url.search = ""
+    const next = new Headers(req.headers)
+    next.set("x-iroder-proxy-url", socket(target.url))
+    return app(upgrade).fetch(
+      new Request(url, {
+        method: req.method,
+        headers: next,
+        signal: req.signal,
+      }),
+      env as never,
+    )
+  }
+}