all-in-one-mcp 1.0.0

package/README.md

@@ -0,0 +1,31 @@
+# all-in-one-mcp
+
+`all-in-one-mcp` is a managed MCP runtime that exposes:
+
+- an HTTP MCP gateway at `/mcp`
+- an admin API at `/api/mcps`
+- a health endpoint at `/healthz`
+- a stdio proxy mode for legacy MCP clients
+
+## Run with npx
+
+```bash
+npx all-in-one-mcp serve
+```
+
+Useful flags:
+
+```bash
+npx all-in-one-mcp serve --host 127.0.0.1 --port 4100 --database ./runtime.sqlite
+npx all-in-one-mcp stdio-proxy --url http://127.0.0.1:4100/mcp
+```
+
+Environment variables:
+
+- `ALL_IN_ONE_MCP_HOST`
+- `ALL_IN_ONE_MCP_PORT`
+- `ALL_IN_ONE_MCP_DATABASE`
+- `ALL_IN_ONE_MCP_URL`
+- `ALL_IN_ONE_MCP_HOME`
+
+If no database path is supplied, the runtime stores its SQLite database in the platform data directory for `all-in-one-mcp`.

package/bin/all-in-one-mcp.mjs

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+import { existsSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const currentDir = dirname(fileURLToPath(import.meta.url))
+const distEntry = resolve(currentDir, '../dist/cli.js')
+
+if (!existsSync(distEntry)) {
+  process.stderr.write(
+    'The runtime CLI has not been built yet. Run "pnpm --filter all-in-one-mcp build" first.\n'
+  )
+  process.exit(1)
+}
+
+await import(pathToFileURL(distEntry).href)

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ToolListChangedNotificationSchema } from '@modelcontextprotocol/sdk/types.js';
+import { startManagedMcpHttpServer } from './server/httpServer.js';
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
+function hasFlag(...flags) {
+    return flags.some((flag) => process.argv.includes(flag));
+}
+function readArgument(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index < 0) {
+        return undefined;
+    }
+    return process.argv[index + 1];
+}
+function parsePort(value) {
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 0 || port > 65_535) {
+        throw new Error(`Invalid port "${value}". Expected an integer between 0 and 65535.`);
+    }
+    return port;
+}
+function printUsage() {
+    process.stdout.write(`all-in-one-mcp v${version}
+
+Usage:
+  all-in-one-mcp serve [--host 127.0.0.1] [--port 4100] [--database /path/to/runtime.sqlite]
+  all-in-one-mcp stdio-proxy --url http://127.0.0.1:4100/mcp
+
+Environment:
+  ALL_IN_ONE_MCP_HOST
+  ALL_IN_ONE_MCP_PORT
+  ALL_IN_ONE_MCP_DATABASE
+  ALL_IN_ONE_MCP_URL
+  ALL_IN_ONE_MCP_HOME
+`);
+}
+async function runStdioProxy(urlString) {
+    const client = new Client({
+        name: 'all-in-one-mcp-stdio-proxy',
+        version: '1.0.0'
+    }, {
+        capabilities: {}
+    });
+    const upstreamTransport = new StreamableHTTPClientTransport(new URL(urlString));
+    const stdioServer = new Server({
+        name: 'all-in-one-mcp-stdio-proxy',
+        version: '1.0.0'
+    }, {
+        capabilities: {
+            tools: {
+                listChanged: true
+            }
+        }
+    });
+    const stdioTransport = new StdioServerTransport();
+    stdioServer.setRequestHandler(ListToolsRequestSchema, async () => {
+        return client.listTools();
+    });
+    stdioServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+        return client.callTool({
+            name: request.params.name,
+            arguments: request.params.arguments
+        });
+    });
+    client.setNotificationHandler(ToolListChangedNotificationSchema, async () => {
+        await stdioServer.sendToolListChanged();
+    });
+    client.onerror = (error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    };
+    await client.connect(upstreamTransport);
+    await stdioServer.connect(stdioTransport);
+}
+async function main() {
+    if (hasFlag('--help', '-h')) {
+        printUsage();
+        return;
+    }
+    if (hasFlag('--version', '-v')) {
+        process.stdout.write(`${version}\n`);
+        return;
+    }
+    const command = process.argv[2] && !process.argv[2].startsWith('--') ? process.argv[2] : 'serve';
+    if (command === 'serve') {
+        const host = readArgument('--host') ?? process.env.ALL_IN_ONE_MCP_HOST ?? '127.0.0.1';
+        const port = parsePort(readArgument('--port') ?? process.env.ALL_IN_ONE_MCP_PORT ?? '4100');
+        const databasePath = readArgument('--database') ?? process.env.ALL_IN_ONE_MCP_DATABASE;
+        const server = await startManagedMcpHttpServer({
+            host,
+            port,
+            databasePath
+        });
+        process.stdout.write(`all-in-one-mcp listening on http://${server.host}:${server.port}\n`);
+        process.stdout.write(`MCP endpoint: http://${server.host}:${server.port}/mcp\n`);
+        process.stdout.write(`Admin API: http://${server.host}:${server.port}/api/mcps\n`);
+        process.stdout.write(`Health: http://${server.host}:${server.port}/healthz\n`);
+        const shutdown = async () => {
+            await server.close();
+            process.exit(0);
+        };
+        process.once('SIGINT', () => {
+            void shutdown();
+        });
+        process.once('SIGTERM', () => {
+            void shutdown();
+        });
+        return;
+    }
+    if (command === 'stdio-proxy') {
+        const url = readArgument('--url') ?? process.env.ALL_IN_ONE_MCP_URL;
+        if (!url) {
+            process.stderr.write('Missing required --url argument.\n');
+            process.exitCode = 1;
+            return;
+        }
+        new URL(url);
+        await runStdioProxy(url);
+        return;
+    }
+    printUsage();
+    process.exitCode = 1;
+}
+void main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});

package/dist/config/runtimeConfig.d.ts

@@ -0,0 +1,6 @@
+export type ManagedMcpRuntimeOptions = {
+    databasePath?: string;
+};
+export declare function resolveDefaultDataDirectory(): string;
+export declare function resolveDatabasePath(databasePath?: string): string;
+//# sourceMappingURL=runtimeConfig.d.ts.map

package/dist/config/runtimeConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeConfig.d.ts","sourceRoot":"","sources":["../../src/config/runtimeConfig.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,wBAAgB,2BAA2B,IAAI,MAAM,CAsBpD;AAED,wBAAgB,mBAAmB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAQjE"}

package/dist/config/runtimeConfig.js

@@ -0,0 +1,33 @@
+import { mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+export function resolveDefaultDataDirectory() {
+    const override = process.env.ALL_IN_ONE_MCP_HOME?.trim();
+    if (override) {
+        const resolvedOverride = resolve(override);
+        mkdirSync(resolvedOverride, { recursive: true });
+        return resolvedOverride;
+    }
+    let baseDirectory;
+    if (process.platform === 'win32' && process.env.LOCALAPPDATA?.trim()) {
+        baseDirectory = resolve(process.env.LOCALAPPDATA.trim(), 'all-in-one-mcp');
+    }
+    else if (process.platform === 'darwin') {
+        baseDirectory = resolve(homedir(), 'Library', 'Application Support', 'all-in-one-mcp');
+    }
+    else if (process.env.XDG_DATA_HOME?.trim()) {
+        baseDirectory = resolve(process.env.XDG_DATA_HOME.trim(), 'all-in-one-mcp');
+    }
+    else {
+        baseDirectory = resolve(homedir(), '.local', 'share', 'all-in-one-mcp');
+    }
+    mkdirSync(baseDirectory, { recursive: true });
+    return baseDirectory;
+}
+export function resolveDatabasePath(databasePath) {
+    const resolvedPath = databasePath && databasePath.trim().length > 0
+        ? resolve(databasePath)
+        : join(resolveDefaultDataDirectory(), 'all-in-one-mcp.sqlite');
+    mkdirSync(dirname(resolvedPath), { recursive: true });
+    return resolvedPath;
+}

package/dist/contracts/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const SECRET_MASK = "********";
+export declare const DEFAULT_STARTUP_TIMEOUT_MS = 10000;
+export declare const MAX_LOG_ENTRIES_PER_MCP = 5000;
+//# sourceMappingURL=constants.d.ts.map

package/dist/contracts/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/contracts/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,aAAa,CAAA;AACrC,eAAO,MAAM,0BAA0B,QAAS,CAAA;AAChD,eAAO,MAAM,uBAAuB,OAAQ,CAAA"}

package/dist/contracts/constants.js

@@ -0,0 +1,3 @@
+export const SECRET_MASK = '********';
+export const DEFAULT_STARTUP_TIMEOUT_MS = 10_000;
+export const MAX_LOG_ENTRIES_PER_MCP = 5_000;

package/dist/contracts/index.d.ts

@@ -0,0 +1,3 @@
+export * from './constants.js';
+export * from './schemas.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/contracts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAC9B,cAAc,cAAc,CAAA"}

package/dist/contracts/index.js

@@ -0,0 +1,2 @@
+export * from './constants.js';
+export * from './schemas.js';

package/dist/contracts/schemas.d.ts

@@ -0,0 +1,325 @@
+import { z } from 'zod';
+export declare const keyValuePairSchema: z.ZodObject<{
+    key: z.ZodString;
+    value: z.ZodString;
+    masked: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const managedStdioMcpDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    autoStart: z.ZodDefault<z.ZodBoolean>;
+    toolPrefix: z.ZodString;
+    startupTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    transport: z.ZodLiteral<"stdio">;
+    command: z.ZodString;
+    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    cwd: z.ZodOptional<z.ZodString>;
+    env: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodString;
+        masked: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const managedStreamableHttpMcpDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    autoStart: z.ZodDefault<z.ZodBoolean>;
+    toolPrefix: z.ZodString;
+    startupTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    transport: z.ZodLiteral<"streamable-http">;
+    url: z.ZodURL;
+    headers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodString;
+        masked: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const managedMcpDefinitionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    autoStart: z.ZodDefault<z.ZodBoolean>;
+    toolPrefix: z.ZodString;
+    startupTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    transport: z.ZodLiteral<"stdio">;
+    command: z.ZodString;
+    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    cwd: z.ZodOptional<z.ZodString>;
+    env: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodString;
+        masked: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    autoStart: z.ZodDefault<z.ZodBoolean>;
+    toolPrefix: z.ZodString;
+    startupTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    transport: z.ZodLiteral<"streamable-http">;
+    url: z.ZodURL;
+    headers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodString;
+        masked: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>], "transport">;
+export declare const managedMcpStatusSchema: z.ZodEnum<{
+    error: "error";
+    stopped: "stopped";
+    starting: "starting";
+    ready: "ready";
+    degraded: "degraded";
+    stopping: "stopping";
+}>;
+export declare const managedToolSchema: z.ZodObject<{
+    name: z.ZodString;
+    upstreamName: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    execution: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const managedMcpSnapshotSchema: z.ZodObject<{
+    definition: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        autoStart: z.ZodDefault<z.ZodBoolean>;
+        toolPrefix: z.ZodString;
+        startupTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        transport: z.ZodLiteral<"stdio">;
+        command: z.ZodString;
+        args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        cwd: z.ZodOptional<z.ZodString>;
+        env: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodString;
+            masked: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        autoStart: z.ZodDefault<z.ZodBoolean>;
+        toolPrefix: z.ZodString;
+        startupTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        transport: z.ZodLiteral<"streamable-http">;
+        url: z.ZodURL;
+        headers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodString;
+            masked: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>], "transport">;
+    status: z.ZodEnum<{
+        error: "error";
+        stopped: "stopped";
+        starting: "starting";
+        ready: "ready";
+        degraded: "degraded";
+        stopping: "stopping";
+    }>;
+    tools: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        upstreamName: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        execution: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    toolCount: z.ZodNumber;
+    pid: z.ZodNullable<z.ZodNumber>;
+    lastError: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const managedMcpLogLevelSchema: z.ZodEnum<{
+    error: "error";
+    debug: "debug";
+    info: "info";
+    warn: "warn";
+}>;
+export declare const managedMcpLogSourceSchema: z.ZodEnum<{
+    transport: "transport";
+    manager: "manager";
+    stdout: "stdout";
+    stderr: "stderr";
+    upstream: "upstream";
+}>;
+export declare const managedMcpLogEntrySchema: z.ZodObject<{
+    id: z.ZodNumber;
+    mcpId: z.ZodString;
+    level: z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+    }>;
+    source: z.ZodEnum<{
+        transport: "transport";
+        manager: "manager";
+        stdout: "stdout";
+        stderr: "stderr";
+        upstream: "upstream";
+    }>;
+    message: z.ZodString;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export declare const managedMcpEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"snapshot">;
+    snapshot: z.ZodObject<{
+        definition: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            autoStart: z.ZodDefault<z.ZodBoolean>;
+            toolPrefix: z.ZodString;
+            startupTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            transport: z.ZodLiteral<"stdio">;
+            command: z.ZodString;
+            args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            cwd: z.ZodOptional<z.ZodString>;
+            env: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodString;
+                masked: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            autoStart: z.ZodDefault<z.ZodBoolean>;
+            toolPrefix: z.ZodString;
+            startupTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            transport: z.ZodLiteral<"streamable-http">;
+            url: z.ZodURL;
+            headers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodString;
+                masked: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>], "transport">;
+        status: z.ZodEnum<{
+            error: "error";
+            stopped: "stopped";
+            starting: "starting";
+            ready: "ready";
+            degraded: "degraded";
+            stopping: "stopping";
+        }>;
+        tools: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            upstreamName: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            execution: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+        toolCount: z.ZodNumber;
+        pid: z.ZodNullable<z.ZodNumber>;
+        lastError: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"log">;
+    entry: z.ZodObject<{
+        id: z.ZodNumber;
+        mcpId: z.ZodString;
+        level: z.ZodEnum<{
+            error: "error";
+            debug: "debug";
+            info: "info";
+            warn: "warn";
+        }>;
+        source: z.ZodEnum<{
+            transport: "transport";
+            manager: "manager";
+            stdout: "stdout";
+            stderr: "stderr";
+            upstream: "upstream";
+        }>;
+        message: z.ZodString;
+        timestamp: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"removed">;
+    mcpId: z.ZodString;
+}, z.core.$strip>], "type">;
+export declare const managedMcpCollectionSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        definition: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            autoStart: z.ZodDefault<z.ZodBoolean>;
+            toolPrefix: z.ZodString;
+            startupTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            transport: z.ZodLiteral<"stdio">;
+            command: z.ZodString;
+            args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            cwd: z.ZodOptional<z.ZodString>;
+            env: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodString;
+                masked: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            autoStart: z.ZodDefault<z.ZodBoolean>;
+            toolPrefix: z.ZodString;
+            startupTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            transport: z.ZodLiteral<"streamable-http">;
+            url: z.ZodURL;
+            headers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodString;
+                masked: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>], "transport">;
+        status: z.ZodEnum<{
+            error: "error";
+            stopped: "stopped";
+            starting: "starting";
+            ready: "ready";
+            degraded: "degraded";
+            stopping: "stopping";
+        }>;
+        tools: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            upstreamName: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            execution: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+        toolCount: z.ZodNumber;
+        pid: z.ZodNullable<z.ZodNumber>;
+        lastError: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    generatedAt: z.ZodString;
+}, z.core.$strip>;
+export type KeyValuePair = z.infer<typeof keyValuePairSchema>;
+export type ManagedMcpDefinition = z.infer<typeof managedMcpDefinitionSchema>;
+export type ManagedStdioMcpDefinition = z.infer<typeof managedStdioMcpDefinitionSchema>;
+export type ManagedStreamableHttpMcpDefinition = z.infer<typeof managedStreamableHttpMcpDefinitionSchema>;
+export type ManagedMcpStatus = z.infer<typeof managedMcpStatusSchema>;
+export type ManagedTool = z.infer<typeof managedToolSchema>;
+export type ManagedMcpSnapshot = z.infer<typeof managedMcpSnapshotSchema>;
+export type ManagedMcpLogEntry = z.infer<typeof managedMcpLogEntrySchema>;
+export type ManagedMcpEvent = z.infer<typeof managedMcpEventSchema>;
+export type ManagedMcpCollection = z.infer<typeof managedMcpCollectionSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/contracts/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/contracts/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAWvB,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAA;AAWF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;iBAM1C,CAAA;AAEF,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;iBAInD,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAGrC,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;EAOjC,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;iBAS5B,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQnC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;EAA6C,CAAA;AAClF,eAAO,MAAM,yBAAyB;;;;;;EAAmE,CAAA;AAEzG,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;iBAOnC,CAAA;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAahC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGrC,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC7D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAC7E,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wCAAwC,CAAC,CAAA;AACzG,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC3D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACnE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA"}