@happy-creative/iroder 1.0.0

package/src/server/router.ts

@@ -0,0 +1,161 @@
+import type { MiddlewareHandler } from "hono"
+import type { UpgradeWebSocket } from "hono/ws"
+import { getAdaptor } from "@/control-plane/adaptors"
+import { WorkspaceID } from "@/control-plane/schema"
+import { Workspace } from "@/control-plane/workspace"
+import { ServerProxy } from "./proxy"
+import { lazy } from "@/util/lazy"
+import { Filesystem } from "@/util/filesystem"
+import { Instance } from "@/project/instance"
+import { InstanceBootstrap } from "@/project/bootstrap"
+import { InstanceRoutes } from "./instance"
+import type { Target } from "@/control-plane/types"
+
+type Rule = { method?: string; path: string; exact?: boolean; action: "local" | "forward" }
+
+const RULES: Array<Rule> = [
+  { path: "/session/status", action: "forward" },
+  { method: "GET", path: "/session", action: "local" },
+]
+
+function local(method: string, path: string) {
+  for (const rule of RULES) {
+    if (rule.method && rule.method !== method) continue
+    const match = rule.exact ? path === rule.path : path === rule.path || path.startsWith(rule.path + "/")
+    if (match) return rule.action === "local"
+  }
+  return false
+}
+
+export function matchRemoteHost(host: string, rule: string) {
+  if (rule === "*") return true
+  if (rule.startsWith("*.")) {
+    const root = rule.slice(2)
+    return host === root || host.endsWith(`.${root}`)
+  }
+  return host === rule
+}
+
+export function allowRemoteTarget(target: Exclude<Target, { type: "local" }>) {
+  const value = process.env.IRODER_REMOTE_WHITELIST ?? ""
+  const list = value
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean)
+  if (list.length === 0) return false
+  const host = new URL(String(target.url)).hostname
+  return list.some((item) => matchRemoteHost(host, item))
+}
+
+function requireRemoteAuth() {
+  const value = (process.env.IRODER_REMOTE_REQUIRE_AUTH ?? "1").toLowerCase()
+  return value !== "0" && value !== "false"
+}
+
+export function hasRemoteAuth(input: { target: Exclude<Target, { type: "local" }>; authorization?: string; token?: string }) {
+  const base = new Headers(input.target.headers).get("authorization")
+  return Boolean(base || input.authorization || input.token)
+}
+
+export function WorkspaceRouterMiddleware(upgrade: UpgradeWebSocket): MiddlewareHandler {
+  const routes = lazy(() => InstanceRoutes(upgrade))
+
+  return async (c) => {
+    const raw = c.req.query("directory") || c.req.header("x-iroder-directory") || process.cwd()
+    const directory = Filesystem.resolve(
+      (() => {
+        try {
+          return decodeURIComponent(raw)
+        } catch {
+          return raw
+        }
+      })(),
+    )
+
+    const url = new URL(c.req.url)
+    const workspaceParam = url.searchParams.get("workspace") || c.req.header("x-iroder-workspace")
+
+    // TODO: If session is being routed, force it to lookup the
+    // project/workspace
+
+    // If no workspace is provided we use the "project" workspace
+    if (!workspaceParam) {
+      return Instance.provide({
+        directory,
+        init: InstanceBootstrap,
+        async fn() {
+          return routes().fetch(c.req.raw, c.env)
+        },
+      })
+    }
+
+    const workspaceID = WorkspaceID.make(workspaceParam)
+    const workspace = await Workspace.get(workspaceID)
+    if (!workspace) {
+      return new Response(`Workspace not found: ${workspaceID}`, {
+        status: 500,
+        headers: {
+          "content-type": "text/plain; charset=utf-8",
+        },
+      })
+    }
+
+    const adaptor = await getAdaptor(workspace.type)
+    const target = await adaptor.target(workspace)
+
+    if (target.type === "local") {
+      return Instance.provide({
+        directory: target.directory,
+        init: InstanceBootstrap,
+        async fn() {
+          return routes().fetch(c.req.raw, c.env)
+        },
+      })
+    }
+
+    if (local(c.req.method, url.pathname)) {
+      // No instance provided because we are serving cached data; there
+      // is no instance to work with
+      return routes().fetch(c.req.raw, c.env)
+    }
+
+    if (!allowRemoteTarget(target)) {
+      return new Response("Remote workspace target blocked by whitelist", {
+        status: 403,
+        headers: {
+          "content-type": "text/plain; charset=utf-8",
+        },
+      })
+    }
+
+    if (
+      requireRemoteAuth() &&
+      !hasRemoteAuth({
+        target,
+        authorization: c.req.header("authorization"),
+        token: c.req.query("auth_token"),
+      })
+    ) {
+      return new Response("Remote workspace target blocked by auth policy", {
+        status: 401,
+        headers: {
+          "content-type": "text/plain; charset=utf-8",
+        },
+      })
+    }
+
+    if (c.req.header("upgrade")?.toLowerCase() === "websocket") {
+      return ServerProxy.websocket(upgrade, target, c.req.raw, c.env)
+    }
+
+    const headers = new Headers(c.req.raw.headers)
+    headers.delete("x-iroder-workspace")
+
+    return ServerProxy.http(
+      target,
+      new Request(c.req.raw, {
+        headers,
+      }),
+    )
+  }
+}

package/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 Iroder 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 Iroder 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),
+        })
+      },
+    ),
+)

package/src/server/routes/event.ts

@@ -0,0 +1,83 @@
+import { Hono } from "hono"
+import { describeRoute, resolver } from "hono-openapi"
+import { streamSSE } from "hono/streaming"
+import { Log } from "@/util/log"
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import { AsyncQueue } from "../../util/queue"
+
+const log = Log.create({ service: "server" })
+
+export const EventRoutes = () =>
+  new Hono().get(
+    "/event",
+    describeRoute({
+      summary: "Subscribe to events",
+      description: "Get events",
+      operationId: "event.subscribe",
+      responses: {
+        200: {
+          description: "Event stream",
+          content: {
+            "text/event-stream": {
+              schema: resolver(BusEvent.payloads()),
+            },
+          },
+        },
+      },
+    }),
+    async (c) => {
+      log.info("event connected")
+      c.header("Cache-Control", "no-cache, no-transform")
+      c.header("X-Accel-Buffering", "no")
+      c.header("X-Content-Type-Options", "nosniff")
+      return streamSSE(c, async (stream) => {
+        const q = new AsyncQueue<string | null>()
+        let done = false
+
+        q.push(
+          JSON.stringify({
+            type: "server.connected",
+            properties: {},
+          }),
+        )
+
+        // Send heartbeat every 10s to prevent stalled proxy streams.
+        const heartbeat = setInterval(() => {
+          q.push(
+            JSON.stringify({
+              type: "server.heartbeat",
+              properties: {},
+            }),
+          )
+        }, 10_000)
+
+        const stop = () => {
+          if (done) return
+          done = true
+          clearInterval(heartbeat)
+          unsub()
+          q.push(null)
+          log.info("event disconnected")
+        }
+
+        const unsub = Bus.subscribeAll((event) => {
+          q.push(JSON.stringify(event))
+          if (event.type === Bus.InstanceDisposed.type) {
+            stop()
+          }
+        })
+
+        stream.onAbort(stop)
+
+        try {
+          for await (const data of q) {
+            if (data === null) return
+            await stream.writeSSE({ data })
+          }
+        } finally {
+          stop()
+        }
+      })
+    },
+  )