@miaws/miaw 1.18.5 → 1.18.6

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

@@ -1,185 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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

@@ -1,206 +0,0 @@
-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

@@ -1,156 +0,0 @@
-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.",
-    }),
-  )