@kya-os/mcp-i 1.2.7 → 1.2.9

package/dist/compiler/compiler-context.d.ts

@@ -3,6 +3,8 @@ import { XmcpConfigOuputSchema } from "./config";
 interface CompilerContext {
     /** The mode of the compiler. */
     mode: CompilerMode;
+    /** The project root directory (absolute path). */
+    projectRoot: string;
     /** Whether the adapter is enabled. */
     adapter?: boolean;
     /** The platforms to build for. */

package/dist/compiler/config/injection.d.ts

@@ -23,7 +23,7 @@ export declare function injectStdioVariables(stdioConfig: any): {
     STDIO_CONFIG: string;
 };
 export type StdioVariables = ReturnType<typeof injectStdioVariables>;
-export declare function injectIdentityVariables(identityConfig: any, mode: string): {
+export declare function injectIdentityVariables(identityConfig: any, mode: string, projectRoot: string): {
     IDENTITY_CONFIG: string;
 };
 export type IdentityVariables = ReturnType<typeof injectIdentityVariables>;

package/dist/compiler/config/injection.js

@@ -11,67 +11,87 @@ function injectHttpVariables(httpConfig, mode) {
     const resolvedConfig = (0, utils_1.getResolvedHttpConfig)(httpConfig);
     if (!resolvedConfig)
         return {};
+    // Double-stringify for webpack DefinePlugin - it replaces the variable with the raw value,
+    // so we need to stringify twice to inject an actual string literal
     return {
-        HTTP_CONFIG: JSON.stringify({
+        HTTP_CONFIG: JSON.stringify(JSON.stringify({
             port: resolvedConfig.port,
             host: resolvedConfig.host,
             bodySizeLimit: resolvedConfig.bodySizeLimit,
             endpoint: resolvedConfig.endpoint,
             stateless: true,
             debug: mode === "development",
-        }),
+        })),
     };
 }
 function injectCorsVariables(httpConfig) {
     const corsConfig = (0, utils_1.getResolvedCorsConfig)(httpConfig);
+    // Double-stringify for webpack DefinePlugin
     return {
-        HTTP_CORS_CONFIG: JSON.stringify({
+        HTTP_CORS_CONFIG: JSON.stringify(JSON.stringify({
             origin: corsConfig.origin ?? "",
             methods: corsConfig.methods ?? "",
             allowedHeaders: corsConfig.allowedHeaders ?? "",
             exposedHeaders: corsConfig.exposedHeaders ?? "",
             credentials: corsConfig.credentials ?? false,
             maxAge: corsConfig.maxAge ?? 0,
-        }),
+        })),
     };
 }
 function injectOAuthVariables(userConfig) {
     const oauthConfig = (0, utils_1.getResolvedOAuthConfig)(userConfig);
+    // Double-stringify for webpack DefinePlugin
     return {
-        OAUTH_CONFIG: JSON.stringify(oauthConfig),
+        OAUTH_CONFIG: JSON.stringify(JSON.stringify(oauthConfig)),
     };
 }
 function injectPathsVariables(userConfig) {
     const pathsConfig = (0, utils_1.getResolvedPathsConfig)(userConfig);
+    // Double-stringify for webpack DefinePlugin
     return {
-        TOOLS_PATH: JSON.stringify(pathsConfig.tools),
+        TOOLS_PATH: JSON.stringify(JSON.stringify(pathsConfig.tools)),
     };
 }
 function injectStdioVariables(stdioConfig) {
     if (!stdioConfig)
         return {};
     const debug = typeof stdioConfig === "object" ? stdioConfig.debug : false;
+    // Double-stringify for webpack DefinePlugin
     return {
-        STDIO_CONFIG: JSON.stringify({
+        STDIO_CONFIG: JSON.stringify(JSON.stringify({
             debug,
-        }),
+        })),
     };
 }
-function injectIdentityVariables(identityConfig, mode) {
+function injectIdentityVariables(identityConfig, mode, projectRoot) {
     if (!identityConfig || !identityConfig.enabled) {
+        // Double-stringify for webpack DefinePlugin
         return {
-            IDENTITY_CONFIG: JSON.stringify({
+            IDENTITY_CONFIG: JSON.stringify(JSON.stringify({
                 enabled: false,
-            }),
+            })),
         };
     }
+    // Resolve devIdentityPath to absolute path at compile time
+    // This ensures the bundle can find the identity file regardless of CWD at runtime
+    const path = require("path");
+    const devIdentityPath = identityConfig.devIdentityPath || ".mcpi/identity.json";
+    const absoluteIdentityPath = path.isAbsolute(devIdentityPath)
+        ? devIdentityPath
+        : path.join(projectRoot, devIdentityPath);
+    // Debug: log the resolved path
+    console.log("[COMPILER] Identity path resolution:");
+    console.log("  projectRoot:", projectRoot);
+    console.log("  devIdentityPath:", devIdentityPath);
+    console.log("  absoluteIdentityPath:", absoluteIdentityPath);
+    // Double-stringify for webpack DefinePlugin
     return {
-        IDENTITY_CONFIG: JSON.stringify({
+        IDENTITY_CONFIG: JSON.stringify(JSON.stringify({
             enabled: true,
             environment: identityConfig.environment || mode,
-            devIdentityPath: identityConfig.devIdentityPath,
+            devIdentityPath: absoluteIdentityPath,
             privacyMode: identityConfig.privacyMode || false,
             debug: identityConfig.debug || mode === "development",
-        }),
+        })),
     };
 }

package/dist/compiler/get-webpack-config/get-injected-variables.js

@@ -9,13 +9,13 @@ const injection_1 = require("../config/injection");
  * This utility will define those variables based on the user's config.
  */
 function getInjectedVariables(xmcpConfig) {
-    const { mode } = compiler_context_1.compilerContext.getContext();
+    const { mode, projectRoot } = compiler_context_1.compilerContext.getContext();
     const httpVariables = (0, injection_1.injectHttpVariables)(xmcpConfig.http, mode);
     const corsVariables = (0, injection_1.injectCorsVariables)(xmcpConfig.http);
     const oauthVariables = (0, injection_1.injectOAuthVariables)(xmcpConfig);
     const pathsVariables = (0, injection_1.injectPathsVariables)(xmcpConfig);
     const stdioVariables = (0, injection_1.injectStdioVariables)(xmcpConfig.stdio);
-    const identityVariables = (0, injection_1.injectIdentityVariables)(xmcpConfig.identity, mode);
+    const identityVariables = (0, injection_1.injectIdentityVariables)(xmcpConfig.identity, mode, projectRoot);
     return {
         ...httpVariables,
         ...corsVariables,

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

@@ -51,9 +51,9 @@ const getDefaultRuntimeFiles = () => {
     }
     return runtimeFiles;
 };
-exports.runtimeFiles = (typeof RUNTIME_FILES !== "undefined"
-    ? RUNTIME_FILES
-    : getDefaultRuntimeFiles());
+// IMPORTANT: Always use getDefaultRuntimeFiles() to ensure we get the latest runtime files
+// DefinePlugin embedding was causing stale file issues
+exports.runtimeFiles = getDefaultRuntimeFiles();
 class InjectRuntimePlugin {
     apply(compiler) {
         let hasRun = false;

package/dist/compiler/index.js

@@ -47,6 +47,7 @@ async function compile({ onBuild } = {}) {
     return new Promise((resolve, reject) => {
         (0, compiler_context_1.compilerContextProvider)({
             mode,
+            projectRoot: process.cwd(),
             platforms: {},
         }, () => {
             compileInternal({ onBuild }).then(resolve).catch(reject);
@@ -175,7 +176,13 @@ async function compileInternal({ onBuild } = {}) {
                 compiler.run(handleCompilation);
             }
             else {
-                compiler.watch({}, handleCompilation);
+                const watching = compiler.watch({}, handleCompilation);
+                // Store watching instance for proper cleanup
+                process.on('SIGINT', () => {
+                    watching.close(() => {
+                        process.exit(0);
+                    });
+                });
             }
         });
     });