@kya-os/mcp-i 0.1.0 → 1.2.0

package/dist/compiler/parse-xmcp-config.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = getConfig;
+exports.readConfig = readConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const webpack_1 = require("webpack");
+const memfs_1 = require("memfs");
+const compiler_context_1 = require("./compiler-context");
+const config_1 = require("./config");
+const constants_1 = require("./config/constants");
+function validateConfig(config) {
+    return config_1.configSchema.parse(config);
+}
+// read if exists
+function readConfigFile(pathToConfig) {
+    const configPath = path_1.default.resolve(process.cwd(), pathToConfig);
+    if (!fs_1.default.existsSync(configPath)) {
+        return null;
+    }
+    return fs_1.default.readFileSync(configPath, "utf8");
+}
+const configPaths = {
+    ts: "xmcp.config.ts",
+    json: "xmcp.config.json",
+};
+/**
+ * Parse and validate xmcp config file
+ */
+async function getConfig() {
+    const config = await readConfig();
+    const { platforms } = compiler_context_1.compilerContext.getContext();
+    if (platforms.vercel) {
+        // Remove stdio to deploy on vercel
+        delete config.stdio;
+    }
+    return config;
+}
+/**
+ * Read config from file or return default
+ */
+async function readConfig() {
+    // Simple json config
+    const jsonFile = readConfigFile(configPaths.json);
+    if (jsonFile) {
+        return validateConfig(JSON.parse(jsonFile));
+    }
+    // TypeScript config, compile it
+    const tsFile = readConfigFile(configPaths.ts);
+    if (tsFile) {
+        try {
+            return await compileConfig();
+        }
+        catch (error) {
+            throw new Error(`Failed to compile xmcp.config.ts:\n${error}`);
+        }
+    }
+    // Default config
+    return {
+        stdio: true,
+        http: true,
+        paths: constants_1.DEFAULT_PATHS_CONFIG,
+    };
+}
+/**
+ * If the user is using a typescript config file,
+ * we need to bundle it, run it and return its copiled code
+ * */
+async function compileConfig() {
+    const configPath = path_1.default.resolve(process.cwd(), configPaths.ts);
+    // Create memory filesystem
+    const memoryFs = (0, memfs_1.createFsFromVolume)(new memfs_1.Volume());
+    // Webpack configuration
+    const webpackConfig = {
+        mode: "production",
+        entry: configPath,
+        target: "node",
+        output: {
+            path: "/",
+            filename: "config.js",
+            library: {
+                type: "commonjs2",
+            },
+        },
+        resolve: {
+            extensions: [".ts", ".js"],
+        },
+        module: {
+            rules: [
+                {
+                    test: /\.ts$/,
+                    use: {
+                        loader: "swc-loader",
+                        options: {
+                            jsc: {
+                                parser: {
+                                    syntax: "typescript",
+                                },
+                                target: "es2020",
+                            },
+                            module: {
+                                type: "commonjs",
+                            },
+                        },
+                    },
+                    exclude: /node_modules/,
+                },
+            ],
+        },
+        externals: {
+            webpack: "commonjs2 webpack",
+        },
+    };
+    return new Promise((resolve, reject) => {
+        const compiler = (0, webpack_1.webpack)(webpackConfig);
+        // Use memory filesystem for output
+        compiler.outputFileSystem = memoryFs;
+        compiler.run((err, stats) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            if (stats?.hasErrors()) {
+                reject(new Error(stats.toString({ colors: false, errors: true })));
+                return;
+            }
+            try {
+                // Read the bundled code from memory
+                const bundledCode = memoryFs.readFileSync("/config.js", "utf8");
+                // Create a temporary module to evaluate the bundled code
+                const module = { exports: {} };
+                const require = (id) => {
+                    // Handle webpack require
+                    if (id === "webpack") {
+                        return webpack_1.webpack;
+                    }
+                    throw new Error(`Cannot resolve module: ${id}`);
+                };
+                // Evaluate the bundled code
+                const func = new Function("module", "exports", "require", "__filename", "__dirname", bundledCode);
+                func(module, module.exports, require, configPath, path_1.default.dirname(configPath));
+                // Extract the config - it could be default export or direct export
+                const configExport = module.exports.default || module.exports;
+                const config = typeof configExport === "function" ? configExport() : configExport;
+                resolve(validateConfig(config));
+            }
+            catch (evalError) {
+                reject(evalError);
+            }
+        });
+    });
+}

package/dist/compiler/start-http-server.d.ts

@@ -0,0 +1 @@
+export declare function startHttpServer(): Promise<void>;

package/dist/compiler/start-http-server.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startHttpServer = startHttpServer;
+const cli_icons_1 = require("../utils/cli-icons");
+const spawn_process_1 = require("../utils/spawn-process");
+const child_process_1 = require("child_process");
+let httpServerProcess = null;
+function spawnHttpServer() {
+    const process = (0, child_process_1.spawn)("node", ["dist/http.js"], {
+        stdio: "inherit",
+        shell: true,
+    });
+    (0, spawn_process_1.watchdog)(process);
+    return process;
+}
+async function killProcess(process) {
+    process.kill("SIGKILL");
+    await new Promise((resolve) => {
+        process.on("exit", resolve);
+    });
+}
+async function startHttpServer() {
+    if (!httpServerProcess) {
+        console.log(`${cli_icons_1.yellowArrow} Starting http server`);
+        // first time starting the server
+        httpServerProcess = spawnHttpServer();
+    }
+    else {
+        console.log(`${cli_icons_1.yellowArrow} Restarting http server`);
+        // restart the server
+        await killProcess(httpServerProcess);
+        httpServerProcess = spawnHttpServer();
+    }
+}

package/dist/index.d.ts

@@ -1,54 +1,12 @@
-/**
- * @kya-os/mcp-i - Ultra-light MCP Identity auto-registration
- *
- * Enable any MCP server to get a verifiable identity with just 2 lines of code:
- *
- * ```typescript
- * import { MCPIdentity } from "@kya-os/mcp-i";
- * const identity = await MCPIdentity.init();
- * ```
- *
- * Zero dependencies on other @kya-os packages - completely standalone!
- */
-interface MCPIdentityOptions {
-    name?: string;
-    description?: string;
-    repository?: string;
-    apiEndpoint?: string;
-    persistencePath?: string;
-}
-export declare class MCPIdentity {
-    readonly did: string;
-    readonly publicKey: string;
-    private privateKey;
-    private constructor();
-    /**
-     * Initialize MCP Identity - the main entry point
-     *
-     * @example
-     * ```typescript
-     * import { MCPIdentity } from "@kya-os/mcp-i";
-     * const identity = await MCPIdentity.init();
-     * ```
-     */
-    static init(options?: MCPIdentityOptions): Promise<MCPIdentity>;
-    /**
-     * Sign a message with the agent's private key
-     */
-    sign(message: string): Promise<string>;
-    /**
-     * Get MCP-I capabilities
-     */
-    getCapabilities(): {
-        version: string;
-        did: string;
-        publicKey: string;
-        conformanceLevel: number;
-    };
-    /**
-     * Sign an MCP response
-     */
-    signResponse(response: any): any;
-}
-export {};
-//# sourceMappingURL=index.d.ts.map
+export { type Middleware } from "./types/middleware";
+export type { ToolMetadata, ToolSchema, ToolExtraArguments, InferSchema, } from "./types/tool";
+export type { XmcpConfigOuputSchema as XmcpConfig } from "./compiler/config";
+export { apiKeyAuthMiddleware } from "./auth/api-key";
+export { jwtAuthMiddleware } from "./auth/jwt";
+export type { OAuthConfigOptions } from "./auth/oauth";
+import "./types/declarations";
+export * from "./test/index";
+export * from "./cache/index";
+export * from "./runtime/identity";
+export * from "./runtime/index";
+export { compile } from "./compiler/index";

package/dist/index.js

@@ -1,16 +1,4 @@
 "use strict";
-/**
- * @kya-os/mcp-i - Ultra-light MCP Identity auto-registration
- *
- * Enable any MCP server to get a verifiable identity with just 2 lines of code:
- *
- * ```typescript
- * import { MCPIdentity } from "@kya-os/mcp-i";
- * const identity = await MCPIdentity.init();
- * ```
- *
- * Zero dependencies on other @kya-os packages - completely standalone!
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -22,185 +10,29 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCPIdentity = void 0;
-const axios_1 = __importDefault(require("axios"));
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-class MCPIdentity {
-    constructor(identity) {
-        this.did = identity.did;
-        this.publicKey = identity.publicKey;
-        this.privateKey = identity.privateKey;
-    }
-    /**
-     * Initialize MCP Identity - the main entry point
-     *
-     * @example
-     * ```typescript
-     * import { MCPIdentity } from "@kya-os/mcp-i";
-     * const identity = await MCPIdentity.init();
-     * ```
-     */
-    static async init(options) {
-        // Try to load existing identity
-        let identity = await loadIdentity(options?.persistencePath);
-        // Auto-register if needed
-        if (!identity) {
-            console.log('[MCP-I] No existing identity found, auto-registering...');
-            const response = await autoRegister({
-                name: options?.name || process.env.MCP_SERVER_NAME || 'Unnamed MCP Server',
-                description: options?.description,
-                repository: options?.repository,
-                apiEndpoint: options?.apiEndpoint || 'https://knowthat.ai'
-            });
-            // Create persisted identity
-            identity = {
-                did: response.did,
-                publicKey: response.keys.publicKey,
-                privateKey: response.keys.privateKey || '',
-                agentId: response.agent.id,
-                agentSlug: response.agent.slug,
-                registeredAt: new Date().toISOString(),
-            };
-            // Save for future use
-            await saveIdentity(identity, options?.persistencePath);
-            console.log('[MCP-I] ✅ Success! Your agent has been registered.');
-            console.log(`[MCP-I] DID: ${response.did}`);
-            console.log(`[MCP-I] Profile: ${response.agent.url}`);
-        }
-        return new MCPIdentity(identity);
-    }
-    /**
-     * Sign a message with the agent's private key
-     */
-    async sign(message) {
-        // Simple signature for demo - in production use proper crypto
-        return Buffer.from(`${this.privateKey}:${message}`).toString('base64');
-    }
-    /**
-     * Get MCP-I capabilities
-     */
-    getCapabilities() {
-        return {
-            version: '1.0',
-            did: this.did,
-            publicKey: this.publicKey,
-            conformanceLevel: 1
-        };
-    }
-    /**
-     * Sign an MCP response
-     */
-    signResponse(response) {
-        return {
-            ...response,
-            _mcp_identity: {
-                did: this.did,
-                signature: this.sign(JSON.stringify(response)),
-                timestamp: new Date().toISOString()
-            }
-        };
-    }
-}
-exports.MCPIdentity = MCPIdentity;
-// Helper functions (inline to keep package standalone)
-async function loadIdentity(customPath) {
-    // Check environment variables first
-    if (process.env.AGENT_DID && process.env.AGENT_PUBLIC_KEY && process.env.AGENT_PRIVATE_KEY) {
-        return {
-            did: process.env.AGENT_DID,
-            publicKey: process.env.AGENT_PUBLIC_KEY,
-            privateKey: process.env.AGENT_PRIVATE_KEY,
-            agentId: process.env.AGENT_ID || '',
-            agentSlug: process.env.AGENT_SLUG || '',
-            registeredAt: new Date().toISOString()
-        };
-    }
-    // Check file
-    const filePath = customPath || path.join(process.cwd(), '.mcp-identity.json');
-    try {
-        if (fs.existsSync(filePath)) {
-            const content = fs.readFileSync(filePath, 'utf-8');
-            return JSON.parse(content);
-        }
-    }
-    catch {
-        // Ignore errors
-    }
-    return null;
-}
-async function saveIdentity(identity, customPath) {
-    // Save to .env.local
-    const envContent = `
-# MCP-I Identity (auto-generated)
-AGENT_DID="${identity.did}"
-AGENT_PUBLIC_KEY="${identity.publicKey}"
-AGENT_PRIVATE_KEY="${identity.privateKey}"
-AGENT_ID="${identity.agentId}"
-AGENT_SLUG="${identity.agentSlug}"
-`;
-    const envPath = path.join(process.cwd(), '.env.local');
-    fs.writeFileSync(envPath, envContent.trim());
-    // Also save as JSON
-    const filePath = customPath || path.join(process.cwd(), '.mcp-identity.json');
-    fs.writeFileSync(filePath, JSON.stringify(identity, null, 2));
-}
-async function autoRegister(options) {
-    try {
-        const response = await axios_1.default.post(`${options.apiEndpoint}/api/agents/auto-register`, {
-            metadata: {
-                name: options.name,
-                description: options.description,
-                repository: options.repository,
-                version: '1.0.0'
-            },
-            clientInfo: {
-                sdkVersion: '0.1.0',
-                language: 'typescript',
-                platform: 'node' // Always node for MCP servers
-            }
-        }, {
-            timeout: 30000,
-            headers: {
-                'Content-Type': 'application/json',
-                'User-Agent': '@kya-os/mcp-i/0.1.0'
-            }
-        });
-        return response.data;
-    }
-    catch (error) {
-        if (error.response?.status === 429) {
-            throw new Error('Rate limit exceeded. Please try again later.');
-        }
-        throw new Error(error.response?.data?.message ||
-            error.message ||
-            'Failed to auto-register agent');
-    }
-}
-//# sourceMappingURL=index.js.map
+exports.compile = exports.jwtAuthMiddleware = exports.apiKeyAuthMiddleware = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+var api_key_1 = require("./auth/api-key");
+Object.defineProperty(exports, "apiKeyAuthMiddleware", { enumerable: true, get: function () { return api_key_1.apiKeyAuthMiddleware; } });
+var jwt_1 = require("./auth/jwt");
+Object.defineProperty(exports, "jwtAuthMiddleware", { enumerable: true, get: function () { return jwt_1.jwtAuthMiddleware; } });
+require("./types/declarations");
+// Test infrastructure (only available when XMCP_ENV=test)
+__exportStar(require("./test/index"), exports);
+// Nonce cache for replay prevention
+__exportStar(require("./cache/index"), exports);
+// Identity management for CLI and runtime
+__exportStar(require("./runtime/identity"), exports);
+// Runtime creation and management
+__exportStar(require("./runtime/index"), exports);
+// Compiler for CLI usage
+var index_1 = require("./compiler/index");
+Object.defineProperty(exports, "compile", { enumerable: true, get: function () { return index_1.compile; } });

package/dist/index.js.LICENSE.txt

@@ -0,0 +1,49 @@
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+/*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+/*!
+ * is-extglob <https://github.com/jonschlinkert/is-extglob>
+ *
+ * Copyright (c) 2014-2016, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+/*!
+ * is-glob <https://github.com/jonschlinkert/is-glob>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+/*!
+ * is-number <https://github.com/jonschlinkert/is-number>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+/*!
+ * normalize-path <https://github.com/jonschlinkert/normalize-path>
+ *
+ * Copyright (c) 2014-2018, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+/*!
+ * to-regex-range <https://github.com/micromatch/to-regex-range>
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */

package/dist/runtime/__tests__/audit.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for Audit Logging System
+ */
+export {};