airaknit 1.1.2-rc.9

package/src/server/events.ts

@@ -0,0 +1,379 @@
+import type { AgentProvider, IndependentWorkspace, ModelOptions, WorkspaceSummary, TranscriptEntry } from "../shared/types"
+import type { WorkspaceTodo, WorkspaceClaim, WorkspaceWorktree, WorkspaceRule } from "../shared/workspace-types"
+import type { AgentConfig, AgentConfigRecord } from "../shared/agent-config-types"
+import type { ProviderProfile, ProviderProfileRecord, WorkspaceProfileOverride } from "../shared/profile-types"
+import type { ExtensionPreference } from "../shared/extension-types"
+import type { TeamMember, RunnerLabelRecord } from "../shared/runner-team-types"
+import type { WorkflowRunState } from "../shared/workflow-types"
+import type { SandboxRecord, SandboxHealthReport, ResourceLimits } from "../shared/sandbox-types"
+
+export interface WorkspaceRecord extends WorkspaceSummary {
+  deletedAt?: number
+}
+
+export interface RepoRecord {
+  id: string
+  workspaceId: string
+  origin: string | null
+  localPath: string
+  label: string | null
+  status: "cloned" | "pending" | "error"
+  branch: string | null
+  createdAt: number
+  updatedAt: number
+}
+
+export interface ChatRecord {
+  id: string
+  workspaceId: string
+  repoId: string | null
+  title: string
+  createdAt: number
+  updatedAt: number
+  deletedAt?: number
+  unread: boolean
+  provider: AgentProvider | null
+  model?: string | null
+  planMode: boolean
+  sessionToken: string | null
+  lastMessageAt?: number
+  lastTurnOutcome: "success" | "failed" | "cancelled" | null
+  /** PR5: sticky runner pin. Absent on pre-PR5 chats → treated as no pin. */
+  runnerId?: string | null
+}
+
+export interface QueuedChatTurnRecord {
+  chatId: string
+  provider?: AgentProvider
+  content: string
+  model?: string
+  modelOptions?: ModelOptions
+  effort?: string
+  planMode?: boolean
+  updatedAt: number
+}
+
+export interface WorkspaceCoordinationState {
+  todos: Map<string, WorkspaceTodo>
+  claims: Map<string, WorkspaceClaim>
+  worktrees: Map<string, WorkspaceWorktree>
+  rules: Map<string, WorkspaceRule>
+  lastUpdated: string
+}
+
+export interface StoreState {
+  workspacesById: Map<string, WorkspaceRecord>
+  workspaceIdsByPath: Map<string, string>
+  independentWorkspacesById: Map<string, IndependentWorkspace>
+  chatsById: Map<string, ChatRecord>
+  queuedTurnsByChat: Map<string, QueuedChatTurnRecord>
+  coordinationByWorkspace: Map<string, WorkspaceCoordinationState>
+  agentConfigsByWorkspace: Map<string, Map<string, AgentConfigRecord>>
+  reposById: Map<string, RepoRecord>
+  reposByPath: Map<string, string>
+  workflowRunsByWorkspace: Map<string, Map<string, WorkflowRunState>>
+  sandboxByWorkspace: Map<string, SandboxRecord>
+  providerProfiles: Map<string, ProviderProfileRecord>
+  workspaceProfileOverrides: Map<string, Map<string, WorkspaceProfileOverride>>
+  extensionPreferences: Map<string, ExtensionPreference>
+  teamMembers: Map<string, TeamMember>
+  runnerLabels: Map<string, RunnerLabelRecord>
+}
+
+export function createEmptyCoordinationState(): WorkspaceCoordinationState {
+  return {
+    todos: new Map(),
+    claims: new Map(),
+    worktrees: new Map(),
+    rules: new Map(),
+    lastUpdated: new Date(0).toISOString(),
+  }
+}
+
+export interface SnapshotFile {
+  v: 2 | 3
+  generatedAt: number
+  workspaces: WorkspaceRecord[]
+  independentWorkspaces?: IndependentWorkspace[]
+  chats: ChatRecord[]
+  queuedTurns?: QueuedChatTurnRecord[]
+  messages?: Array<{ chatId: string; entries: TranscriptEntry[] }>
+  coordination?: Array<{ workspaceId: string; todos: WorkspaceTodo[]; claims: WorkspaceClaim[]; worktrees: WorkspaceWorktree[]; rules: WorkspaceRule[] }>
+  agentConfigs?: Array<{ workspaceId: string; records: AgentConfigRecord[] }>
+  repos?: RepoRecord[]
+  workflowRuns?: Array<{ workspaceId: string; runs: WorkflowRunState[] }>
+  sandboxes?: SandboxRecord[]
+  providerProfiles?: ProviderProfileRecord[]
+  workspaceProfileOverrides?: WorkspaceProfileOverride[]
+  extensionPreferences?: ExtensionPreference[]
+  teamMembers?: TeamMember[]
+  runnerLabels?: RunnerLabelRecord[]
+}
+
+export type WorkspaceEvent = {
+  v: 3
+  type: "workspace_opened"
+  timestamp: number
+  workspaceId: string
+  localPath: string
+  title: string
+} | {
+  v: 3
+  type: "workspace_removed"
+  timestamp: number
+  workspaceId: string
+} | {
+  v: 3
+  type: "independent_workspace_created"
+  timestamp: number
+  workspaceId: string
+  name: string
+} | {
+  v: 3
+  type: "independent_workspace_deleted"
+  timestamp: number
+  workspaceId: string
+} | {
+  v: 3
+  type: "independent_workspace_renamed"
+  timestamp: number
+  workspaceId: string
+  name: string
+} | {
+  v: 3
+  type: "independent_workspace_pin_toggled"
+  timestamp: number
+  workspaceId: string
+  pinned: boolean
+} | {
+  v: 3
+  type: "independent_workspaces_reordered"
+  timestamp: number
+  orderedWorkspaceIds: string[]
+}
+
+export type ChatEvent =
+  | {
+      v: 3
+      type: "chat_created"
+      timestamp: number
+      chatId: string
+      workspaceId: string
+      title: string
+      repoId?: string
+    }
+  | {
+      v: 3
+      type: "chat_renamed"
+      timestamp: number
+      chatId: string
+      title: string
+    }
+  | {
+      v: 3
+      type: "chat_deleted"
+      timestamp: number
+      chatId: string
+    }
+  | {
+      v: 3
+      type: "chat_provider_set"
+      timestamp: number
+      chatId: string
+      provider: AgentProvider
+    }
+  | {
+      v: 3
+      type: "chat_model_set"
+      timestamp: number
+      chatId: string
+      model: string | null
+    }
+  | {
+      v: 3
+      type: "chat_plan_mode_set"
+      timestamp: number
+      chatId: string
+      planMode: boolean
+    }
+  | {
+      v: 3
+      type: "chat_read_state_set"
+      timestamp: number
+      chatId: string
+      unread: boolean
+    }
+  | {
+      v: 3
+      type: "chat_runner_set"
+      timestamp: number
+      chatId: string
+      runnerId: string | null
+    }
+
+export type MessageEvent = {
+  v: 3
+  type: "message_appended"
+  timestamp: number
+  chatId: string
+  entry: TranscriptEntry
+}
+
+export type TurnEvent =
+  | {
+      v: 3
+      type: "turn_started"
+      timestamp: number
+      chatId: string
+    }
+  | {
+      v: 3
+      type: "turn_finished"
+      timestamp: number
+      chatId: string
+    }
+  | {
+      v: 3
+      type: "turn_failed"
+      timestamp: number
+      chatId: string
+      error: string
+    }
+  | {
+      v: 3
+      type: "turn_cancelled"
+      timestamp: number
+      chatId: string
+    }
+  | {
+      v: 3
+      type: "session_token_set"
+      timestamp: number
+      chatId: string
+      sessionToken: string | null
+    }
+  | {
+      v: 3
+      type: "chat_turn_queued"
+      timestamp: number
+      chatId: string
+      provider?: AgentProvider
+      content: string
+      model?: string
+      modelOptions?: ModelOptions
+      effort?: string
+      planMode?: boolean
+    }
+  | {
+      v: 3
+      type: "chat_queued_turn_cleared"
+      timestamp: number
+      chatId: string
+    }
+  | {
+      v: 3
+      type: "delegation_initiated"
+      timestamp: number
+      delegationId: string
+      parentChatId: string
+      childChatId: string
+      workspaceId: string
+      mode: "blocking" | "background"
+      resume: "immediate" | "gate"
+    }
+  | {
+      v: 3
+      type: "delegation_completed"
+      timestamp: number
+      delegationId: string
+      parentChatId: string
+      childChatId: string
+      workspaceId: string
+      outcome: "completed" | "failed" | "orphaned" | "stale"
+    }
+
+export type CoordinationEvent =
+  | { v: 3; type: "todo_added"; timestamp: number; workspaceId: string; todoId: string; description: string; priority: "high" | "normal" | "low"; createdBy: string }
+  | { v: 3; type: "todo_claimed"; timestamp: number; workspaceId: string; todoId: string; claimedBy: string }
+  | { v: 3; type: "todo_completed"; timestamp: number; workspaceId: string; todoId: string; outputs: string[] }
+  | { v: 3; type: "todo_abandoned"; timestamp: number; workspaceId: string; todoId: string }
+  | { v: 3; type: "claim_created"; timestamp: number; workspaceId: string; claimId: string; intent: string; files: string[]; sessionId: string }
+  | { v: 3; type: "claim_released"; timestamp: number; workspaceId: string; claimId: string }
+  | { v: 3; type: "claim_conflict_detected"; timestamp: number; workspaceId: string; claimId: string; conflictsWith: string; overlappingFiles: string[] }
+  | { v: 3; type: "worktree_created"; timestamp: number; workspaceId: string; worktreeId: string; branch: string; baseBranch: string; path: string }
+  | { v: 3; type: "worktree_assigned"; timestamp: number; workspaceId: string; worktreeId: string; sessionId: string }
+  | { v: 3; type: "worktree_removed"; timestamp: number; workspaceId: string; worktreeId: string }
+  | { v: 3; type: "rule_set"; timestamp: number; workspaceId: string; ruleId: string; content: string; setBy: string }
+  | { v: 3; type: "rule_removed"; timestamp: number; workspaceId: string; ruleId: string }
+
+export type RepoEvent =
+  | { v: 3; type: "repo_added"; timestamp: number; id: string; workspaceId: string; localPath: string; origin: string | null; label: string | null; branch: string | null }
+  | { v: 3; type: "repo_clone_started"; timestamp: number; id: string; workspaceId: string; origin: string; targetPath: string; label: string | null }
+  | { v: 3; type: "repo_cloned"; timestamp: number; id: string; localPath: string; branch: string | null }
+  | { v: 3; type: "repo_clone_failed"; timestamp: number; id: string; error: string }
+  | { v: 3; type: "repo_removed"; timestamp: number; id: string; workspaceId: string }
+  | { v: 3; type: "repo_label_updated"; timestamp: number; id: string; label: string }
+
+export type AgentConfigEvent =
+  | { v: 3; type: "agent_config_saved"; timestamp: number; workspaceId: string; agentId: string; config: AgentConfig }
+  | { v: 3; type: "agent_config_committed"; timestamp: number; workspaceId: string; agentId: string; commitHash: string }
+  | { v: 3; type: "agent_config_removed"; timestamp: number; workspaceId: string; agentId: string }
+
+export type WorkflowEvent =
+  | { v: 3; type: "workflow_started"; timestamp: number; runId: string; workflowId: string; workspaceId: string; targetRepoIds: string[]; triggeredBy: string }
+  | { v: 3; type: "workflow_step_started"; timestamp: number; runId: string; workspaceId: string; stepIndex: number; mcp_tool: string; repoId?: string }
+  | { v: 3; type: "workflow_step_completed"; timestamp: number; runId: string; workspaceId: string; stepIndex: number; repoId?: string; output: string }
+  | { v: 3; type: "workflow_step_failed"; timestamp: number; runId: string; workspaceId: string; stepIndex: number; repoId?: string; error: string }
+  | { v: 3; type: "workflow_completed"; timestamp: number; runId: string; workspaceId: string }
+  | { v: 3; type: "workflow_failed"; timestamp: number; runId: string; workspaceId: string; error: string; failedStep: number }
+  | { v: 3; type: "workflow_cancelled"; timestamp: number; runId: string; workspaceId: string }
+
+export type SandboxEvent =
+  | { v: 3; type: "sandbox_created"; timestamp: number; id: string; workspaceId: string; resourceLimits: ResourceLimits }
+  | { v: 3; type: "sandbox_started"; timestamp: number; id: string; containerId: string; natsUrl: string }
+  | { v: 3; type: "sandbox_stopped"; timestamp: number; id: string; reason: string }
+  | { v: 3; type: "sandbox_destroyed"; timestamp: number; id: string }
+  | { v: 3; type: "sandbox_error"; timestamp: number; id: string; error: string }
+  | { v: 3; type: "sandbox_health_updated"; timestamp: number; id: string; health: SandboxHealthReport }
+
+export type ProviderProfileEvent =
+  | { v: 3; type: "provider_profile_saved"; timestamp: number; profileId: string; profile: ProviderProfile }
+  | { v: 3; type: "provider_profile_removed"; timestamp: number; profileId: string }
+  | { v: 3; type: "workspace_profile_override_set"; timestamp: number; workspaceId: string; profileId: string; overrides: Partial<Omit<ProviderProfile, "id" | "provider">> }
+  | { v: 3; type: "workspace_profile_override_removed"; timestamp: number; workspaceId: string; profileId: string }
+
+export type ExtensionPreferenceEvent =
+  | { v: 3; type: "extension_preference_set"; timestamp: number; extensionId: string; enabled: boolean }
+
+export type RunnerTeamEvent =
+  | { v: 3; type: "team_member_saved"; timestamp: number; memberId: string; member: TeamMember }
+  | { v: 3; type: "team_member_removed"; timestamp: number; memberId: string }
+  | { v: 3; type: "runner_label_set"; timestamp: number; runnerId: string; name: string | null; memberId: string | null }
+  | { v: 3; type: "runner_label_removed"; timestamp: number; runnerId: string }
+
+export type StoreEvent = WorkspaceEvent | ChatEvent | MessageEvent | TurnEvent | CoordinationEvent | RepoEvent | AgentConfigEvent | WorkflowEvent | SandboxEvent | ProviderProfileEvent | ExtensionPreferenceEvent | RunnerTeamEvent
+
+export function createEmptyState(): StoreState {
+  return {
+    workspacesById: new Map(),
+    workspaceIdsByPath: new Map(),
+    independentWorkspacesById: new Map(),
+    chatsById: new Map(),
+    queuedTurnsByChat: new Map(),
+    coordinationByWorkspace: new Map(),
+    agentConfigsByWorkspace: new Map(),
+    reposById: new Map(),
+    reposByPath: new Map(),
+    workflowRunsByWorkspace: new Map(),
+    sandboxByWorkspace: new Map(),
+    providerProfiles: new Map(),
+    workspaceProfileOverrides: new Map(),
+    extensionPreferences: new Map(),
+    teamMembers: new Map(),
+    runnerLabels: new Map(),
+  }
+}
+
+export function cloneTranscriptEntries(entries: TranscriptEntry[]): TranscriptEntry[] {
+  return entries.map((entry) => ({ ...entry }))
+}

package/src/server/extension-router.test.ts

@@ -0,0 +1,183 @@
+import { describe, test, expect, afterEach } from "bun:test"
+import { mkdtemp, rm, mkdir } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { createExtensionRouter } from "./extension-router"
+import type { ServerExtension, DetectionResult } from "../shared/extension-types"
+
+let tempDirs: string[] = []
+
+afterEach(async () => {
+  for (const d of tempDirs) await rm(d, { recursive: true, force: true })
+  tempDirs = []
+})
+
+async function makeTempDir(): Promise<string> {
+  const dir = await mkdtemp(path.join(tmpdir(), "ext-router-test-"))
+  tempDirs.push(dir)
+  return dir
+}
+
+/** Minimal c3 extension stub for testing */
+function makeC3Extension(overrides?: Partial<ServerExtension>): ServerExtension {
+  return {
+    id: "c3",
+    name: "C3 Docs",
+    icon: "book",
+    detect: [".c3/"],
+    routes(ctx) {
+      return [
+        {
+          method: "GET",
+          path: "/list",
+          handler: async (_req, _params) =>
+            new Response(JSON.stringify({ items: [], projectPath: ctx.projectPath }), {
+              headers: { "Content-Type": "application/json" },
+            }),
+        },
+        {
+          method: "GET",
+          path: "/read/:id",
+          handler: async (_req, params) =>
+            new Response(JSON.stringify({ id: params.id, projectPath: ctx.projectPath }), {
+              headers: { "Content-Type": "application/json" },
+            }),
+        },
+        {
+          method: "POST",
+          path: "/write",
+          handler: async (req, _params) => {
+            const body = await req.json()
+            return new Response(JSON.stringify({ ok: true, body }), {
+              headers: { "Content-Type": "application/json" },
+            })
+          },
+        },
+      ]
+    },
+    ...overrides,
+  }
+}
+
+describe("extension-router", () => {
+  describe("GET /api/ext/detect", () => {
+    test("detects extensions when probe files exist", async () => {
+      const dir = await makeTempDir()
+      await mkdir(path.join(dir, ".c3"), { recursive: true })
+
+      const router = createExtensionRouter([makeC3Extension()])
+      const req = new Request(`http://localhost/api/ext/detect?projectPath=${encodeURIComponent(dir)}`)
+      const res = await router(req)
+
+      expect(res.status).toBe(200)
+      const body: DetectionResult[] = await res.json()
+      expect(body).toHaveLength(1)
+      expect(body[0].extensionId).toBe("c3")
+      expect(body[0].detected).toBe(true)
+    })
+
+    test("returns detected:false for empty directory", async () => {
+      const dir = await makeTempDir()
+
+      const router = createExtensionRouter([makeC3Extension()])
+      const req = new Request(`http://localhost/api/ext/detect?projectPath=${encodeURIComponent(dir)}`)
+      const res = await router(req)
+
+      expect(res.status).toBe(200)
+      const body: DetectionResult[] = await res.json()
+      expect(body).toHaveLength(1)
+      expect(body[0].extensionId).toBe("c3")
+      expect(body[0].detected).toBe(false)
+    })
+
+    test("returns 400 when projectPath is missing", async () => {
+      const router = createExtensionRouter([makeC3Extension()])
+      const req = new Request("http://localhost/api/ext/detect")
+      const res = await router(req)
+
+      expect(res.status).toBe(400)
+      const body = await res.json()
+      expect(body.error).toBeDefined()
+    })
+  })
+
+  describe("extension route dispatch", () => {
+    test("GET dispatches to correct extension handler", async () => {
+      const dir = await makeTempDir()
+      const router = createExtensionRouter([makeC3Extension()])
+      const req = new Request(`http://localhost/api/ext/c3/list?projectPath=${encodeURIComponent(dir)}`)
+      const res = await router(req)
+
+      expect(res.status).toBe(200)
+      const body = await res.json()
+      expect(body.items).toEqual([])
+      expect(body.projectPath).toBe(dir)
+    })
+
+    test("GET with path params dispatches correctly", async () => {
+      const dir = await makeTempDir()
+      const router = createExtensionRouter([makeC3Extension()])
+      const req = new Request(`http://localhost/api/ext/c3/read/c3-101?projectPath=${encodeURIComponent(dir)}`)
+      const res = await router(req)
+
+      expect(res.status).toBe(200)
+      const body = await res.json()
+      expect(body.id).toBe("c3-101")
+      expect(body.projectPath).toBe(dir)
+    })
+
+    test("POST route match works", async () => {
+      const dir = await makeTempDir()
+      const router = createExtensionRouter([makeC3Extension()])
+      const req = new Request(`http://localhost/api/ext/c3/write?projectPath=${encodeURIComponent(dir)}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ content: "hello" }),
+      })
+      const res = await router(req)
+
+      expect(res.status).toBe(200)
+      const body = await res.json()
+      expect(body.ok).toBe(true)
+      expect(body.body.content).toBe("hello")
+    })
+
+    test("returns 404 for unknown extension ID", async () => {
+      const dir = await makeTempDir()
+      const router = createExtensionRouter([makeC3Extension()])
+      const req = new Request(`http://localhost/api/ext/unknown/list?projectPath=${encodeURIComponent(dir)}`)
+      const res = await router(req)
+
+      expect(res.status).toBe(404)
+      const body = await res.json()
+      expect(body.error).toBeDefined()
+    })
+
+    test("returns 400 when projectPath is missing on extension route", async () => {
+      const router = createExtensionRouter([makeC3Extension()])
+      const req = new Request("http://localhost/api/ext/c3/list")
+      const res = await router(req)
+
+      expect(res.status).toBe(400)
+    })
+
+    test("returns 404 for method mismatch (GET on POST-only route)", async () => {
+      const dir = await makeTempDir()
+      const router = createExtensionRouter([makeC3Extension()])
+      // /write is POST-only, try GET
+      const req = new Request(`http://localhost/api/ext/c3/write?projectPath=${encodeURIComponent(dir)}`)
+      const res = await router(req)
+
+      expect(res.status).toBe(404)
+    })
+
+    test("returns 404 for route not defined on extension", async () => {
+      const dir = await makeTempDir()
+      const router = createExtensionRouter([makeC3Extension()])
+      const req = new Request(`http://localhost/api/ext/c3/nonexistent?projectPath=${encodeURIComponent(dir)}`)
+      const res = await router(req)
+
+      expect(res.status).toBe(404)
+    })
+  })
+})

package/src/server/extension-router.ts

@@ -0,0 +1,114 @@
+import { exists } from "node:fs/promises"
+import path from "node:path"
+import type { ServerExtension, DetectionResult } from "../shared/extension-types"
+
+function jsonResponse(data: unknown, status = 200): Response {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  })
+}
+
+function errorResponse(error: string, code: number, detail?: string): Response {
+  return jsonResponse({ error, code, detail }, code)
+}
+
+/** Match a route pattern (e.g. `/read/:id`) against a request path (e.g. `/read/c3-101`) */
+function matchRoute(
+  pattern: string,
+  requestPath: string,
+): Record<string, string> | null {
+  const patternParts = pattern.split("/").filter(Boolean)
+  const requestParts = requestPath.split("/").filter(Boolean)
+
+  if (patternParts.length !== requestParts.length) return null
+
+  const params: Record<string, string> = {}
+  for (let i = 0; i < patternParts.length; i++) {
+    const pat = patternParts[i]
+    const req = requestParts[i]
+    if (pat.startsWith(":")) {
+      params[pat.slice(1)] = req
+    } else if (pat !== req) {
+      return null
+    }
+  }
+  return params
+}
+
+async function detectExtension(
+  ext: ServerExtension,
+  projectPath: string,
+): Promise<DetectionResult> {
+  let detected = false
+  for (const probe of ext.detect) {
+    const probePath = path.join(projectPath, probe)
+    if (await exists(probePath)) {
+      detected = true
+      break
+    }
+  }
+  return {
+    extensionId: ext.id,
+    name: ext.name,
+    icon: ext.icon,
+    detected,
+  }
+}
+
+export function createExtensionRouter(
+  extensions: ServerExtension[],
+): (req: Request) => Promise<Response> {
+  const extensionMap = new Map<string, ServerExtension>()
+  for (const ext of extensions) {
+    extensionMap.set(ext.id, ext)
+  }
+
+  return async (req: Request): Promise<Response> => {
+    const url = new URL(req.url)
+    const fullPath = url.pathname.replace(/^\/api\/ext/, "")
+
+    // GET /api/ext/detect?projectPath=...
+    if (req.method === "GET" && fullPath === "/detect") {
+      const projectPath = url.searchParams.get("projectPath")
+      if (!projectPath) {
+        return errorResponse("Missing 'projectPath' query parameter", 400)
+      }
+
+      const results = await Promise.all(
+        extensions.map((ext) => detectExtension(ext, projectPath)),
+      )
+      return jsonResponse(results)
+    }
+
+    // Extension route dispatch: /api/ext/:extensionId/...
+    const segments = fullPath.split("/").filter(Boolean)
+    if (segments.length < 2) {
+      return errorResponse("Not found", 404)
+    }
+
+    const extensionId = segments[0]
+    const routePath = "/" + segments.slice(1).join("/")
+
+    const projectPath = url.searchParams.get("projectPath")
+    if (!projectPath) {
+      return errorResponse("Missing 'projectPath' query parameter", 400)
+    }
+
+    const ext = extensionMap.get(extensionId)
+    if (!ext) {
+      return errorResponse(`Extension '${extensionId}' not found`, 404)
+    }
+
+    const routes = ext.routes({ projectPath })
+    for (const route of routes) {
+      if (route.method !== req.method) continue
+      const params = matchRoute(route.path, routePath)
+      if (params !== null) {
+        return route.handler(req, params)
+      }
+    }
+
+    return errorResponse("Not found", 404)
+  }
+}