muonroi-cli 1.2.0

package/src/lsp/types.ts

@@ -0,0 +1,116 @@
+export const LSP_TOOL_OPERATIONS = [
+  "goToDefinition",
+  "findReferences",
+  "hover",
+  "documentSymbol",
+  "workspaceSymbol",
+  "goToImplementation",
+  "prepareCallHierarchy",
+  "incomingCalls",
+  "outgoingCalls",
+] as const;
+
+export type LspToolOperation = (typeof LSP_TOOL_OPERATIONS)[number];
+
+export type LspBuiltInServerId =
+  | "typescript"
+  | "pyright"
+  | "gopls"
+  | "rust-analyzer"
+  | "bash-language-server"
+  | "yaml-language-server"
+  | "clangd"
+  | "jdtls"
+  | "sourcekit-lsp";
+
+export interface LspPosition {
+  line: number;
+  character: number;
+}
+
+export interface LspRange {
+  start: LspPosition;
+  end: LspPosition;
+}
+
+export interface LspLocation {
+  uri: string;
+  range: LspRange;
+}
+
+export interface LspDiagnostic {
+  message: string;
+  severity?: number;
+  source?: string;
+  code?: string;
+  range: LspRange;
+}
+
+export interface LspDiagnosticFile {
+  filePath: string;
+  serverId: string;
+  diagnostics: LspDiagnostic[];
+}
+
+export interface LspLaunchSpec {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+  initializationOptions?: Record<string, unknown>;
+}
+
+export interface LspBuiltInServerSettings {
+  enabled?: boolean;
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  initialization?: Record<string, unknown>;
+  rootMarkers?: string[];
+  extensions?: string[];
+}
+
+export interface LspCustomServerConfig {
+  id: string;
+  enabled?: boolean;
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+  initialization?: Record<string, unknown>;
+  rootMarkers?: string[];
+  extensions: string[];
+  languageIds?: Record<string, string>;
+}
+
+export interface LspSettings {
+  enabled?: boolean;
+  tool?: boolean;
+  autoInstall?: boolean;
+  startupTimeoutMs?: number;
+  diagnosticsDebounceMs?: number;
+  builtins?: Partial<Record<LspBuiltInServerId, LspBuiltInServerSettings>>;
+  servers?: LspCustomServerConfig[];
+}
+
+export interface NormalizedLspSettings {
+  enabled: boolean;
+  tool: boolean;
+  autoInstall: boolean;
+  startupTimeoutMs: number;
+  diagnosticsDebounceMs: number;
+  builtins: Partial<Record<LspBuiltInServerId, LspBuiltInServerSettings>>;
+  servers: LspCustomServerConfig[];
+}
+
+export interface LspQueryInput {
+  operation: LspToolOperation;
+  filePath: string;
+  line?: number;
+  character?: number;
+  query?: string;
+}
+
+export interface LspToolResponse {
+  success: boolean;
+  output: string;
+  lspDiagnostics?: LspDiagnosticFile[];
+}

package/src/mcp/auto-setup.ts

@@ -0,0 +1,80 @@
+import type { McpServerConfig } from "../utils/settings.js";
+import { loadMcpServers, saveMcpServers } from "../utils/settings.js";
+
+const DEFAULT_CONFIGS: McpServerConfig[] = [
+  {
+    id: "filesystem",
+    label: "Filesystem",
+    enabled: true,
+    transport: "stdio",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-filesystem", "."],
+  },
+  {
+    id: "playwright",
+    label: "Playwright",
+    enabled: true,
+    transport: "stdio",
+    command: "npx",
+    args: ["-y", "@playwright/mcp"],
+  },
+  {
+    id: "memory",
+    label: "Memory",
+    enabled: false,
+    transport: "stdio",
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-memory"],
+  },
+  {
+    id: "figma",
+    label: "Figma",
+    enabled: false,
+    transport: "stdio",
+    command: "npx",
+    args: ["-y", "figma-developer-mcp", "--stdio"],
+    env: { FIGMA_API_KEY: "" },
+  },
+];
+
+const PACKAGE_MIGRATIONS: Record<string, string> = {
+  "@anthropic-ai/figma-mcp": "figma-developer-mcp",
+  "@anthropic-ai/mcp-playwright": "@playwright/mcp",
+};
+
+function migrateServers(servers: McpServerConfig[]): boolean {
+  let changed = false;
+  for (const server of servers) {
+    const pkgArg = server.args?.find((a) => PACKAGE_MIGRATIONS[a]);
+    if (pkgArg) {
+      server.args = server.args!.map((a) => PACKAGE_MIGRATIONS[a] ?? a);
+      changed = true;
+    }
+    if (
+      server.id === "figma" &&
+      server.args?.includes("figma-developer-mcp") &&
+      !server.args.includes("--stdio")
+    ) {
+      server.args = [...server.args, "--stdio"];
+      changed = true;
+    }
+  }
+  return changed;
+}
+
+export function ensureDefaultMcpServers(): McpServerConfig[] {
+  try {
+    const existing = loadMcpServers();
+    let dirty = migrateServers(existing);
+    const existingIds = new Set(existing.map((s) => s.id));
+    const toAdd = DEFAULT_CONFIGS.filter((s) => !existingIds.has(s.id));
+    if (toAdd.length > 0) dirty = true;
+    if (!dirty) return existing;
+    const merged =
+      toAdd.length > 0 ? [...toAdd, ...existing] : existing;
+    saveMcpServers(merged);
+    return merged;
+  } catch {
+    return [];
+  }
+}

package/src/mcp/catalog.ts

@@ -0,0 +1,138 @@
+import type { McpRemoteTransport } from "../utils/settings.js";
+
+export interface McpCatalogEntry {
+  id: string;
+  name: string;
+  description: string;
+  directoryUrl: string;
+  sourceUrl?: string;
+  starterTransport?: McpRemoteTransport | "stdio";
+}
+
+export const POPULAR_MCP_CATALOG: McpCatalogEntry[] = [
+  {
+    id: "filesystem",
+    name: "Filesystem",
+    description:
+      "Read/write access to the local filesystem with safety controls.",
+    directoryUrl:
+      "https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem",
+    sourceUrl: "https://github.com/modelcontextprotocol/servers",
+    starterTransport: "stdio",
+  },
+  {
+    id: "playwright",
+    name: "Playwright",
+    description: "Browser automation and web testing via Playwright.",
+    directoryUrl: "https://github.com/microsoft/playwright-mcp",
+    sourceUrl: "https://github.com/microsoft/playwright-mcp",
+    starterTransport: "stdio",
+  },
+  {
+    id: "memory",
+    name: "Memory",
+    description: "Persistent knowledge graph memory for context recall.",
+    directoryUrl:
+      "https://github.com/modelcontextprotocol/servers/tree/main/src/memory",
+    sourceUrl: "https://github.com/modelcontextprotocol/servers",
+    starterTransport: "stdio",
+  },
+  {
+    id: "github",
+    name: "GitHub",
+    description: "Integration with GitHub issues and related workflows.",
+    directoryUrl: "https://cursor.directory/plugins/mcp-github",
+    sourceUrl:
+      "https://github.com/modelcontextprotocol/servers/tree/main/src/github",
+    starterTransport: "stdio",
+  },
+  {
+    id: "supabase",
+    name: "Supabase",
+    description: "PostgREST-backed operations for Postgres databases.",
+    directoryUrl: "https://cursor.directory/plugins/mcp-supabase",
+  },
+  {
+    id: "vercel",
+    name: "Vercel",
+    description: "Vercel infrastructure and deployment workflows.",
+    directoryUrl: "https://cursor.directory/plugins/mcp-vercel",
+  },
+  {
+    id: "cloudflare",
+    name: "Cloudflare",
+    description: "Workers, KV, R2, and D1 operations on Cloudflare.",
+    directoryUrl: "https://cursor.directory/plugins/mcp-cloudflare",
+  },
+  {
+    id: "stripe",
+    name: "Stripe",
+    description: "Stripe API access for billing and payment workflows.",
+    directoryUrl: "https://cursor.directory/plugins/mcp-stripe",
+  },
+  {
+    id: "notion",
+    name: "Notion",
+    description:
+      "Databases, pages, blocks, and search inside Notion workspaces.",
+    directoryUrl: "https://cursor.directory/plugins/mcp-notion",
+  },
+  {
+    id: "slack",
+    name: "Slack",
+    description: "Slack workspace messaging and channel workflows.",
+    directoryUrl: "https://cursor.directory/plugins/mcp-slack",
+  },
+  {
+    id: "sentry",
+    name: "Sentry",
+    description:
+      "Issue analysis and debugging workflows for Sentry projects.",
+    directoryUrl: "https://cursor.directory/plugins/mcp-sentry",
+  },
+  {
+    id: "figma",
+    name: "Figma",
+    description: "Design data from Figma for implementation workflows.",
+    directoryUrl: "https://cursor.directory/plugins/mcp-figma",
+  },
+  {
+    id: "firebase",
+    name: "Firebase",
+    description: "Auth, Firestore, and Storage operations.",
+    directoryUrl: "https://cursor.directory/plugins/mcp-firebase",
+  },
+  {
+    id: "docker",
+    name: "Docker",
+    description: "Manage containers, images, volumes, and networks.",
+    directoryUrl: "https://cursor.directory/plugins/mcp-docker",
+    starterTransport: "stdio",
+  },
+  {
+    id: "prisma",
+    name: "Prisma",
+    description: "Prisma database workflows and Postgres management.",
+    directoryUrl: "https://cursor.directory/plugins/mcp-prisma",
+  },
+  {
+    id: "mongodb",
+    name: "MongoDB",
+    description:
+      "Read-only exploration, queries, and aggregation for MongoDB.",
+    directoryUrl: "https://cursor.directory/plugins/mcp-mongodb",
+  },
+  {
+    id: "puppeteer",
+    name: "Puppeteer",
+    description: "Browser automation via Puppeteer MCP.",
+    directoryUrl: "https://cursor.directory/plugins/mcp-puppeteer",
+    starterTransport: "stdio",
+  },
+  {
+    id: "browserbase",
+    name: "Browserbase",
+    description: "Cloud browser automation workflows.",
+    directoryUrl: "https://cursor.directory/plugins/mcp-browserbase",
+  },
+];

package/src/mcp/oauth-callback.ts

@@ -0,0 +1,63 @@
+import http from "node:http";
+import { URL } from "node:url";
+
+export interface OAuthCallbackServer {
+  port: number;
+  url: string;
+  close(): void;
+}
+
+const SUCCESS_HTML = `<!DOCTYPE html><html><body style="font-family:system-ui;text-align:center;padding:60px">
+<h2>Authorization successful</h2><p>You can close this tab and return to the terminal.</p>
+</body></html>`;
+
+export function startOAuthCallbackServer(opts: {
+  onCode: (code: string, state: string) => void;
+  timeoutMs?: number;
+}): Promise<OAuthCallbackServer> {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      if (!req.url?.startsWith("/callback")) {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const parsed = new URL(req.url, "http://127.0.0.1");
+      const code = parsed.searchParams.get("code");
+      const state = parsed.searchParams.get("state") ?? "";
+      if (!code) {
+        res.writeHead(400);
+        res.end("Missing code parameter");
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(SUCCESS_HTML);
+      opts.onCode(code, state);
+    });
+
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Failed to start callback server"));
+        return;
+      }
+      const port = addr.port;
+      const url = `http://127.0.0.1:${port}/callback`;
+
+      const timeout = setTimeout(() => {
+        server.close();
+      }, opts.timeoutMs ?? 300_000);
+
+      resolve({
+        port,
+        url,
+        close() {
+          clearTimeout(timeout);
+          server.close();
+        },
+      });
+    });
+
+    server.on("error", reject);
+  });
+}

package/src/mcp/oauth-provider.ts

@@ -0,0 +1,130 @@
+import type { OAuthDiscoveryState } from "@modelcontextprotocol/sdk/client/auth.js";
+import type {
+  OAuthClientInformationMixed,
+  OAuthClientMetadata,
+  OAuthTokens,
+} from "@modelcontextprotocol/sdk/shared/auth.js";
+import { startOAuthCallbackServer } from "./oauth-callback.js";
+
+interface CliOAuthStorage {
+  clientInfo?: OAuthClientInformationMixed;
+  tokens?: OAuthTokens;
+  discovery?: OAuthDiscoveryState;
+}
+
+const storage = new Map<string, CliOAuthStorage>();
+
+function getStore(serverId: string): CliOAuthStorage {
+  let s = storage.get(serverId);
+  if (!s) {
+    s = {};
+    storage.set(serverId, s);
+  }
+  return s;
+}
+
+export class CliOAuthProvider {
+  private _codeVerifier = "";
+  private serverId: string;
+  private _redirectUrl: string;
+  private onAuthUrl: (url: URL) => void;
+
+  constructor(opts: {
+    serverId: string;
+    callbackPort: number;
+    onAuthorizationUrl: (url: URL) => void;
+  }) {
+    this.serverId = opts.serverId;
+    this._redirectUrl = `http://127.0.0.1:${opts.callbackPort}/callback`;
+    this.onAuthUrl = opts.onAuthorizationUrl;
+  }
+
+  get redirectUrl(): string {
+    return this._redirectUrl;
+  }
+
+  get clientMetadata(): OAuthClientMetadata {
+    return {
+      client_name: "muonroi-cli",
+      redirect_uris: [this._redirectUrl],
+      grant_types: ["authorization_code"],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none",
+    };
+  }
+
+  clientInformation(): OAuthClientInformationMixed | undefined {
+    return getStore(this.serverId).clientInfo;
+  }
+
+  saveClientInformation(info: OAuthClientInformationMixed): void {
+    getStore(this.serverId).clientInfo = info;
+  }
+
+  tokens(): OAuthTokens | undefined {
+    return getStore(this.serverId).tokens;
+  }
+
+  saveTokens(tokens: OAuthTokens): void {
+    getStore(this.serverId).tokens = tokens;
+  }
+
+  redirectToAuthorization(authorizationUrl: URL): void {
+    this.onAuthUrl(authorizationUrl);
+  }
+
+  saveCodeVerifier(codeVerifier: string): void {
+    this._codeVerifier = codeVerifier;
+  }
+
+  codeVerifier(): string {
+    return this._codeVerifier;
+  }
+
+  saveDiscoveryState(state: OAuthDiscoveryState): void {
+    getStore(this.serverId).discovery = state;
+  }
+
+  discoveryState(): OAuthDiscoveryState | undefined {
+    return getStore(this.serverId).discovery;
+  }
+
+  invalidateCredentials(
+    scope: "all" | "client" | "tokens" | "verifier" | "discovery",
+  ): void {
+    const s = getStore(this.serverId);
+    if (scope === "all" || scope === "tokens") s.tokens = undefined;
+    if (scope === "all" || scope === "client") s.clientInfo = undefined;
+    if (scope === "all" || scope === "discovery") s.discovery = undefined;
+    if (scope === "all" || scope === "verifier") this._codeVerifier = "";
+  }
+
+  cleanup(): void {
+    // noop — callback server is managed externally
+  }
+}
+
+export async function createOAuthProviderWithCallback(opts: {
+  serverId: string;
+  onAuthorizationUrl: (url: URL) => void;
+}): Promise<{ provider: CliOAuthProvider; close: () => void }> {
+  const server = await startOAuthCallbackServer({
+    onCode: () => {
+      // SDK handles code exchange internally
+    },
+  });
+
+  const provider = new CliOAuthProvider({
+    serverId: opts.serverId,
+    callbackPort: server.port,
+    onAuthorizationUrl: opts.onAuthorizationUrl,
+  });
+
+  return {
+    provider,
+    close() {
+      server.close();
+      provider.cleanup();
+    },
+  };
+}

package/src/mcp/parse-headers.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { parseEnvLines, parseHeaderLines } from "./parse-headers";
+
+describe("parseHeaderLines", () => {
+  it("parses colon-separated headers and trims whitespace", () => {
+    expect(
+      parseHeaderLines(`
+        Authorization: Bearer token
+        X-Trace-Id:  abc123
+      `),
+    ).toEqual({
+      Authorization: "Bearer token",
+      "X-Trace-Id": "abc123",
+    });
+  });
+
+  it("ignores blank and malformed lines while preserving later colons in values", () => {
+    expect(
+      parseHeaderLines(`
+        invalid
+        : missing-name
+        Host: example.com:443
+      `),
+    ).toEqual({
+      Host: "example.com:443",
+    });
+  });
+});
+
+describe("parseEnvLines", () => {
+  it("parses equals-separated env assignments and trims whitespace", () => {
+    expect(
+      parseEnvLines(`
+        API_KEY = secret
+        MODE= production
+      `),
+    ).toEqual({
+      API_KEY: "secret",
+      MODE: "production",
+    });
+  });
+
+  it("ignores blank and malformed lines while preserving later equals in values", () => {
+    expect(
+      parseEnvLines(`
+        missing
+        = no-name
+        URL=https://example.com?a=b
+      `),
+    ).toEqual({
+      URL: "https://example.com?a=b",
+    });
+  });
+});

package/src/mcp/parse-headers.ts

@@ -0,0 +1,35 @@
+export function parseHeaderLines(text: string): Record<string, string> {
+  const headers: Record<string, string> = {};
+
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) continue;
+
+    const idx = line.indexOf(":");
+    if (idx <= 0) continue;
+
+    const name = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim();
+    if (name) headers[name] = value;
+  }
+
+  return headers;
+}
+
+export function parseEnvLines(text: string): Record<string, string> {
+  const env: Record<string, string> = {};
+
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) continue;
+
+    const idx = line.indexOf("=");
+    if (idx <= 0) continue;
+
+    const name = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim();
+    if (name) env[name] = value;
+  }
+
+  return env;
+}