@nextclaw/mcp 0.1.1 → 0.1.2

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { McpServerDefinition, McpTransport, Config, McpServerScope } from '@nextclaw/core';
+import { McpServerDefinition, McpTransport, McpServerScope, McpServerMetadata, Config } from '@nextclaw/core';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
 
@@ -45,6 +45,56 @@ type McpLifecycleState = {
     lastReadyAt?: string;
     lastError?: string;
 };
+type McpMarketplaceTransportType = McpTransport["type"];
+type McpMarketplaceInputField = {
+    id: string;
+    label: string;
+    description?: string;
+    required?: boolean;
+    secret?: boolean;
+    defaultValue?: string;
+};
+type McpMarketplaceInstallTemplate = {
+    kind: "template";
+    spec: string;
+    command: string;
+    defaultName: string;
+    transportTypes: McpMarketplaceTransportType[];
+    template: McpServerDefinition;
+    inputs: McpMarketplaceInputField[];
+};
+type McpInstalledRecord = {
+    name: string;
+    enabled: boolean;
+    transport: McpTransport["type"];
+    scope: McpServerScope;
+    source: "manual" | "marketplace";
+    catalogSlug?: string;
+    displayName?: string;
+    vendor?: string;
+    docsUrl?: string;
+    homepage?: string;
+    trustLevel?: "official" | "verified" | "community";
+    installedAt?: string;
+    toolCount?: number;
+    accessible?: boolean;
+    lastReadyAt?: string;
+    lastError?: string;
+};
+type McpMutationResult = {
+    changed: boolean;
+    name: string;
+    message: string;
+    definition?: McpServerDefinition;
+};
+type McpMaterializeInstallParams = {
+    template: McpMarketplaceInstallTemplate;
+    name?: string;
+    enabled?: boolean;
+    scope?: Partial<McpServerScope>;
+    inputs?: Record<string, string | undefined>;
+    metadata?: Partial<McpServerMetadata>;
+};
 declare function normalizeMcpServerName(name: string): string;
 declare function readDefaultAgentId(config: Config): string;
 declare function isServerAccessibleToAgent(params: {
@@ -79,6 +129,7 @@ declare class McpServerLifecycleManager {
     });
     warmServer(record: McpServerRecord): Promise<McpLifecycleState>;
     getCachedCatalog(serverName: string): McpToolCatalogEntry[];
+    getCachedState(serverName: string): McpLifecycleState | undefined;
     callTool(record: McpServerRecord, toolName: string, args: Record<string, unknown>): Promise<unknown>;
     closeAll(): Promise<void>;
     closeServer(serverName: string): Promise<void>;
@@ -104,6 +155,7 @@ declare class McpRegistryService {
         nextConfig: Config;
     }): Promise<McpConfigReconcileResult>;
     listAccessibleTools(filter?: McpCatalogFilter): McpToolCatalogEntry[];
+    getCachedState(serverName: string): McpLifecycleState | undefined;
     callTool(params: {
         serverName: string;
         toolName: string;
@@ -122,4 +174,55 @@ declare class McpDoctorService {
     inspect(name?: string): Promise<McpDoctorReport[]>;
 }
 
-export { type McpCatalogFilter, McpClientFactory, type McpConfigReconcileResult, type McpDoctorReport, McpDoctorService, type McpLifecycleState, McpRegistryService, McpServerLifecycleManager, type McpServerRecord, type McpServerWarmResult, type McpToolCatalogEntry, buildQualifiedMcpToolName, getMcpServer, isServerAccessibleToAgent, listMcpServers, normalizeMcpServerName, readDefaultAgentId, sanitizeMcpSegment };
+declare class McpDoctorFacade {
+    private readonly options;
+    private readonly doctorService;
+    constructor(options: {
+        getConfig: () => Config;
+        registryService?: McpRegistryService;
+    });
+    inspect(name?: string): Promise<McpDoctorReport[]>;
+    inspectOne(name: string): Promise<McpDoctorReport | null>;
+}
+
+declare class McpInstallTemplateMaterializer {
+    materialize(params: McpMaterializeInstallParams): {
+        name: string;
+        definition: McpServerDefinition;
+    };
+    private applyInputs;
+    private mergeScope;
+    private mergeMetadata;
+}
+
+declare class McpMutationService {
+    private readonly options;
+    private readonly materializer;
+    constructor(options: {
+        getConfig: () => Config;
+        saveConfig: (config: Config) => void;
+        materializer?: McpInstallTemplateMaterializer;
+    });
+    listServerNames(): string[];
+    addServer(name: string, definition: McpServerDefinition): McpMutationResult;
+    updateServer(name: string, definition: McpServerDefinition): McpMutationResult;
+    removeServer(name: string): McpMutationResult;
+    toggleEnabled(name: string, enabled: boolean): McpMutationResult;
+    installFromTemplate(params: Omit<McpMaterializeInstallParams, "template"> & {
+        template: McpMarketplaceInstallTemplate;
+    }): McpMutationResult;
+    duplicateServer(sourceName: string, targetName: string): McpMutationResult;
+    renameServer(sourceName: string, targetName: string): McpMutationResult;
+}
+
+declare class McpInstalledViewService {
+    private readonly options;
+    private readonly registryService;
+    constructor(options: {
+        getConfig: () => Config;
+        registryService?: McpRegistryService;
+    });
+    listInstalled(): McpInstalledRecord[];
+}
+
+export { type McpCatalogFilter, McpClientFactory, type McpConfigReconcileResult, McpDoctorFacade, type McpDoctorReport, McpDoctorService, McpInstallTemplateMaterializer, type McpInstalledRecord, McpInstalledViewService, type McpLifecycleState, type McpMarketplaceInputField, type McpMarketplaceInstallTemplate, type McpMarketplaceTransportType, type McpMaterializeInstallParams, type McpMutationResult, McpMutationService, McpRegistryService, McpServerLifecycleManager, type McpServerRecord, type McpServerWarmResult, type McpToolCatalogEntry, buildQualifiedMcpToolName, getMcpServer, isServerAccessibleToAgent, listMcpServers, normalizeMcpServerName, readDefaultAgentId, sanitizeMcpSegment };

package/dist/index.js

@@ -151,6 +151,13 @@ var McpServerLifecycleManager = class {
   getCachedCatalog(serverName) {
     return this.readyConnections.get(serverName)?.tools ?? [];
   }
+  getCachedState(serverName) {
+    const ready = this.readyConnections.get(serverName);
+    if (!ready) {
+      return void 0;
+    }
+    return this.stripConnection(ready);
+  }
   async callTool(record, toolName, args) {
     const connection = await this.ensureConnection(record);
     const result = await connection.client.callTool({
@@ -376,6 +383,9 @@ var McpRegistryService = class {
       })
     ).flatMap((record) => this.lifecycleManager.getCachedCatalog(record.name)).sort((left, right) => left.qualifiedName.localeCompare(right.qualifiedName));
   }
+  getCachedState(serverName) {
+    return this.lifecycleManager.getCachedState(serverName);
+  }
   async callTool(params) {
     const server = this.getServer(params.serverName);
     if (!server) {
@@ -437,9 +447,270 @@ var McpDoctorService = class {
     );
   }
 };
+
+// src/doctor/mcp-doctor-facade.ts
+var McpDoctorFacade = class {
+  constructor(options) {
+    this.options = options;
+    this.doctorService = new McpDoctorService({
+      getConfig: this.options.getConfig,
+      registryService: this.options.registryService
+    });
+  }
+  doctorService;
+  async inspect(name) {
+    return await this.doctorService.inspect(name);
+  }
+  async inspectOne(name) {
+    const reports = await this.inspect(name);
+    return reports[0] ?? null;
+  }
+};
+
+// src/install/mcp-install-template-materializer.ts
+var McpInstallTemplateMaterializer = class {
+  materialize(params) {
+    const name = normalizeMcpServerName(params.name?.trim() || params.template.defaultName);
+    const inputs = params.inputs ?? {};
+    const definition = this.applyInputs(params.template.template, inputs);
+    definition.enabled = params.enabled ?? definition.enabled;
+    definition.scope = this.mergeScope(definition.scope, params.scope);
+    definition.metadata = this.mergeMetadata(definition.metadata, params.template, params.metadata);
+    return { name, definition };
+  }
+  applyInputs(definition, inputs) {
+    const replacer = (value) => value.replace(/\{\{\s*([A-Za-z0-9._-]+)\s*\}\}/g, (_, key) => inputs[key]?.trim() ?? "");
+    const transform = (value) => {
+      if (typeof value === "string") {
+        return replacer(value);
+      }
+      if (Array.isArray(value)) {
+        return value.map((entry) => transform(entry));
+      }
+      if (!value || typeof value !== "object") {
+        return value;
+      }
+      return Object.fromEntries(
+        Object.entries(value).map(([key, entry]) => [key, transform(entry)])
+      );
+    };
+    return transform(structuredClone(definition));
+  }
+  mergeScope(current, override) {
+    if (!override) {
+      return current;
+    }
+    const agents = Array.from(new Set((override.agents ?? current.agents ?? []).map((entry) => entry.trim()).filter(Boolean)));
+    const allAgents = override.allAgents ?? current.allAgents ?? agents.length === 0;
+    return {
+      allAgents,
+      agents: allAgents ? [] : agents
+    };
+  }
+  mergeMetadata(current, template, override) {
+    return {
+      ...current,
+      source: "marketplace",
+      catalogSlug: template.spec,
+      displayName: override?.displayName ?? current?.displayName,
+      vendor: override?.vendor ?? current?.vendor,
+      docsUrl: override?.docsUrl ?? current?.docsUrl,
+      homepage: override?.homepage ?? current?.homepage,
+      trustLevel: override?.trustLevel ?? current?.trustLevel ?? "official",
+      installedAt: override?.installedAt ?? current?.installedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      ...override ?? {}
+    };
+  }
+};
+
+// src/manage/mcp-mutation-service.ts
+var McpMutationService = class {
+  constructor(options) {
+    this.options = options;
+    this.materializer = this.options.materializer ?? new McpInstallTemplateMaterializer();
+  }
+  materializer;
+  listServerNames() {
+    return listMcpServers(this.options.getConfig()).map((record) => record.name);
+  }
+  addServer(name, definition) {
+    const normalizedName = normalizeMcpServerName(name);
+    const config = this.options.getConfig();
+    if (config.mcp.servers[normalizedName]) {
+      return {
+        changed: false,
+        name: normalizedName,
+        message: `MCP server already exists: ${normalizedName}. Use 'mcp list' or remove it first.`,
+        definition: config.mcp.servers[normalizedName]
+      };
+    }
+    config.mcp.servers[normalizedName] = definition;
+    this.options.saveConfig(config);
+    return {
+      changed: true,
+      name: normalizedName,
+      message: `Added MCP server ${normalizedName}.`,
+      definition
+    };
+  }
+  updateServer(name, definition) {
+    const normalizedName = normalizeMcpServerName(name);
+    const config = this.options.getConfig();
+    if (!config.mcp.servers[normalizedName]) {
+      return {
+        changed: false,
+        name: normalizedName,
+        message: `Unknown MCP server: ${normalizedName}`
+      };
+    }
+    config.mcp.servers[normalizedName] = definition;
+    this.options.saveConfig(config);
+    return {
+      changed: true,
+      name: normalizedName,
+      message: `Updated MCP server ${normalizedName}.`,
+      definition
+    };
+  }
+  removeServer(name) {
+    const normalizedName = normalizeMcpServerName(name);
+    const config = this.options.getConfig();
+    if (!config.mcp.servers[normalizedName]) {
+      return {
+        changed: false,
+        name: normalizedName,
+        message: `Unknown MCP server: ${normalizedName}`
+      };
+    }
+    delete config.mcp.servers[normalizedName];
+    this.options.saveConfig(config);
+    return {
+      changed: true,
+      name: normalizedName,
+      message: `Removed MCP server ${normalizedName}.`
+    };
+  }
+  toggleEnabled(name, enabled) {
+    const normalizedName = normalizeMcpServerName(name);
+    const config = this.options.getConfig();
+    const current = config.mcp.servers[normalizedName];
+    if (!current) {
+      return {
+        changed: false,
+        name: normalizedName,
+        message: `Unknown MCP server: ${normalizedName}`
+      };
+    }
+    current.enabled = enabled;
+    this.options.saveConfig(config);
+    return {
+      changed: true,
+      name: normalizedName,
+      message: `${enabled ? "Enabled" : "Disabled"} MCP server ${normalizedName}.`,
+      definition: current
+    };
+  }
+  installFromTemplate(params) {
+    const materialized = this.materializer.materialize(params);
+    return this.addServer(materialized.name, materialized.definition);
+  }
+  duplicateServer(sourceName, targetName) {
+    const source = getMcpServer(this.options.getConfig(), sourceName);
+    if (!source) {
+      return {
+        changed: false,
+        name: normalizeMcpServerName(sourceName),
+        message: `Unknown MCP server: ${normalizeMcpServerName(sourceName)}`
+      };
+    }
+    const definition = structuredClone(source.definition);
+    if (definition.metadata) {
+      definition.metadata = {
+        ...definition.metadata,
+        installedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    return this.addServer(targetName, definition);
+  }
+  renameServer(sourceName, targetName) {
+    const source = getMcpServer(this.options.getConfig(), sourceName);
+    if (!source) {
+      return {
+        changed: false,
+        name: normalizeMcpServerName(sourceName),
+        message: `Unknown MCP server: ${normalizeMcpServerName(sourceName)}`
+      };
+    }
+    const nextName = normalizeMcpServerName(targetName);
+    const config = this.options.getConfig();
+    if (source.name === nextName) {
+      return {
+        changed: false,
+        name: nextName,
+        message: `MCP server already named ${nextName}.`,
+        definition: source.definition
+      };
+    }
+    if (config.mcp.servers[nextName]) {
+      return {
+        changed: false,
+        name: nextName,
+        message: `MCP server already exists: ${nextName}. Use another name.`
+      };
+    }
+    delete config.mcp.servers[source.name];
+    config.mcp.servers[nextName] = source.definition;
+    this.options.saveConfig(config);
+    return {
+      changed: true,
+      name: nextName,
+      message: `Renamed MCP server ${source.name} -> ${nextName}.`,
+      definition: source.definition
+    };
+  }
+};
+
+// src/view/mcp-installed-view-service.ts
+var McpInstalledViewService = class {
+  constructor(options) {
+    this.options = options;
+    this.registryService = this.options.registryService ?? new McpRegistryService({
+      getConfig: this.options.getConfig
+    });
+  }
+  registryService;
+  listInstalled() {
+    return this.registryService.listServers().map((server) => {
+      const metadata = server.definition.metadata;
+      const cached = this.registryService.getCachedState(server.name);
+      return {
+        name: server.name,
+        enabled: server.definition.enabled,
+        transport: server.definition.transport.type,
+        scope: server.definition.scope,
+        source: metadata?.source === "marketplace" ? "marketplace" : "manual",
+        catalogSlug: metadata?.catalogSlug,
+        displayName: metadata?.displayName,
+        vendor: metadata?.vendor,
+        docsUrl: metadata?.docsUrl,
+        homepage: metadata?.homepage,
+        trustLevel: metadata?.trustLevel,
+        installedAt: metadata?.installedAt,
+        accessible: cached?.clientReady,
+        toolCount: cached?.tools.length,
+        lastReadyAt: cached?.lastReadyAt,
+        lastError: cached?.lastError
+      };
+    });
+  }
+};
 export {
   McpClientFactory,
+  McpDoctorFacade,
   McpDoctorService,
+  McpInstallTemplateMaterializer,
+  McpInstalledViewService,
+  McpMutationService,
   McpRegistryService,
   McpServerLifecycleManager,
   buildQualifiedMcpToolName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/mcp",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "private": false,
   "description": "Platform-level MCP registry, lifecycle, and diagnostics for NextClaw.",
   "type": "module",