@kya-os/mcp-i 0.1.0 → 1.2.0

package/dist/compiler/get-webpack-config/index.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWebpackConfig = getWebpackConfig;
+const webpack_1 = require("webpack");
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../../utils/constants");
+const compiler_context_1 = require("../compiler-context");
+const get_entries_1 = require("./get-entries");
+const get_injected_variables_1 = require("./get-injected-variables");
+const resolve_tsconfig_paths_1 = require("./resolve-tsconfig-paths");
+const clean_webpack_plugin_1 = require("clean-webpack-plugin");
+const plugins_1 = require("./plugins");
+const get_externals_1 = require("./get-externals");
+/** Creates the webpack configuration that xmcp will use to bundle the user's code */
+function getWebpackConfig(xmcpConfig) {
+    const processFolder = process.cwd();
+    const { mode } = compiler_context_1.compilerContext.getContext();
+    const outputPath = xmcpConfig.experimental?.adapter
+        ? constants_1.adapterOutputPath
+        : constants_1.distOutputPath;
+    const outputFilename = xmcpConfig.experimental?.adapter
+        ? "index.js"
+        : "[name].js";
+    const config = {
+        mode,
+        watch: mode === "development",
+        devtool: mode === "development" ? "eval-cheap-module-source-map" : false,
+        output: {
+            filename: outputFilename,
+            path: outputPath,
+            libraryTarget: "commonjs2",
+        },
+        target: "node",
+        externals: (0, get_externals_1.getExternals)(),
+        resolve: {
+            fallback: {
+                process: false,
+            },
+            alias: {
+                "node:process": "process",
+                "xmcp/headers": path_1.default.resolve(processFolder, ".xmcp/headers.js"),
+                ...(0, resolve_tsconfig_paths_1.resolveTsconfigPathsToAlias)(),
+            },
+            extensions: [".tsx", ".ts", ".jsx", ".js", ".json"],
+        },
+        plugins: [new plugins_1.InjectRuntimePlugin(), new plugins_1.CreateTypeDefinitionPlugin()],
+        module: {
+            rules: [
+                {
+                    test: /\.ts$/,
+                    use: "swc-loader",
+                },
+            ],
+        },
+        optimization: {
+            minimize: mode === "production",
+            splitChunks: false,
+        },
+    };
+    // Do not watch the adapter output folder, avoid infinite loop
+    if (mode === "development" && !xmcpConfig.experimental?.adapter) {
+        config.watchOptions = {
+            ignored: [constants_1.adapterOutputPath],
+        };
+    }
+    const providedPackages = {
+        // connects the user exports with our runtime
+        INJECTED_TOOLS: [
+            path_1.default.resolve(processFolder, ".xmcp/import-map.js"),
+            "tools",
+        ],
+        INJECTED_MIDDLEWARE: [
+            path_1.default.resolve(processFolder, ".xmcp/import-map.js"),
+            "middleware",
+        ],
+    };
+    // add entry points based on config
+    config.entry = (0, get_entries_1.getEntries)(xmcpConfig);
+    // add injected variables to config
+    config.plugins.push(new webpack_1.ProvidePlugin(providedPackages));
+    // add defined variables to config
+    const definedVariables = (0, get_injected_variables_1.getInjectedVariables)(xmcpConfig);
+    config.plugins.push(new webpack_1.DefinePlugin(definedVariables));
+    // add clean plugin
+    if (!xmcpConfig.experimental?.adapter) {
+        // not needed in adapter mode since it only outputs one file
+        config.plugins.push(new clean_webpack_plugin_1.CleanWebpackPlugin());
+    }
+    // add shebang to CLI output on stdio mode
+    if (xmcpConfig.stdio) {
+        config.plugins.push(new webpack_1.BannerPlugin({
+            banner: "#!/usr/bin/env node",
+            raw: true,
+            include: /^stdio\.js$/,
+        }));
+    }
+    return config;
+}

package/dist/compiler/get-webpack-config/plugins.d.ts

@@ -0,0 +1,8 @@
+import { Compiler } from "webpack";
+export declare const runtimeFiles: Record<string, string>;
+export declare class InjectRuntimePlugin {
+    apply(compiler: Compiler): void;
+}
+export declare class CreateTypeDefinitionPlugin {
+    apply(compiler: Compiler): void;
+}

package/dist/compiler/get-webpack-config/plugins.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateTypeDefinitionPlugin = exports.InjectRuntimePlugin = exports.runtimeFiles = void 0;
+const constants_1 = require("../../utils/constants");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const compiler_context_1 = require("../compiler-context");
+// Fallback runtime files if RUNTIME_FILES is not defined
+const getDefaultRuntimeFiles = () => {
+    const path = require("path");
+    const fs = require("fs");
+    console.log("getDefaultRuntimeFiles: Starting from __dirname:", __dirname);
+    // Try multiple possible locations for the mcp-i runtime dist directory
+    const possiblePaths = [
+        // When running from compiled dist
+        path.resolve(__dirname, "../../../dist/runtime"),
+        path.resolve(__dirname, "../../dist/runtime"),
+        path.resolve(__dirname, "../dist/runtime"),
+        path.resolve(__dirname, "../runtime"),
+        // When running from source
+        path.resolve(__dirname, "../../../packages/mcp-i/dist/runtime"),
+        path.resolve(__dirname, "../../packages/mcp-i/dist/runtime"),
+        path.resolve(__dirname, "../packages/mcp-i/dist/runtime"),
+    ];
+    let mcpDistPath = "";
+    for (const possiblePath of possiblePaths) {
+        console.log("getDefaultRuntimeFiles: Checking path:", possiblePath);
+        if (fs.existsSync(possiblePath) &&
+            fs.existsSync(path.join(possiblePath, "http.js"))) {
+            mcpDistPath = possiblePath;
+            console.log("getDefaultRuntimeFiles: Found valid dist path:", mcpDistPath);
+            break;
+        }
+    }
+    const runtimeFiles = {};
+    if (mcpDistPath) {
+        console.log("getDefaultRuntimeFiles: Loading runtime files from:", mcpDistPath);
+        // Add known runtime files
+        const knownFiles = [
+            "http.js",
+            "stdio.js",
+            "adapter-express.js",
+            "adapter-nextjs.js",
+            "headers.js",
+        ];
+        for (const file of knownFiles) {
+            const filePath = path.join(mcpDistPath, file);
+            console.log("getDefaultRuntimeFiles: Checking for file:", filePath);
+            if (fs.existsSync(filePath)) {
+                console.log("getDefaultRuntimeFiles: Found file:", file);
+                runtimeFiles[file] = fs.readFileSync(filePath, "utf8");
+            }
+        }
+    }
+    else {
+        console.log("getDefaultRuntimeFiles: No valid dist path found");
+    }
+    console.log("getDefaultRuntimeFiles: Final runtime files:", Object.keys(runtimeFiles));
+    return runtimeFiles;
+};
+exports.runtimeFiles = (typeof RUNTIME_FILES !== "undefined"
+    ? RUNTIME_FILES
+    : getDefaultRuntimeFiles());
+class InjectRuntimePlugin {
+    apply(compiler) {
+        let hasRun = false;
+        compiler.hooks.beforeCompile.tap("InjectRuntimePlugin", (_compilationParams) => {
+            if (hasRun)
+                return;
+            hasRun = true;
+            console.log("InjectRuntimePlugin: Found runtime files:", Object.keys(exports.runtimeFiles));
+            for (const [fileName, fileContent] of Object.entries(exports.runtimeFiles)) {
+                const targetPath = path_1.default.join(constants_1.runtimeFolderPath, fileName);
+                console.log(`InjectRuntimePlugin: Writing ${fileName} to ${targetPath}`);
+                fs_extra_1.default.writeFileSync(targetPath, fileContent);
+            }
+        });
+    }
+}
+exports.InjectRuntimePlugin = InjectRuntimePlugin;
+const nextJsTypeDefinition = `
+export const xmcpHandler: (req: Request) => Promise<Response>;
+export const withAuth: (handler: (req: Request) => Promise<Response>, authConfig: AuthConfig) => (req: Request) => Promise<Response>;
+export type VerifyToken = (req: Request, bearerToken?: string) => Promise<AuthInfo | undefined>;
+export type Options = {
+  required?: boolean;
+  requiredScopes?: string[];
+  resourceMetadataPath?: string;
+};
+export type AuthConfig = {
+  verifyToken: VerifyToken;
+  options?: Options;
+};
+export type AuthInfo = {
+  token: string;
+  clientId: string;
+  scopes: string[];
+  expiresAt?: number;
+  resource?: URL;
+  extra?: Record<string, unknown>;
+};
+`;
+const expressTypeDefinition = `
+export const xmcpHandler: (req: Request, res: Response) => Promise<void>;
+`;
+class CreateTypeDefinitionPlugin {
+    apply(compiler) {
+        let hasRun = false;
+        compiler.hooks.afterEmit.tap("CreateTypeDefinitionPlugin", (_compilationParams) => {
+            if (hasRun)
+                return;
+            hasRun = true;
+            const xmcpConfig = (0, compiler_context_1.getXmcpConfig)();
+            // Manually type the .xmcp/adapter/index.js file using a .xmcp/adapter/index.d.ts file
+            // TO DO add withAuth to the type definition & AuthConfig
+            if (xmcpConfig.experimental?.adapter) {
+                let typeDefinitionContent = "";
+                if (xmcpConfig.experimental?.adapter == "nextjs") {
+                    typeDefinitionContent = nextJsTypeDefinition;
+                }
+                else if (xmcpConfig.experimental?.adapter == "express") {
+                    typeDefinitionContent = expressTypeDefinition;
+                }
+                fs_extra_1.default.writeFileSync(path_1.default.join(constants_1.adapterOutputPath, "index.d.ts"), typeDefinitionContent);
+            }
+        });
+    }
+}
+exports.CreateTypeDefinitionPlugin = CreateTypeDefinitionPlugin;

package/dist/compiler/get-webpack-config/resolve-tsconfig-paths.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolve tsconfig.json paths to Webpack aliases
+ * @param  {string} tsconfigPath           - Path to tsconfig
+ * @param  {string} webpackConfigBasePath  - Path from tsconfig to Webpack config to create absolute aliases
+ * @return {object}                        - Webpack alias config
+ */
+export declare function resolveTsconfigPathsToAlias({ tsconfigPath, }?: {
+    tsconfigPath?: string | undefined;
+}): Record<string, string>;

package/dist/compiler/get-webpack-config/resolve-tsconfig-paths.js

@@ -0,0 +1,40 @@
+"use strict";
+// Based on https://gist.github.com/nerdyman/2f97b24ab826623bff9202750013f99e
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTsconfigPathsToAlias = resolveTsconfigPathsToAlias;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const fs_utils_1 = require("../../utils/fs-utils");
+/**
+ * Resolve tsconfig.json paths to Webpack aliases
+ * @param  {string} tsconfigPath           - Path to tsconfig
+ * @param  {string} webpackConfigBasePath  - Path from tsconfig to Webpack config to create absolute aliases
+ * @return {object}                        - Webpack alias config
+ */
+function resolveTsconfigPathsToAlias({ tsconfigPath = "./tsconfig.json", } = {}) {
+    if (!(0, fs_1.existsSync)(tsconfigPath)) {
+        return {};
+    }
+    const tsconfigContent = (0, fs_1.readFileSync)(tsconfigPath, "utf-8");
+    const [parsedTsconfig, parsingError] = (0, fs_utils_1.parseJson)(tsconfigContent);
+    if (parsingError) {
+        console.error(`Error parsing tsconfig.json: ${parsingError.message} at ${tsconfigPath}`);
+        console.log(tsconfigContent);
+        return {};
+    }
+    if (!parsedTsconfig.compilerOptions ||
+        !parsedTsconfig.compilerOptions.paths) {
+        return {};
+    }
+    const paths = parsedTsconfig.compilerOptions.paths;
+    const aliases = {};
+    Object.keys(paths).forEach((item) => {
+        const key = item.replace("/*", "");
+        const value = path_1.default.resolve(paths[item][0].replace("/*", "").replace("*", ""));
+        aliases[key] = value;
+    });
+    return aliases;
+}

package/dist/compiler/index.d.ts

@@ -0,0 +1,6 @@
+export { type Middleware } from "../types/middleware";
+export type CompilerMode = "development" | "production";
+export interface CompileOptions {
+    onBuild?: () => void;
+}
+export declare function compile({ onBuild }?: CompileOptions): Promise<void>;

package/dist/compiler/index.js

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = compile;
+const webpack_1 = require("webpack");
+const get_webpack_config_1 = require("./get-webpack-config");
+// Simplified - remove chalk styling for now
+const chalk = {
+    bold: {
+        green: (text) => text,
+    },
+};
+const parse_xmcp_config_1 = require("./parse-xmcp-config");
+const generate_import_code_1 = require("./generate-import-code");
+const fs_1 = __importDefault(require("fs"));
+const constants_1 = require("../utils/constants");
+const fs_utils_1 = require("../utils/fs-utils");
+const path_1 = __importDefault(require("path"));
+// Use fs.rmSync for cleanup (Node.js 14.14+)
+const deleteSync = (path) => {
+    try {
+        if (fs_1.default.existsSync(path)) {
+            fs_1.default.rmSync(path, { recursive: true, force: true });
+            console.log(`Cleaned: ${path}`);
+        }
+    }
+    catch (error) {
+        console.log(`Could not clean ${path}:`, error instanceof Error ? error.message : String(error));
+    }
+};
+const dotenv_1 = __importDefault(require("dotenv"));
+const generate_env_code_1 = require("./generate-env-code");
+const file_watcher_1 = require("../utils/file-watcher");
+const on_first_build_1 = require("./on-first-build");
+const cli_icons_1 = require("../utils/cli-icons");
+const compiler_context_1 = require("./compiler-context");
+const start_http_server_1 = require("./start-http-server");
+const path_validation_1 = require("../utils/path-validation");
+const utils_1 = require("./config/utils");
+dotenv_1.default.config();
+async function compile({ onBuild } = {}) {
+    // Initialize compiler context if not already set
+    const mode = process.env.NODE_ENV === "production" ? "production" : "development";
+    // Use compiler context provider to set up the context properly
+    return new Promise((resolve, reject) => {
+        (0, compiler_context_1.compilerContextProvider)({
+            mode,
+            platforms: {},
+        }, () => {
+            compileInternal({ onBuild }).then(resolve).catch(reject);
+        });
+    });
+}
+async function compileInternal({ onBuild } = {}) {
+    const { mode } = compiler_context_1.compilerContext.getContext();
+    const { toolPaths } = compiler_context_1.compilerContext.getContext();
+    const startTime = Date.now();
+    let compilerStarted = false;
+    const xmpcConfig = await (0, parse_xmcp_config_1.getConfig)();
+    compiler_context_1.compilerContext.setContext({
+        xmcpConfig: xmpcConfig,
+    });
+    let webpackConfig = (0, get_webpack_config_1.getWebpackConfig)(xmpcConfig);
+    if (xmpcConfig.webpack) {
+        webpackConfig = xmpcConfig.webpack(webpackConfig);
+    }
+    return new Promise((resolve, reject) => {
+        const watcher = new file_watcher_1.Watcher({
+            // keep the watcher running on dev mode after "onReady"
+            persistent: mode === "development",
+            ignored: /(^|[\/\\])\../,
+            ignoreInitial: false,
+        });
+        let toolsPath = (0, path_validation_1.isValidPath)((0, utils_1.getResolvedPathsConfig)(xmpcConfig).tools, "tools");
+        // handle tools
+        watcher.watch(`${toolsPath}/**/*.ts`, {
+            onAdd: (path) => {
+                toolPaths.add(path);
+                if (compilerStarted) {
+                    generateCode();
+                }
+            },
+            onUnlink: (path) => {
+                toolPaths.delete(path);
+                if (compilerStarted) {
+                    generateCode();
+                }
+            },
+        });
+        // if adapter is not enabled, handle middleware
+        if (!xmpcConfig.experimental?.adapter) {
+            // handle middleware
+            watcher.watch("./src/middleware.ts", {
+                onAdd: () => {
+                    compiler_context_1.compilerContext.setContext({
+                        hasMiddleware: true,
+                    });
+                    if (compilerStarted) {
+                        generateCode();
+                    }
+                },
+                onUnlink: () => {
+                    compiler_context_1.compilerContext.setContext({
+                        hasMiddleware: false,
+                    });
+                    if (compilerStarted) {
+                        generateCode();
+                    }
+                },
+            });
+        }
+        // start compiler
+        watcher.onReady(() => {
+            let firstBuild = true;
+            compilerStarted = true;
+            // delete existing runtime folder
+            deleteSync(constants_1.runtimeFolderPath);
+            (0, fs_utils_1.createFolder)(constants_1.runtimeFolderPath);
+            generateCode();
+            const compiler = (0, webpack_1.webpack)(webpackConfig);
+            const handleCompilation = (err, stats) => {
+                if (err) {
+                    console.error(err);
+                    reject(err);
+                    return;
+                }
+                if (stats?.hasErrors()) {
+                    const errorMsg = stats.toString({
+                        colors: true,
+                        chunks: false,
+                    });
+                    console.error(errorMsg);
+                    reject(new Error('Webpack compilation failed'));
+                    return;
+                }
+                if (firstBuild) {
+                    firstBuild = false;
+                    const endTime = Date.now();
+                    const duration = endTime - startTime;
+                    console.log(`${cli_icons_1.greenCheck} Compiled in ${chalk.bold.green(`${duration}ms`)}`);
+                    (0, on_first_build_1.onFirstBuild)(mode, xmpcConfig);
+                    onBuild?.();
+                    // In production mode, close watcher and compiler, then resolve
+                    if (mode === "production") {
+                        watcher.close().then(() => {
+                            // Close webpack compiler to release all resources
+                            compiler.close((compilerCloseErr) => {
+                                if (compilerCloseErr) {
+                                    console.error('Error closing webpack compiler:', compilerCloseErr);
+                                    reject(compilerCloseErr);
+                                }
+                                else {
+                                    resolve();
+                                }
+                            });
+                        }).catch((closeErr) => {
+                            console.error('Error closing watcher:', closeErr);
+                            reject(closeErr);
+                        });
+                    }
+                }
+                else {
+                    // on dev mode, webpack will recompile the code, so we need to start the http server after the first one
+                    if (mode === "development" &&
+                        xmpcConfig["http"] &&
+                        !xmpcConfig.experimental?.adapter) {
+                        (0, start_http_server_1.startHttpServer)();
+                    }
+                }
+            };
+            // Use compiler.run() for production (single build) or compiler.watch() for development (continuous builds)
+            if (mode === "production") {
+                compiler.run(handleCompilation);
+            }
+            else {
+                compiler.watch({}, handleCompilation);
+            }
+        });
+    });
+}
+function generateCode() {
+    const fileContent = (0, generate_import_code_1.generateImportCode)();
+    fs_1.default.writeFileSync(path_1.default.join(constants_1.runtimeFolderPath, "import-map.js"), fileContent);
+    // Generate runtime exports for global access
+    const runtimeExportsCode = (0, generate_env_code_1.generateEnvCode)();
+    const envFilePath = path_1.default.join(constants_1.rootFolder, "xmcp-env.d.ts");
+    // Delete existing file if it exists
+    if (fs_1.default.existsSync(envFilePath)) {
+        fs_1.default.unlinkSync(envFilePath);
+    }
+    fs_1.default.writeFileSync(envFilePath, runtimeExportsCode);
+}

package/dist/compiler/on-first-build.d.ts

@@ -0,0 +1,3 @@
+import { CompilerMode } from ".";
+import { XmcpConfigOuputSchema } from "./config";
+export declare function onFirstBuild(mode: CompilerMode, xmcpConfig: XmcpConfigOuputSchema): void;

package/dist/compiler/on-first-build.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onFirstBuild = onFirstBuild;
+const child_process_1 = require("child_process");
+const spawn_process_1 = require("../utils/spawn-process");
+const cli_icons_1 = require("../utils/cli-icons");
+function onFirstBuild(mode, xmcpConfig) {
+    if (mode === "development" && false) {
+        // disable inspector for now
+        console.log("🔍 Starting inspector...");
+        const inspectorArgs = ["@modelcontextprotocol/inspector@latest"];
+        if (xmcpConfig.stdio) {
+            inspectorArgs.push("node", "dist/stdio.js");
+        }
+        const inspectorProcess = (0, child_process_1.spawn)("npx", inspectorArgs, {
+            stdio: ["inherit", "pipe", "pipe"],
+            shell: true,
+        });
+        (0, spawn_process_1.watchdog)(inspectorProcess);
+        // Prefix inspector output with [Inspector]
+        inspectorProcess.stdout?.on("data", (data) => {
+            const lines = data.toString().split("\n");
+            lines.forEach((line) => {
+                if (line.trim()) {
+                    if (line.includes("?MCP_PROXY_AUTH_TOKEN")) {
+                        console.log(`🔍 Inspector started at ${line}`);
+                    }
+                }
+            });
+        });
+        inspectorProcess.stderr?.on("data", (data) => {
+            const lines = data.toString().split("\n");
+            lines.forEach((line) => {
+                if (line.trim()) {
+                    console.error(`[Inspector] ${line}`);
+                }
+            });
+        });
+        inspectorProcess.on("error", (err) => {
+            console.error("[Inspector] Failed to start inspector:", err);
+        });
+    }
+    const builtResults = [];
+    if (xmcpConfig.stdio) {
+        builtResults.push(`${cli_icons_1.greenCheck} Built STDIO server`);
+    }
+    if (xmcpConfig["http"]) {
+        if (xmcpConfig.experimental?.adapter) {
+            builtResults.push(`${cli_icons_1.greenCheck} Built Adapter`);
+        }
+        else {
+            builtResults.push(`${cli_icons_1.greenCheck} Built HTTP server`);
+        }
+    }
+    builtResults.forEach((result) => {
+        console.log(result);
+    });
+}

package/dist/compiler/parse-xmcp-config.d.ts

@@ -0,0 +1,9 @@
+import { type XmcpConfigOuputSchema } from "./config";
+/**
+ * Parse and validate xmcp config file
+ */
+export declare function getConfig(): Promise<XmcpConfigOuputSchema>;
+/**
+ * Read config from file or return default
+ */
+export declare function readConfig(): Promise<XmcpConfigOuputSchema>;