@getmcp/core 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 getmcp Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,93 @@
+# @getmcp/core
+
+Core types, schemas, and validation for the getmcp canonical configuration format. Aligned with [FastMCP](https://github.com/jlowin/fastmcp)'s standard.
+
+## Install
+
+```bash
+npm install @getmcp/core
+```
+
+## Usage
+
+### Schema Validation
+
+All schemas use [Zod](https://zod.dev) for runtime validation:
+
+```ts
+import { StdioServerConfig, RemoteServerConfig, CanonicalMCPConfig } from "@getmcp/core";
+
+// Validate a stdio server config
+const result = StdioServerConfig.safeParse({
+  command: "npx",
+  args: ["-y", "@modelcontextprotocol/server-github"],
+  env: { GITHUB_TOKEN: "..." },
+});
+
+if (result.success) {
+  console.log(result.data); // typed StdioServerConfigType
+}
+
+// Validate a remote server config
+RemoteServerConfig.parse({
+  url: "https://mcp.example.com/sse",
+  headers: { Authorization: "Bearer token" },
+});
+
+// Validate a full canonical config
+CanonicalMCPConfig.parse({
+  mcpServers: {
+    github: { command: "npx", args: ["-y", "@modelcontextprotocol/server-github"] },
+    sentry: { url: "https://mcp.sentry.dev/sse" },
+  },
+});
+```
+
+### Type Guards
+
+```ts
+import { isStdioConfig, isRemoteConfig, inferTransport } from "@getmcp/core";
+
+const config = { command: "npx", args: ["server"] };
+
+isStdioConfig(config);   // true
+isRemoteConfig(config);  // false
+inferTransport(config);  // "stdio"
+```
+
+### TypeScript Types
+
+Types are inferred from Zod schemas:
+
+```ts
+import type {
+  StdioServerConfigType,
+  RemoteServerConfigType,
+  ServerConfigType,
+  RegistryEntryType,
+  AppIdType,
+  ConfigGenerator,
+  AppMetadata,
+} from "@getmcp/core";
+```
+
+## Schemas
+
+| Schema | Description |
+|--------|-------------|
+| `StdioServerConfig` | Local server with `command`, `args`, `env` |
+| `RemoteServerConfig` | Remote server with `url`, `headers` |
+| `ServerConfig` | Union of stdio and remote |
+| `LooseServerConfig` | Passthrough schema for unknown fields |
+| `CanonicalMCPConfig` | Top-level `{ mcpServers: { ... } }` |
+| `RegistryEntry` | Server definition for the registry |
+| `AppId` | Enum of supported app identifiers |
+| `TransportType` | `"stdio" | "sse" | "streamable-http"` |
+
+## Supported Apps
+
+`AppId` includes: `claude-desktop`, `claude-code`, `vscode`, `cursor`, `cline`, `roo-code`, `goose`, `windsurf`, `opencode`, `zed`
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @getmcp/core
+ *
+ * Core types, schemas, and validation for the getmcp canonical configuration format.
+ * Aligned with FastMCP's CanonicalMCPConfig standard.
+ */
+export { TransportType, StdioServerConfig, RemoteServerConfig, ServerConfig, LooseServerConfig, CanonicalMCPConfig, PlatformOverride, Runtime, RegistryEntry, AppId, } from "./schemas.js";
+export type { TransportType as TransportTypeType, StdioServerConfig as StdioServerConfigType, RemoteServerConfig as RemoteServerConfigType, ServerConfig as ServerConfigType, LooseServerConfig as LooseServerConfigType, CanonicalMCPConfig as CanonicalMCPConfigType, PlatformOverride as PlatformOverrideType, Runtime as RuntimeType, RegistryEntry as RegistryEntryType, AppId as AppIdType, AppMetadata, ConfigGenerator, } from "./types.js";
+export { isStdioConfig, isRemoteConfig, inferTransport } from "./utils.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,OAAO,EACP,aAAa,EACb,KAAK,GACN,MAAM,cAAc,CAAC;AAGtB,YAAY,EACV,aAAa,IAAI,iBAAiB,EAClC,iBAAiB,IAAI,qBAAqB,EAC1C,kBAAkB,IAAI,sBAAsB,EAC5C,YAAY,IAAI,gBAAgB,EAChC,iBAAiB,IAAI,qBAAqB,EAC1C,kBAAkB,IAAI,sBAAsB,EAC5C,gBAAgB,IAAI,oBAAoB,EACxC,OAAO,IAAI,WAAW,EACtB,aAAa,IAAI,iBAAiB,EAClC,KAAK,IAAI,SAAS,EAClB,WAAW,EACX,eAAe,GAChB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,11 @@
+/**
+ * @getmcp/core
+ *
+ * Core types, schemas, and validation for the getmcp canonical configuration format.
+ * Aligned with FastMCP's CanonicalMCPConfig standard.
+ */
+// Zod schemas (runtime validation)
+export { TransportType, StdioServerConfig, RemoteServerConfig, ServerConfig, LooseServerConfig, CanonicalMCPConfig, PlatformOverride, Runtime, RegistryEntry, AppId, } from "./schemas.js";
+// Utilities
+export { isStdioConfig, isRemoteConfig, inferTransport } from "./utils.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,mCAAmC;AACnC,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,OAAO,EACP,aAAa,EACb,KAAK,GACN,MAAM,cAAc,CAAC;AAkBtB,YAAY;AACZ,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}

package/dist/schemas.d.ts

@@ -0,0 +1,556 @@
+/**
+ * Zod schemas for the canonical MCP configuration format.
+ *
+ * Aligned with FastMCP's CanonicalMCPConfig:
+ *   - Root key: "mcpServers"
+ *   - Stdio: command, args, env, cwd, timeout, description
+ *   - Remote: url, transport, headers, timeout, description
+ *
+ * Extended with registry metadata for the getmcp ecosystem.
+ */
+import { z } from "zod";
+export declare const TransportType: z.ZodEnum<["stdio", "http", "streamable-http", "sse"]>;
+/**
+ * Stdio transport server configuration.
+ * This is the most common format — runs a local process.
+ */
+export declare const StdioServerConfig: z.ZodObject<{
+    /** The executable command (e.g. "npx", "uvx", "docker", "node") */
+    command: z.ZodString;
+    /** Arguments passed to the command */
+    args: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    /** Environment variables for the process */
+    env: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    /** Transport type — always "stdio" for this variant */
+    transport: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"stdio">>>;
+    /** Working directory for command execution */
+    cwd: z.ZodOptional<z.ZodString>;
+    /** Maximum response time in milliseconds */
+    timeout: z.ZodOptional<z.ZodNumber>;
+    /** Human-readable server description */
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+    transport: "stdio";
+    cwd?: string | undefined;
+    timeout?: number | undefined;
+    description?: string | undefined;
+}, {
+    command: string;
+    args?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+    transport?: "stdio" | undefined;
+    cwd?: string | undefined;
+    timeout?: number | undefined;
+    description?: string | undefined;
+}>;
+/**
+ * Remote transport server configuration.
+ * Used for HTTP, Streamable HTTP, and SSE servers.
+ */
+export declare const RemoteServerConfig: z.ZodObject<{
+    /** The server URL */
+    url: z.ZodString;
+    /** Transport type — inferred from URL if not provided */
+    transport: z.ZodOptional<z.ZodEnum<["http", "streamable-http", "sse"]>>;
+    /** HTTP headers to include with requests */
+    headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    /** Maximum response time in milliseconds */
+    timeout: z.ZodOptional<z.ZodNumber>;
+    /** Human-readable server description */
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    headers: Record<string, string>;
+    transport?: "http" | "streamable-http" | "sse" | undefined;
+    timeout?: number | undefined;
+    description?: string | undefined;
+}, {
+    url: string;
+    transport?: "http" | "streamable-http" | "sse" | undefined;
+    timeout?: number | undefined;
+    description?: string | undefined;
+    headers?: Record<string, string> | undefined;
+}>;
+/**
+ * Union of both transport configurations.
+ * Discriminated by the presence of `command` (stdio) vs `url` (remote).
+ */
+export declare const ServerConfig: z.ZodDiscriminatedUnion<"transport", [z.ZodObject<{
+    command: z.ZodString;
+    args: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    env: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    cwd: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+} & {
+    transport: z.ZodLiteral<"stdio">;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+    transport: "stdio";
+    cwd?: string | undefined;
+    timeout?: number | undefined;
+    description?: string | undefined;
+}, {
+    command: string;
+    transport: "stdio";
+    args?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+    cwd?: string | undefined;
+    timeout?: number | undefined;
+    description?: string | undefined;
+}>, z.ZodObject<{
+    url: z.ZodString;
+    headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+} & {
+    transport: z.ZodLiteral<"http">;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    transport: "http";
+    headers: Record<string, string>;
+    timeout?: number | undefined;
+    description?: string | undefined;
+}, {
+    url: string;
+    transport: "http";
+    timeout?: number | undefined;
+    description?: string | undefined;
+    headers?: Record<string, string> | undefined;
+}>, z.ZodObject<{
+    url: z.ZodString;
+    headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+} & {
+    transport: z.ZodLiteral<"streamable-http">;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    transport: "streamable-http";
+    headers: Record<string, string>;
+    timeout?: number | undefined;
+    description?: string | undefined;
+}, {
+    url: string;
+    transport: "streamable-http";
+    timeout?: number | undefined;
+    description?: string | undefined;
+    headers?: Record<string, string> | undefined;
+}>, z.ZodObject<{
+    url: z.ZodString;
+    headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+} & {
+    transport: z.ZodLiteral<"sse">;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    transport: "sse";
+    headers: Record<string, string>;
+    timeout?: number | undefined;
+    description?: string | undefined;
+}, {
+    url: string;
+    transport: "sse";
+    timeout?: number | undefined;
+    description?: string | undefined;
+    headers?: Record<string, string> | undefined;
+}>]>;
+/**
+ * Loose server config — accepts either stdio or remote without requiring
+ * an explicit transport field. Uses the presence of `command` vs `url` to
+ * determine the type.
+ */
+export declare const LooseServerConfig: z.ZodUnion<[z.ZodObject<{
+    /** The executable command (e.g. "npx", "uvx", "docker", "node") */
+    command: z.ZodString;
+    /** Arguments passed to the command */
+    args: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    /** Environment variables for the process */
+    env: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    /** Transport type — always "stdio" for this variant */
+    transport: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"stdio">>>;
+    /** Working directory for command execution */
+    cwd: z.ZodOptional<z.ZodString>;
+    /** Maximum response time in milliseconds */
+    timeout: z.ZodOptional<z.ZodNumber>;
+    /** Human-readable server description */
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+    transport: "stdio";
+    cwd?: string | undefined;
+    timeout?: number | undefined;
+    description?: string | undefined;
+}, {
+    command: string;
+    args?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+    transport?: "stdio" | undefined;
+    cwd?: string | undefined;
+    timeout?: number | undefined;
+    description?: string | undefined;
+}>, z.ZodObject<{
+    /** The server URL */
+    url: z.ZodString;
+    /** Transport type — inferred from URL if not provided */
+    transport: z.ZodOptional<z.ZodEnum<["http", "streamable-http", "sse"]>>;
+    /** HTTP headers to include with requests */
+    headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    /** Maximum response time in milliseconds */
+    timeout: z.ZodOptional<z.ZodNumber>;
+    /** Human-readable server description */
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    headers: Record<string, string>;
+    transport?: "http" | "streamable-http" | "sse" | undefined;
+    timeout?: number | undefined;
+    description?: string | undefined;
+}, {
+    url: string;
+    transport?: "http" | "streamable-http" | "sse" | undefined;
+    timeout?: number | undefined;
+    description?: string | undefined;
+    headers?: Record<string, string> | undefined;
+}>]>;
+/**
+ * The canonical MCP configuration format.
+ * This mirrors FastMCP's CanonicalMCPConfig: { mcpServers: { name: config } }
+ */
+export declare const CanonicalMCPConfig: z.ZodObject<{
+    mcpServers: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        /** The executable command (e.g. "npx", "uvx", "docker", "node") */
+        command: z.ZodString;
+        /** Arguments passed to the command */
+        args: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        /** Environment variables for the process */
+        env: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        /** Transport type — always "stdio" for this variant */
+        transport: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"stdio">>>;
+        /** Working directory for command execution */
+        cwd: z.ZodOptional<z.ZodString>;
+        /** Maximum response time in milliseconds */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /** Human-readable server description */
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+        transport: "stdio";
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+        description?: string | undefined;
+    }, {
+        command: string;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        transport?: "stdio" | undefined;
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+        description?: string | undefined;
+    }>, z.ZodObject<{
+        /** The server URL */
+        url: z.ZodString;
+        /** Transport type — inferred from URL if not provided */
+        transport: z.ZodOptional<z.ZodEnum<["http", "streamable-http", "sse"]>>;
+        /** HTTP headers to include with requests */
+        headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        /** Maximum response time in milliseconds */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /** Human-readable server description */
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        headers: Record<string, string>;
+        transport?: "http" | "streamable-http" | "sse" | undefined;
+        timeout?: number | undefined;
+        description?: string | undefined;
+    }, {
+        url: string;
+        transport?: "http" | "streamable-http" | "sse" | undefined;
+        timeout?: number | undefined;
+        description?: string | undefined;
+        headers?: Record<string, string> | undefined;
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    mcpServers: Record<string, {
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+        transport: "stdio";
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+        description?: string | undefined;
+    } | {
+        url: string;
+        headers: Record<string, string>;
+        transport?: "http" | "streamable-http" | "sse" | undefined;
+        timeout?: number | undefined;
+        description?: string | undefined;
+    }>;
+}, {
+    mcpServers: Record<string, {
+        command: string;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        transport?: "stdio" | undefined;
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+        description?: string | undefined;
+    } | {
+        url: string;
+        transport?: "http" | "streamable-http" | "sse" | undefined;
+        timeout?: number | undefined;
+        description?: string | undefined;
+        headers?: Record<string, string> | undefined;
+    }>;
+}>;
+/** Platform-specific command overrides for stdio servers */
+export declare const PlatformOverride: z.ZodObject<{
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    command?: string | undefined;
+    args?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+    cwd?: string | undefined;
+}, {
+    command?: string | undefined;
+    args?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+    cwd?: string | undefined;
+}>;
+export declare const Runtime: z.ZodEnum<["node", "python", "docker", "binary"]>;
+/**
+ * A full MCP server registry entry.
+ * Contains the canonical server config plus metadata for discovery,
+ * display, and multi-platform support.
+ */
+export declare const RegistryEntry: z.ZodObject<{
+    /** Unique identifier (e.g. "github-mcp-server") */
+    id: z.ZodString;
+    /** Display name (e.g. "GitHub MCP Server") */
+    name: z.ZodString;
+    /** What this server does */
+    description: z.ZodString;
+    /** The canonical server configuration */
+    config: z.ZodUnion<[z.ZodObject<{
+        /** The executable command (e.g. "npx", "uvx", "docker", "node") */
+        command: z.ZodString;
+        /** Arguments passed to the command */
+        args: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        /** Environment variables for the process */
+        env: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        /** Transport type — always "stdio" for this variant */
+        transport: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"stdio">>>;
+        /** Working directory for command execution */
+        cwd: z.ZodOptional<z.ZodString>;
+        /** Maximum response time in milliseconds */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /** Human-readable server description */
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+        transport: "stdio";
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+        description?: string | undefined;
+    }, {
+        command: string;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        transport?: "stdio" | undefined;
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+        description?: string | undefined;
+    }>, z.ZodObject<{
+        /** The server URL */
+        url: z.ZodString;
+        /** Transport type — inferred from URL if not provided */
+        transport: z.ZodOptional<z.ZodEnum<["http", "streamable-http", "sse"]>>;
+        /** HTTP headers to include with requests */
+        headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        /** Maximum response time in milliseconds */
+        timeout: z.ZodOptional<z.ZodNumber>;
+        /** Human-readable server description */
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        headers: Record<string, string>;
+        transport?: "http" | "streamable-http" | "sse" | undefined;
+        timeout?: number | undefined;
+        description?: string | undefined;
+    }, {
+        url: string;
+        transport?: "http" | "streamable-http" | "sse" | undefined;
+        timeout?: number | undefined;
+        description?: string | undefined;
+        headers?: Record<string, string> | undefined;
+    }>]>;
+    /** Package name (npm or pypi) */
+    package: z.ZodOptional<z.ZodString>;
+    /** Runtime used to execute the server */
+    runtime: z.ZodOptional<z.ZodEnum<["node", "python", "docker", "binary"]>>;
+    /** Source code repository URL */
+    repository: z.ZodOptional<z.ZodString>;
+    /** Homepage URL */
+    homepage: z.ZodOptional<z.ZodString>;
+    /** Author or organization */
+    author: z.ZodOptional<z.ZodString>;
+    /** Discovery categories (e.g. ["developer-tools", "git"]) */
+    categories: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    /** Environment variables that the user MUST provide */
+    requiredEnvVars: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    /** Platform-specific overrides (e.g. Windows needs cmd /c wrapper) */
+    windows: z.ZodOptional<z.ZodObject<{
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        cwd: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        command?: string | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    }, {
+        command?: string | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    }>>;
+    linux: z.ZodOptional<z.ZodObject<{
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        cwd: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        command?: string | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    }, {
+        command?: string | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    }>>;
+    macos: z.ZodOptional<z.ZodObject<{
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        cwd: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        command?: string | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    }, {
+        command?: string | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    id: string;
+    name: string;
+    config: {
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+        transport: "stdio";
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+        description?: string | undefined;
+    } | {
+        url: string;
+        headers: Record<string, string>;
+        transport?: "http" | "streamable-http" | "sse" | undefined;
+        timeout?: number | undefined;
+        description?: string | undefined;
+    };
+    categories: string[];
+    requiredEnvVars: string[];
+    package?: string | undefined;
+    runtime?: "node" | "python" | "docker" | "binary" | undefined;
+    repository?: string | undefined;
+    homepage?: string | undefined;
+    author?: string | undefined;
+    windows?: {
+        command?: string | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    } | undefined;
+    linux?: {
+        command?: string | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    } | undefined;
+    macos?: {
+        command?: string | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    } | undefined;
+}, {
+    description: string;
+    id: string;
+    name: string;
+    config: {
+        command: string;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        transport?: "stdio" | undefined;
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+        description?: string | undefined;
+    } | {
+        url: string;
+        transport?: "http" | "streamable-http" | "sse" | undefined;
+        timeout?: number | undefined;
+        description?: string | undefined;
+        headers?: Record<string, string> | undefined;
+    };
+    package?: string | undefined;
+    runtime?: "node" | "python" | "docker" | "binary" | undefined;
+    repository?: string | undefined;
+    homepage?: string | undefined;
+    author?: string | undefined;
+    categories?: string[] | undefined;
+    requiredEnvVars?: string[] | undefined;
+    windows?: {
+        command?: string | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    } | undefined;
+    linux?: {
+        command?: string | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    } | undefined;
+    macos?: {
+        command?: string | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        cwd?: string | undefined;
+    } | undefined;
+}>;
+export declare const AppId: z.ZodEnum<["claude-desktop", "claude-code", "vscode", "cursor", "cline", "roo-code", "goose", "windsurf", "opencode", "zed"]>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,aAAa,wDAKxB,CAAC;AAMH;;;GAGG;AACH,eAAO,MAAM,iBAAiB;IAC5B,mEAAmE;;IAGnE,sCAAsC;;IAGtC,4CAA4C;;IAG5C,uDAAuD;;IAGvD,8CAA8C;;IAG9C,4CAA4C;;IAG5C,wCAAwC;;;;;;;;;;;;;;;;;;EAExC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;IAC7B,qBAAqB;;IAGrB,yDAAyD;;IAKzD,4CAA4C;;IAG5C,4CAA4C;;IAG5C,wCAAwC;;;;;;;;;;;;;;EAExC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKvB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;IA7D5B,mEAAmE;;IAGnE,sCAAsC;;IAGtC,4CAA4C;;IAG5C,uDAAuD;;IAGvD,8CAA8C;;IAG9C,4CAA4C;;IAG5C,wCAAwC;;;;;;;;;;;;;;;;;;;IASxC,qBAAqB;;IAGrB,yDAAyD;;IAKzD,4CAA4C;;IAG5C,4CAA4C;;IAG5C,wCAAwC;;;;;;;;;;;;;;IAuBxC,CAAC;AAMH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;QA1E7B,mEAAmE;;QAGnE,sCAAsC;;QAGtC,4CAA4C;;QAG5C,uDAAuD;;QAGvD,8CAA8C;;QAG9C,4CAA4C;;QAG5C,wCAAwC;;;;;;;;;;;;;;;;;;;QASxC,qBAAqB;;QAGrB,yDAAyD;;QAKzD,4CAA4C;;QAG5C,4CAA4C;;QAG5C,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCxC,CAAC;AAMH,4DAA4D;AAC5D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;EAK3B,CAAC;AAMH,eAAO,MAAM,OAAO,mDAAiD,CAAC;AAEtE;;;;GAIG;AACH,eAAO,MAAM,aAAa;IACxB,mDAAmD;;IAGnD,8CAA8C;;IAG9C,4BAA4B;;IAG5B,yCAAyC;;QA/GzC,mEAAmE;;QAGnE,sCAAsC;;QAGtC,4CAA4C;;QAG5C,uDAAuD;;QAGvD,8CAA8C;;QAG9C,4CAA4C;;QAG5C,wCAAwC;;;;;;;;;;;;;;;;;;;QASxC,qBAAqB;;QAGrB,yDAAyD;;QAKzD,4CAA4C;;QAG5C,4CAA4C;;QAG5C,wCAAwC;;;;;;;;;;;;;;;IAyExC,iCAAiC;;IAGjC,yCAAyC;;IAGzC,iCAAiC;;IAGjC,mBAAmB;;IAGnB,6BAA6B;;IAG7B,6DAA6D;;IAG7D,uDAAuD;;IAGvD,sEAAsE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAItE,CAAC;AAMH,eAAO,MAAM,KAAK,+HAWhB,CAAC"}

package/dist/schemas.js

@@ -0,0 +1,153 @@
+/**
+ * Zod schemas for the canonical MCP configuration format.
+ *
+ * Aligned with FastMCP's CanonicalMCPConfig:
+ *   - Root key: "mcpServers"
+ *   - Stdio: command, args, env, cwd, timeout, description
+ *   - Remote: url, transport, headers, timeout, description
+ *
+ * Extended with registry metadata for the getmcp ecosystem.
+ */
+import { z } from "zod";
+// ---------------------------------------------------------------------------
+// Transport types
+// ---------------------------------------------------------------------------
+export const TransportType = z.enum([
+    "stdio",
+    "http",
+    "streamable-http",
+    "sse",
+]);
+// ---------------------------------------------------------------------------
+// Canonical server configs (FastMCP-compatible)
+// ---------------------------------------------------------------------------
+/**
+ * Stdio transport server configuration.
+ * This is the most common format — runs a local process.
+ */
+export const StdioServerConfig = z.object({
+    /** The executable command (e.g. "npx", "uvx", "docker", "node") */
+    command: z.string().min(1),
+    /** Arguments passed to the command */
+    args: z.array(z.string()).optional().default([]),
+    /** Environment variables for the process */
+    env: z.record(z.string(), z.string()).optional().default({}),
+    /** Transport type — always "stdio" for this variant */
+    transport: z.literal("stdio").optional().default("stdio"),
+    /** Working directory for command execution */
+    cwd: z.string().optional(),
+    /** Maximum response time in milliseconds */
+    timeout: z.number().int().positive().optional(),
+    /** Human-readable server description */
+    description: z.string().optional(),
+});
+/**
+ * Remote transport server configuration.
+ * Used for HTTP, Streamable HTTP, and SSE servers.
+ */
+export const RemoteServerConfig = z.object({
+    /** The server URL */
+    url: z.string().url(),
+    /** Transport type — inferred from URL if not provided */
+    transport: z
+        .enum(["http", "streamable-http", "sse"])
+        .optional(),
+    /** HTTP headers to include with requests */
+    headers: z.record(z.string(), z.string()).optional().default({}),
+    /** Maximum response time in milliseconds */
+    timeout: z.number().int().positive().optional(),
+    /** Human-readable server description */
+    description: z.string().optional(),
+});
+/**
+ * Union of both transport configurations.
+ * Discriminated by the presence of `command` (stdio) vs `url` (remote).
+ */
+export const ServerConfig = z.discriminatedUnion("transport", [
+    StdioServerConfig.extend({ transport: z.literal("stdio") }),
+    RemoteServerConfig.extend({ transport: z.literal("http") }),
+    RemoteServerConfig.extend({ transport: z.literal("streamable-http") }),
+    RemoteServerConfig.extend({ transport: z.literal("sse") }),
+]);
+/**
+ * Loose server config — accepts either stdio or remote without requiring
+ * an explicit transport field. Uses the presence of `command` vs `url` to
+ * determine the type.
+ */
+export const LooseServerConfig = z.union([
+    StdioServerConfig,
+    RemoteServerConfig,
+]);
+// ---------------------------------------------------------------------------
+// Canonical MCP config (FastMCP-compatible root format)
+// ---------------------------------------------------------------------------
+/**
+ * The canonical MCP configuration format.
+ * This mirrors FastMCP's CanonicalMCPConfig: { mcpServers: { name: config } }
+ */
+export const CanonicalMCPConfig = z.object({
+    mcpServers: z.record(z.string(), LooseServerConfig),
+});
+// ---------------------------------------------------------------------------
+// Platform overrides
+// ---------------------------------------------------------------------------
+/** Platform-specific command overrides for stdio servers */
+export const PlatformOverride = z.object({
+    command: z.string().min(1).optional(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    cwd: z.string().optional(),
+});
+// ---------------------------------------------------------------------------
+// Registry entry (our metadata layer on top of canonical config)
+// ---------------------------------------------------------------------------
+export const Runtime = z.enum(["node", "python", "docker", "binary"]);
+/**
+ * A full MCP server registry entry.
+ * Contains the canonical server config plus metadata for discovery,
+ * display, and multi-platform support.
+ */
+export const RegistryEntry = z.object({
+    /** Unique identifier (e.g. "github-mcp-server") */
+    id: z.string().min(1).regex(/^[a-z0-9-]+$/, "ID must be lowercase alphanumeric with hyphens"),
+    /** Display name (e.g. "GitHub MCP Server") */
+    name: z.string().min(1),
+    /** What this server does */
+    description: z.string().min(1),
+    /** The canonical server configuration */
+    config: LooseServerConfig,
+    /** Package name (npm or pypi) */
+    package: z.string().optional(),
+    /** Runtime used to execute the server */
+    runtime: Runtime.optional(),
+    /** Source code repository URL */
+    repository: z.string().url().optional(),
+    /** Homepage URL */
+    homepage: z.string().url().optional(),
+    /** Author or organization */
+    author: z.string().optional(),
+    /** Discovery categories (e.g. ["developer-tools", "git"]) */
+    categories: z.array(z.string()).optional().default([]),
+    /** Environment variables that the user MUST provide */
+    requiredEnvVars: z.array(z.string()).optional().default([]),
+    /** Platform-specific overrides (e.g. Windows needs cmd /c wrapper) */
+    windows: PlatformOverride.optional(),
+    linux: PlatformOverride.optional(),
+    macos: PlatformOverride.optional(),
+});
+// ---------------------------------------------------------------------------
+// App identifiers (all supported target apps)
+// ---------------------------------------------------------------------------
+export const AppId = z.enum([
+    "claude-desktop",
+    "claude-code",
+    "vscode",
+    "cursor",
+    "cline",
+    "roo-code",
+    "goose",
+    "windsurf",
+    "opencode",
+    "zed",
+]);
+//# sourceMappingURL=schemas.js.map

package/dist/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -0,0 +1,63 @@
+/**
+ * TypeScript types inferred from Zod schemas.
+ *
+ * These types are the single source of truth — derived directly from
+ * the schemas so they can never drift out of sync.
+ */
+import { z } from "zod";
+import { TransportType, StdioServerConfig, RemoteServerConfig, ServerConfig, LooseServerConfig, CanonicalMCPConfig, PlatformOverride, Runtime, RegistryEntry, AppId } from "./schemas.js";
+export type TransportType = z.infer<typeof TransportType>;
+export type StdioServerConfig = z.infer<typeof StdioServerConfig>;
+export type RemoteServerConfig = z.infer<typeof RemoteServerConfig>;
+export type ServerConfig = z.infer<typeof ServerConfig>;
+export type LooseServerConfig = z.infer<typeof LooseServerConfig>;
+export type CanonicalMCPConfig = z.infer<typeof CanonicalMCPConfig>;
+export type PlatformOverride = z.infer<typeof PlatformOverride>;
+export type Runtime = z.infer<typeof Runtime>;
+export type RegistryEntry = z.infer<typeof RegistryEntry>;
+export type AppId = z.infer<typeof AppId>;
+/**
+ * Metadata about a target application.
+ * Used by the CLI for auto-detection and display.
+ */
+export interface AppMetadata {
+    /** Unique app identifier */
+    id: AppId;
+    /** Human-readable app name */
+    name: string;
+    /** Brief description of the app */
+    description: string;
+    /** Config file path pattern (with platform placeholders) */
+    configPaths: {
+        win32?: string;
+        darwin?: string;
+        linux?: string;
+    };
+    /** Config file format */
+    configFormat: "json" | "jsonc" | "yaml";
+    /** URL to the app's MCP documentation */
+    docsUrl: string;
+}
+/**
+ * A config generator transforms canonical server configs into
+ * app-specific configuration format.
+ */
+export interface ConfigGenerator {
+    /** The target app metadata */
+    app: AppMetadata;
+    /**
+     * Generate the app-specific config object for a single server.
+     * Returns the full config structure including the root key.
+     */
+    generate(serverName: string, config: LooseServerConfig): Record<string, unknown>;
+    /**
+     * Generate the app-specific config for multiple servers.
+     * Returns the full config structure including the root key.
+     */
+    generateAll(servers: Record<string, LooseServerConfig>): Record<string, unknown>;
+    /**
+     * Serialize the config object to a string (JSON, YAML, etc.)
+     */
+    serialize(config: Record<string, unknown>): string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,OAAO,EACP,aAAa,EACb,KAAK,EACN,MAAM,cAAc,CAAC;AAMtB,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAM1D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAClE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACpE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AACxD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAMlE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAMpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAChE,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAC;AAC9C,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC;AAM1C;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,4BAA4B;IAC5B,EAAE,EAAE,KAAK,CAAC;IAEV,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAC;IAEb,mCAAmC;IACnC,WAAW,EAAE,MAAM,CAAC;IAEpB,4DAA4D;IAC5D,WAAW,EAAE;QACX,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IAEF,yBAAyB;IACzB,YAAY,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAExC,yCAAyC;IACzC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,8BAA8B;IAC9B,GAAG,EAAE,WAAW,CAAC;IAEjB;;;OAGG;IACH,QAAQ,CACN,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,iBAAiB,GACxB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE3B;;;OAGG;IACH,WAAW,CACT,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GACzC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE3B;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC;CACpD"}

package/dist/types.js

@@ -0,0 +1,8 @@
+/**
+ * TypeScript types inferred from Zod schemas.
+ *
+ * These types are the single source of truth — derived directly from
+ * the schemas so they can never drift out of sync.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/utils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Utility functions for working with canonical MCP server configs.
+ */
+import type { LooseServerConfig, StdioServerConfig, RemoteServerConfig, TransportType } from "./types.js";
+/**
+ * Type guard: checks if a config is a stdio transport config.
+ */
+export declare function isStdioConfig(config: LooseServerConfig): config is StdioServerConfig;
+/**
+ * Type guard: checks if a config is a remote transport config.
+ */
+export declare function isRemoteConfig(config: LooseServerConfig): config is RemoteServerConfig;
+/**
+ * Infer the transport type from a server config.
+ *
+ * For stdio configs, always returns "stdio".
+ * For remote configs, uses the explicit `transport` field if set,
+ * otherwise infers from the URL (paths containing "/sse" → "sse", else "http").
+ */
+export declare function inferTransport(config: LooseServerConfig): TransportType;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE1G;;GAEG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,iBAAiB,GACxB,MAAM,IAAI,iBAAiB,CAE7B;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,iBAAiB,GACxB,MAAM,IAAI,kBAAkB,CAE9B;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,iBAAiB,GAAG,aAAa,CAsBvE"}

package/dist/utils.js

@@ -0,0 +1,45 @@
+/**
+ * Utility functions for working with canonical MCP server configs.
+ */
+/**
+ * Type guard: checks if a config is a stdio transport config.
+ */
+export function isStdioConfig(config) {
+    return "command" in config && typeof config.command === "string";
+}
+/**
+ * Type guard: checks if a config is a remote transport config.
+ */
+export function isRemoteConfig(config) {
+    return "url" in config && typeof config.url === "string";
+}
+/**
+ * Infer the transport type from a server config.
+ *
+ * For stdio configs, always returns "stdio".
+ * For remote configs, uses the explicit `transport` field if set,
+ * otherwise infers from the URL (paths containing "/sse" → "sse", else "http").
+ */
+export function inferTransport(config) {
+    if (isStdioConfig(config)) {
+        return "stdio";
+    }
+    if (isRemoteConfig(config)) {
+        if (config.transport) {
+            return config.transport;
+        }
+        // Infer from URL (matches FastMCP's logic)
+        try {
+            const url = new URL(config.url);
+            if (/\/sse(\/|\?|&|$)/.test(url.pathname)) {
+                return "sse";
+            }
+        }
+        catch {
+            // Invalid URL, fall through
+        }
+        return "http";
+    }
+    return "stdio";
+}
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;GAEG;AACH,MAAM,UAAU,aAAa,CAC3B,MAAyB;IAEzB,OAAO,SAAS,IAAI,MAAM,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,CAAC;AACnE,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc,CAC5B,MAAyB;IAEzB,OAAO,KAAK,IAAI,MAAM,IAAI,OAAO,MAAM,CAAC,GAAG,KAAK,QAAQ,CAAC;AAC3D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,MAAyB;IACtD,IAAI,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;QAC1B,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,IAAI,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC;QAC3B,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;YACrB,OAAO,MAAM,CAAC,SAAS,CAAC;QAC1B,CAAC;QACD,2CAA2C;QAC3C,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAChC,IAAI,kBAAkB,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC1C,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,4BAA4B;QAC9B,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@getmcp/core",
+  "version": "0.1.1",
+  "description": "Core types, schemas, and validation for getmcp canonical configuration format",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "config",
+    "schema",
+    "zod",
+    "validation"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/RodrigoTomeES/getmcp.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/RodrigoTomeES/getmcp/tree/main/packages/core#readme",
+  "bugs": {
+    "url": "https://github.com/RodrigoTomeES/getmcp/issues"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "dependencies": {
+    "zod": "^3.24.0"
+  }
+}