@miaws/miaw 1.18.4 → 1.18.5

package/src/server/routes/instance/httpapi/groups/file.ts

@@ -0,0 +1,185 @@
+import { FileSystem } from "@miaw/core/filesystem"
+import { NonNegativeInt } from "@miaw/core/schema"
+import { LSP } from "@/lsp/lsp"
+import { Schema } from "effect"
+import { HttpApi, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
+import { Authorization } from "../middleware/authorization"
+import { InstanceContextMiddleware } from "../middleware/instance-context"
+import {
+  WorkspaceRoutingMiddleware,
+  WorkspaceRoutingQuery,
+  WorkspaceRoutingQueryFields,
+} from "../middleware/workspace-routing"
+import { described } from "./metadata"
+
+export const FileQuery = Schema.Struct({
+  ...WorkspaceRoutingQueryFields,
+  path: Schema.String,
+})
+
+export const FindTextQuery = Schema.Struct({
+  ...WorkspaceRoutingQueryFields,
+  pattern: Schema.String,
+})
+
+export const FindFileQuery = Schema.Struct({
+  ...WorkspaceRoutingQueryFields,
+  query: Schema.String,
+  dirs: Schema.optional(Schema.Literals(["true", "false"])),
+  type: Schema.optional(Schema.Literals(["file", "directory"])),
+  limit: Schema.optional(
+    Schema.NumberFromString.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(200)),
+  ),
+})
+
+export const FindSymbolQuery = Schema.Struct({
+  ...WorkspaceRoutingQueryFields,
+  query: Schema.String,
+})
+
+export const LegacyMatch = Schema.Struct({
+  path: Schema.Struct({ text: Schema.String }),
+  lines: Schema.Struct({ text: Schema.String }),
+  line_number: NonNegativeInt,
+  absolute_offset: NonNegativeInt,
+  submatches: Schema.Array(
+    Schema.Struct({
+      match: Schema.Struct({ text: Schema.String }),
+      start: NonNegativeInt,
+      end: NonNegativeInt,
+    }),
+  ),
+})
+
+export const LegacyEntry = Schema.Struct({
+  name: Schema.String,
+  path: Schema.String,
+  absolute: Schema.String,
+  type: Schema.Literals(["file", "directory"]),
+  ignored: Schema.Boolean,
+}).annotate({ identifier: "FileNode" })
+
+export const LegacyContent = Schema.Struct({
+  type: Schema.Literals(["text", "binary"]),
+  content: Schema.String,
+  diff: Schema.optional(Schema.String),
+  patch: Schema.optional(
+    Schema.Struct({
+      oldFileName: Schema.String,
+      newFileName: Schema.String,
+      oldHeader: Schema.optional(Schema.String),
+      newHeader: Schema.optional(Schema.String),
+      hunks: Schema.Array(
+        Schema.Struct({
+          oldStart: NonNegativeInt,
+          oldLines: NonNegativeInt,
+          newStart: NonNegativeInt,
+          newLines: NonNegativeInt,
+          lines: Schema.Array(Schema.String),
+        }),
+      ),
+      index: Schema.optional(Schema.String),
+    }),
+  ),
+  encoding: Schema.optional(Schema.Literal("base64")),
+  mimeType: Schema.optional(Schema.String),
+}).annotate({ identifier: "FileContent" })
+
+export const LegacyStatus = Schema.Struct({
+  path: Schema.String,
+  added: NonNegativeInt,
+  removed: NonNegativeInt,
+  status: Schema.Literals(["added", "deleted", "modified"]),
+}).annotate({ identifier: "File" })
+
+export const FilePaths = {
+  findText: "/find",
+  findFile: "/find/file",
+  findSymbol: "/find/symbol",
+  list: "/file",
+  content: "/file/content",
+  status: "/file/status",
+} as const
+
+export const FileApi = HttpApi.make("file")
+  .add(
+    HttpApiGroup.make("file")
+      .add(
+        HttpApiEndpoint.get("findText", FilePaths.findText, {
+          query: FindTextQuery,
+          success: described(Schema.Array(LegacyMatch), "Matches"),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "find.text",
+            summary: "Find text",
+            description: "Search for text patterns across files in the project using ripgrep.",
+          }),
+        ),
+        HttpApiEndpoint.get("findFile", FilePaths.findFile, {
+          query: FindFileQuery,
+          success: described(Schema.Array(Schema.String), "File paths"),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "find.files",
+            summary: "Find files",
+            description: "Search for files or directories by name or pattern in the project directory.",
+          }),
+        ),
+        HttpApiEndpoint.get("findSymbol", FilePaths.findSymbol, {
+          query: FindSymbolQuery,
+          success: described(Schema.Array(LSP.Symbol), "Symbols"),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "find.symbols",
+            summary: "Find symbols",
+            description: "Search for workspace symbols like functions, classes, and variables using LSP.",
+          }),
+        ),
+        HttpApiEndpoint.get("list", FilePaths.list, {
+          query: FileQuery,
+          success: described(Schema.Array(LegacyEntry), "Files and directories"),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "file.list",
+            summary: "List files",
+            description: "List files and directories in a specified path.",
+          }),
+        ),
+        HttpApiEndpoint.get("content", FilePaths.content, {
+          query: FileQuery,
+          success: described(LegacyContent, "File content"),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "file.read",
+            summary: "Read file",
+            description: "Read the content of a specified file.",
+          }),
+        ),
+        HttpApiEndpoint.get("status", FilePaths.status, {
+          query: WorkspaceRoutingQuery,
+          success: described(Schema.Array(LegacyStatus), "File status"),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "file.status",
+            summary: "Get file status",
+            description: "Get the git status of all files in the project.",
+          }),
+        ),
+      )
+      .annotateMerge(
+        OpenApi.annotations({
+          title: "file",
+          description: "Experimental HttpApi file routes.",
+        }),
+      )
+      .middleware(InstanceContextMiddleware)
+      .middleware(WorkspaceRoutingMiddleware)
+      .middleware(Authorization),
+  )
+  .annotateMerge(
+    OpenApi.annotations({
+      title: "miaw experimental HttpApi",
+      version: "0.0.1",
+      description: "Experimental HttpApi surface for selected instance routes.",
+    }),
+  )

package/src/server/routes/instance/httpapi/groups/global.ts

@@ -0,0 +1,138 @@
+import { Config } from "@/config/config"
+import { ConfigV1 } from "@miaw/core/v1/config/config"
+import { EventV2 } from "@miaw/core/event"
+import { InstanceDisposed } from "@/server/event"
+import "@miaw/core/account"
+import "@/server/event"
+import { Schema } from "effect"
+import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
+import { described } from "./metadata"
+
+const GlobalHealth = Schema.Struct({
+  healthy: Schema.Literal(true),
+  version: Schema.String,
+})
+
+const SyncEventSchemas = EventV2.registry
+  .values()
+  .flatMap((definition) => {
+    if (!definition.sync) return []
+    return [
+      Schema.Struct({
+        type: Schema.Literal("sync"),
+        id: EventV2.ID,
+        syncEvent: Schema.Struct({
+          type: Schema.Literal(EventV2.versionedType(definition.type, definition.sync.version)),
+          id: EventV2.ID,
+          seq: Schema.Finite,
+          aggregateID: Schema.String,
+          data: definition.data,
+        }),
+      }).annotate({ identifier: `SyncEvent.${definition.type}` }),
+    ]
+  })
+  .toArray()
+
+const GlobalEventSchema = Schema.Struct({
+  directory: Schema.String,
+  project: Schema.optional(Schema.String),
+  workspace: Schema.optional(Schema.String),
+  payload: Schema.Union([
+    ...EventV2.registry
+      .values()
+      .map((definition) =>
+        Schema.Struct({ id: EventV2.ID, type: Schema.Literal(definition.type), properties: definition.data }),
+      )
+      .toArray(),
+    InstanceDisposed,
+    ...SyncEventSchemas,
+  ]),
+}).annotate({ identifier: "GlobalEvent" })
+
+export const GlobalUpgradeInput = Schema.Struct({
+  target: Schema.optional(Schema.String),
+})
+
+const GlobalUpgradeResult = Schema.Union([
+  Schema.Struct({
+    success: Schema.Literal(true),
+    version: Schema.String,
+  }),
+  Schema.Struct({
+    success: Schema.Literal(false),
+    error: Schema.String,
+  }),
+])
+
+export const GlobalPaths = {
+  health: "/global/health",
+  event: "/global/event",
+  config: "/global/config",
+  dispose: "/global/dispose",
+  upgrade: "/global/upgrade",
+} as const
+
+export const GlobalApi = HttpApi.make("global").add(
+  HttpApiGroup.make("global")
+    .add(
+      HttpApiEndpoint.get("health", GlobalPaths.health, {
+        success: described(GlobalHealth, "Health information"),
+      }).annotateMerge(
+        OpenApi.annotations({
+          identifier: "global.health",
+          summary: "Get health",
+          description: "Get health information about the Miaw server.",
+        }),
+      ),
+      HttpApiEndpoint.get("event", GlobalPaths.event, {
+        success: GlobalEventSchema,
+      }).annotateMerge(
+        OpenApi.annotations({
+          identifier: "global.event",
+          summary: "Get global events",
+          description: "Subscribe to global events from the Miaw system using server-sent events.",
+        }),
+      ),
+      HttpApiEndpoint.get("configGet", GlobalPaths.config, {
+        success: described(ConfigV1.Info, "Get global config info"),
+      }).annotateMerge(
+        OpenApi.annotations({
+          identifier: "global.config.get",
+          summary: "Get global configuration",
+          description: "Retrieve the current global Miaw configuration settings and preferences.",
+        }),
+      ),
+      HttpApiEndpoint.patch("configUpdate", GlobalPaths.config, {
+        payload: ConfigV1.Info,
+        success: described(ConfigV1.Info, "Successfully updated global config"),
+        error: HttpApiError.BadRequest,
+      }).annotateMerge(
+        OpenApi.annotations({
+          identifier: "global.config.update",
+          summary: "Update global configuration",
+          description: "Update global Miaw configuration settings and preferences.",
+        }),
+      ),
+      HttpApiEndpoint.post("dispose", GlobalPaths.dispose, {
+        success: described(Schema.Boolean, "Global disposed"),
+      }).annotateMerge(
+        OpenApi.annotations({
+          identifier: "global.dispose",
+          summary: "Dispose instance",
+          description: "Clean up and dispose all Miaw instances, releasing all resources.",
+        }),
+      ),
+      HttpApiEndpoint.post("upgrade", GlobalPaths.upgrade, {
+        payload: [HttpApiSchema.NoContent, GlobalUpgradeInput],
+        success: described(GlobalUpgradeResult, "Upgrade result"),
+        error: HttpApiError.BadRequest,
+      }).annotateMerge(
+        OpenApi.annotations({
+          identifier: "global.upgrade",
+          summary: "Upgrade miaw",
+          description: "Upgrade miaw to the specified version or latest if not specified.",
+        }),
+      ),
+    )
+    .annotateMerge(OpenApi.annotations({ title: "global", description: "Global server routes." })),
+)

package/src/server/routes/instance/httpapi/groups/instance.ts

@@ -0,0 +1,206 @@
+import { Agent } from "@/agent/agent"
+import { Command } from "@/command"
+import { Format } from "@/format"
+import { LSP } from "@/lsp/lsp"
+import { Vcs } from "@/project/vcs"
+import { Skill } from "@/skill"
+import { Schema } from "effect"
+import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
+import { Authorization } from "../middleware/authorization"
+import { InstanceContextMiddleware } from "../middleware/instance-context"
+import {
+  WorkspaceRoutingMiddleware,
+  WorkspaceRoutingQuery,
+  WorkspaceRoutingQueryFields,
+} from "../middleware/workspace-routing"
+import { described } from "./metadata"
+
+const PathInfo = Schema.Struct({
+  home: Schema.String,
+  state: Schema.String,
+  config: Schema.String,
+  worktree: Schema.String,
+  directory: Schema.String,
+}).annotate({ identifier: "Path" })
+
+export const VcsDiffQuery = Schema.Struct({
+  ...WorkspaceRoutingQueryFields,
+  mode: Vcs.Mode,
+  context: Schema.optional(Schema.NumberFromString.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0))),
+})
+
+export class ApiVcsApplyError extends Schema.ErrorClass<ApiVcsApplyError>("VcsApplyError")(
+  {
+    name: Schema.Literal("VcsApplyError"),
+    data: Schema.Struct({
+      message: Schema.String,
+      reason: Schema.Literals(["non-git", "not-clean"]),
+    }),
+  },
+  { httpApiStatus: 400 },
+) {}
+
+export const InstancePaths = {
+  dispose: "/instance/dispose",
+  path: "/path",
+  vcs: "/vcs",
+  vcsStatus: "/vcs/status",
+  vcsDiff: "/vcs/diff",
+  vcsDiffRaw: "/vcs/diff/raw",
+  vcsApply: "/vcs/apply",
+  command: "/command",
+  agent: "/agent",
+  skill: "/skill",
+  lsp: "/lsp",
+  formatter: "/formatter",
+} as const
+
+export const InstanceApi = HttpApi.make("instance")
+  .add(
+    HttpApiGroup.make("instance")
+      .add(
+        HttpApiEndpoint.post("dispose", InstancePaths.dispose, {
+          query: WorkspaceRoutingQuery,
+          success: described(Schema.Boolean, "Instance disposed"),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "instance.dispose",
+            summary: "Dispose instance",
+            description: "Clean up and dispose the current Miaw instance, releasing all resources.",
+          }),
+        ),
+        HttpApiEndpoint.get("path", InstancePaths.path, {
+          query: WorkspaceRoutingQuery,
+          success: PathInfo,
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "path.get",
+            summary: "Get paths",
+            description:
+              "Retrieve the current working directory and related path information for the Miaw instance.",
+          }),
+        ),
+        HttpApiEndpoint.get("vcs", InstancePaths.vcs, {
+          query: WorkspaceRoutingQuery,
+          success: described(Vcs.Info, "VCS info"),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "vcs.get",
+            summary: "Get VCS info",
+            description:
+              "Retrieve version control system (VCS) information for the current project, such as git branch.",
+          }),
+        ),
+        HttpApiEndpoint.get("vcsStatus", InstancePaths.vcsStatus, {
+          query: WorkspaceRoutingQuery,
+          success: described(Schema.Array(Vcs.FileStatus), "VCS status"),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "vcs.status",
+            summary: "Get VCS status",
+            description: "Retrieve changed files in the current working tree without patches.",
+          }),
+        ),
+        HttpApiEndpoint.get("vcsDiff", InstancePaths.vcsDiff, {
+          query: VcsDiffQuery,
+          success: described(Schema.Array(Vcs.FileDiff), "VCS diff"),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "vcs.diff",
+            summary: "Get VCS diff",
+            description: "Retrieve the current git diff for the working tree or against the default branch.",
+          }),
+        ),
+        HttpApiEndpoint.get("vcsDiffRaw", InstancePaths.vcsDiffRaw, {
+          query: WorkspaceRoutingQuery,
+          success: described(
+            Schema.String.pipe(HttpApiSchema.asText({ contentType: "text/x-diff; charset=utf-8" })),
+            "Raw VCS diff",
+          ),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "vcs.diff.raw",
+            summary: "Get raw VCS diff",
+            description: "Retrieve a raw patch for current uncommitted changes.",
+          }),
+        ),
+        HttpApiEndpoint.post("vcsApply", InstancePaths.vcsApply, {
+          query: WorkspaceRoutingQuery,
+          payload: Vcs.ApplyInput,
+          success: described(Vcs.ApplyResult, "VCS patch applied"),
+          error: ApiVcsApplyError,
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "vcs.apply",
+            summary: "Apply VCS patch",
+            description: "Apply a raw patch to the current working tree.",
+          }),
+        ),
+        HttpApiEndpoint.get("command", InstancePaths.command, {
+          query: WorkspaceRoutingQuery,
+          success: described(Schema.Array(Command.Info), "List of commands"),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "command.list",
+            summary: "List commands",
+            description: "Get a list of all available commands in the Miaw system.",
+          }),
+        ),
+        HttpApiEndpoint.get("agent", InstancePaths.agent, {
+          query: WorkspaceRoutingQuery,
+          success: described(Schema.Array(Agent.Info), "List of agents"),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "app.agents",
+            summary: "List agents",
+            description: "Get a list of all available AI agents in the Miaw system.",
+          }),
+        ),
+        HttpApiEndpoint.get("skill", InstancePaths.skill, {
+          query: WorkspaceRoutingQuery,
+          success: described(Schema.Array(Skill.Info), "List of skills"),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "app.skills",
+            summary: "List skills",
+            description: "Get a list of all available skills in the Miaw system.",
+          }),
+        ),
+        HttpApiEndpoint.get("lsp", InstancePaths.lsp, {
+          query: WorkspaceRoutingQuery,
+          success: described(Schema.Array(LSP.Status), "LSP server status"),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "lsp.status",
+            summary: "Get LSP status",
+            description: "Get LSP server status",
+          }),
+        ),
+        HttpApiEndpoint.get("formatter", InstancePaths.formatter, {
+          query: WorkspaceRoutingQuery,
+          success: described(Schema.Array(Format.Status), "Formatter status"),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "formatter.status",
+            summary: "Get formatter status",
+            description: "Get formatter status",
+          }),
+        ),
+      )
+      .annotateMerge(
+        OpenApi.annotations({
+          title: "instance",
+          description: "Experimental HttpApi instance read routes.",
+        }),
+      )
+      .middleware(InstanceContextMiddleware)
+      .middleware(WorkspaceRoutingMiddleware)
+      .middleware(Authorization),
+  )
+  .annotateMerge(
+    OpenApi.annotations({
+      title: "miaw experimental HttpApi",
+      version: "0.0.1",
+      description: "Experimental HttpApi surface for selected instance routes.",
+    }),
+  )

package/src/server/routes/instance/httpapi/groups/mcp.ts

@@ -0,0 +1,156 @@
+import { MCP } from "@/mcp"
+import { ConfigMCPV1 } from "@miaw/core/v1/config/mcp"
+import { Schema } from "effect"
+import { HttpApi, HttpApiEndpoint, HttpApiError, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
+import { McpServerNotFoundError } from "../errors"
+import { Authorization } from "../middleware/authorization"
+import { InstanceContextMiddleware } from "../middleware/instance-context"
+import { WorkspaceRoutingMiddleware, WorkspaceRoutingQuery } from "../middleware/workspace-routing"
+import { described } from "./metadata"
+
+export const AddPayload = Schema.Struct({
+  name: Schema.String,
+  config: ConfigMCPV1.Info,
+})
+
+export const StatusMap = Schema.Record(Schema.String, MCP.Status)
+export const AuthStartResponse = Schema.Struct({
+  authorizationUrl: Schema.String,
+  oauthState: Schema.String,
+})
+export const AuthCallbackPayload = Schema.Struct({
+  code: Schema.String,
+})
+export const AuthRemoveResponse = Schema.Struct({
+  success: Schema.Literal(true),
+})
+export class UnsupportedOAuthError extends Schema.ErrorClass<UnsupportedOAuthError>("McpUnsupportedOAuthError")(
+  { error: Schema.String },
+  { httpApiStatus: 400 },
+) {}
+
+export const McpPaths = {
+  status: "/mcp",
+  auth: "/mcp/:name/auth",
+  authCallback: "/mcp/:name/auth/callback",
+  authAuthenticate: "/mcp/:name/auth/authenticate",
+  connect: "/mcp/:name/connect",
+  disconnect: "/mcp/:name/disconnect",
+} as const
+
+export const McpApi = HttpApi.make("mcp")
+  .add(
+    HttpApiGroup.make("mcp")
+      .add(
+        HttpApiEndpoint.get("status", McpPaths.status, {
+          query: WorkspaceRoutingQuery,
+          success: described(Schema.Record(Schema.String, MCP.Status), "MCP server status"),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "mcp.status",
+            summary: "Get MCP status",
+            description: "Get the status of all Model Context Protocol (MCP) servers.",
+          }),
+        ),
+        HttpApiEndpoint.post("add", McpPaths.status, {
+          query: WorkspaceRoutingQuery,
+          payload: AddPayload,
+          success: described(StatusMap, "MCP server added successfully"),
+          error: HttpApiError.BadRequest,
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "mcp.add",
+            summary: "Add MCP server",
+            description: "Dynamically add a new Model Context Protocol (MCP) server to the system.",
+          }),
+        ),
+        HttpApiEndpoint.post("authStart", McpPaths.auth, {
+          params: { name: Schema.String },
+          query: WorkspaceRoutingQuery,
+          success: described(AuthStartResponse, "OAuth flow started"),
+          error: [UnsupportedOAuthError, McpServerNotFoundError],
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "mcp.auth.start",
+            summary: "Start MCP OAuth",
+            description: "Start OAuth authentication flow for a Model Context Protocol (MCP) server.",
+          }),
+        ),
+        HttpApiEndpoint.post("authCallback", McpPaths.authCallback, {
+          params: { name: Schema.String },
+          query: WorkspaceRoutingQuery,
+          payload: AuthCallbackPayload,
+          success: described(MCP.Status, "OAuth authentication completed"),
+          error: [HttpApiError.BadRequest, McpServerNotFoundError],
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "mcp.auth.callback",
+            summary: "Complete MCP OAuth",
+            description:
+              "Complete OAuth authentication for a Model Context Protocol (MCP) server using the authorization code.",
+          }),
+        ),
+        HttpApiEndpoint.post("authAuthenticate", McpPaths.authAuthenticate, {
+          params: { name: Schema.String },
+          query: WorkspaceRoutingQuery,
+          success: described(MCP.Status, "OAuth authentication completed"),
+          error: [UnsupportedOAuthError, McpServerNotFoundError],
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "mcp.auth.authenticate",
+            summary: "Authenticate MCP OAuth",
+            description: "Start OAuth flow and wait for callback (opens browser).",
+          }),
+        ),
+        HttpApiEndpoint.delete("authRemove", McpPaths.auth, {
+          params: { name: Schema.String },
+          query: WorkspaceRoutingQuery,
+          success: described(AuthRemoveResponse, "OAuth credentials removed"),
+          error: McpServerNotFoundError,
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "mcp.auth.remove",
+            summary: "Remove MCP OAuth",
+            description: "Remove OAuth credentials for an MCP server.",
+          }),
+        ),
+        HttpApiEndpoint.post("connect", McpPaths.connect, {
+          params: { name: Schema.String },
+          query: WorkspaceRoutingQuery,
+          success: described(Schema.Boolean, "MCP server connected successfully"),
+          error: McpServerNotFoundError,
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "mcp.connect",
+            description: "Connect an MCP server.",
+          }),
+        ),
+        HttpApiEndpoint.post("disconnect", McpPaths.disconnect, {
+          params: { name: Schema.String },
+          query: WorkspaceRoutingQuery,
+          success: described(Schema.Boolean, "MCP server disconnected successfully"),
+          error: McpServerNotFoundError,
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "mcp.disconnect",
+            description: "Disconnect an MCP server.",
+          }),
+        ),
+      )
+      .annotateMerge(
+        OpenApi.annotations({
+          title: "mcp",
+          description: "Experimental HttpApi MCP routes.",
+        }),
+      )
+      .middleware(InstanceContextMiddleware)
+      .middleware(WorkspaceRoutingMiddleware)
+      .middleware(Authorization),
+  )
+  .annotateMerge(
+    OpenApi.annotations({
+      title: "miaw experimental HttpApi",
+      version: "0.0.1",
+      description: "Experimental HttpApi surface for selected instance routes.",
+    }),
+  )