Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
4.3 KB
Raw Blame
import type { createOpencodeClient } from "@opencode-ai/sdk/v2/client";
import {
  isTrustedCloudMcpEndpointForGlobalPersist,
  OMNIRUSH_CLOUD_MCP_NAME,
  readOmniRushCloudMcpHealth,
  reconcileOmniRushCloudMcp,
  refreshOmniRushCloudMcpEngine,
  type CloudMcpServerMetadata,
  type CloudMcpProviderModelContext,
  type CloudMcpRuntimeRegistrar,
  type CloudMcpLiveStatusObserver,
} from "../cloud-mcp-health.js";
import { ApiError } from "../errors.js";
import { refuseAccountLinkedMcp } from "../mcp-policy.js";
import type { ServerConfig, TokenScope, WorkspaceInfo } from "../types.js";
import { addRoute, type RequestContext, type Route } from "./registry.js";

type JsonResponse = (data: unknown, status?: number) => Response;
type ReadJsonBody = (request: Request) => Promise<Record<string, unknown>>;
type WorkspaceOpencodeClient = ReturnType<typeof createOpencodeClient>;

export type RegisterCloudMcpRoutesOptions = {
  routes: Route[];
  config: ServerConfig;
  jsonResponse: JsonResponse;
  readJsonBody: ReadJsonBody;
  ensureWritable: (config: ServerConfig) => void;
  requireClientScope: (ctx: RequestContext, required: TokenScope) => void;
  resolveWorkspace: (config: ServerConfig, id: string) => Promise<WorkspaceInfo>;
  resolveOpencodeDirectory: (workspace: WorkspaceInfo) => string | null;
  createWorkspaceOpencodeClient: (config: ServerConfig, workspace: WorkspaceInfo) => WorkspaceOpencodeClient;
  registerRuntimeMcp: CloudMcpRuntimeRegistrar;
  refreshRegistrationFromLiveStatus?: CloudMcpLiveStatusObserver;
  serverMetadata?: CloudMcpServerMetadata;
};

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === "object" && value !== null && !Array.isArray(value);
}

function providerModelFromValues(provider: unknown, model: unknown): CloudMcpProviderModelContext | undefined {
  const providerValue = typeof provider === "string" ? provider.trim() : "";
  const modelValue = typeof model === "string" ? model.trim() : "";
  if (!providerValue && !modelValue) return undefined;
  if (!providerValue || !modelValue) {
    throw new ApiError(400, "invalid_payload", "provider and model must be supplied together");
  }
  return { provider: providerValue, model: modelValue };
}

function providerModelFromQuery(url: URL): CloudMcpProviderModelContext | undefined {
  return providerModelFromValues(url.searchParams.get("provider"), url.searchParams.get("model"));
}

function probeFromQuery(url: URL): boolean {
  const value = url.searchParams.get("probe")?.toLowerCase();
  return value === "1" || value === "true";
}

function providerModelFromBody(body: Record<string, unknown>): CloudMcpProviderModelContext | undefined {
  const direct = providerModelFromValues(body.provider, body.model);
  if (direct) return direct;
  if (!isRecord(body.context)) return undefined;
  return providerModelFromValues(body.context.provider, body.context.model);
}

function assertExactWorkspace(requestedId: string, workspace: WorkspaceInfo): void {
  if (requestedId.trim() !== workspace.id) {
    throw new ApiError(404, "workspace_not_found", "Workspace not found");
  }
}

function assertStrictBody(body: Record<string, unknown>, workspace: WorkspaceInfo): void {
  if (typeof body.workspaceId === "string" && body.workspaceId.trim() !== workspace.id) {
    throw new ApiError(400, "workspace_id_mismatch", "workspaceId must match the route workspace");
  }
  if (typeof body.name === "string" && body.name.trim() !== OMNIRUSH_CLOUD_MCP_NAME) {
    throw new ApiError(400, "invalid_mcp_name", "Only omnirush-cloud can be reconciled by this endpoint");
  }
}

export function registerCloudMcpRoutes(options: RegisterCloudMcpRoutesOptions): void {
  const {
    routes,
    config,
    jsonResponse,
    readJsonBody,
    ensureWritable,
    requireClientScope,
    resolveWorkspace,
    resolveOpencodeDirectory,
    createWorkspaceOpencodeClient,
    registerRuntimeMcp,
    refreshRegistrationFromLiveStatus,
    serverMetadata,
  } = options;

  addRoute(routes, "GET", "/workspace/:id/mcp/omnirush-cloud/health", "client", async () => {
    refuseAccountLinkedMcp();
  });

  addRoute(routes, "POST", "/workspace/:id/mcp/omnirush-cloud/engine-refresh", "client", async () => {
    refuseAccountLinkedMcp();
  });

  addRoute(routes, "POST", "/workspace/:id/mcp/omnirush-cloud/reconcile", "client", async () => {
    refuseAccountLinkedMcp();
  });
}