@kya-os/mcp-i 1.2.6 → 1.2.8

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/index.d.ts

@@ -163,6 +163,25 @@ export declare const configSchema: z.ZodObject<{
         tools?: string | undefined;
     }>>;
     webpack: z.ZodOptional<z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodAny>>>;
+    identity: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        environment: z.ZodOptional<z.ZodEnum<["development", "production"]>>;
+        devIdentityPath: z.ZodOptional<z.ZodString>;
+        privacyMode: z.ZodOptional<z.ZodBoolean>;
+        debug: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        debug?: boolean | undefined;
+        environment?: "development" | "production" | undefined;
+        devIdentityPath?: string | undefined;
+        privacyMode?: boolean | undefined;
+    }, {
+        enabled: boolean;
+        debug?: boolean | undefined;
+        environment?: "development" | "production" | undefined;
+        devIdentityPath?: string | undefined;
+        privacyMode?: boolean | undefined;
+    }>>>;
 }, "strip", z.ZodTypeAny, {
     stdio?: boolean | {
         debug: boolean;
@@ -203,6 +222,13 @@ export declare const configSchema: z.ZodObject<{
         tools: string;
     } | undefined;
     webpack?: ((args_0: any, ...args: unknown[]) => any) | undefined;
+    identity?: {
+        enabled: boolean;
+        debug?: boolean | undefined;
+        environment?: "development" | "production" | undefined;
+        devIdentityPath?: string | undefined;
+        privacyMode?: boolean | undefined;
+    } | undefined;
 }, {
     stdio?: boolean | {
         debug?: boolean | undefined;
@@ -243,6 +269,13 @@ export declare const configSchema: z.ZodObject<{
         tools?: string | undefined;
     } | undefined;
     webpack?: ((args_0: any, ...args: unknown[]) => any) | undefined;
+    identity?: {
+        enabled: boolean;
+        debug?: boolean | undefined;
+        environment?: "development" | "production" | undefined;
+        devIdentityPath?: string | undefined;
+        privacyMode?: boolean | undefined;
+    } | undefined;
 }>;
 type WebpackConfig = {
     webpack?: (config: Configuration) => Configuration;

package/dist/compiler/config/index.js

@@ -12,4 +12,5 @@ exports.configSchema = zod_1.z.object({
     experimental: schemas_1.experimentalConfigSchema.optional(),
     paths: schemas_1.pathsConfigSchema.optional(),
     webpack: schemas_1.webpackConfigSchema.optional(),
+    identity: schemas_1.identityConfigSchema.optional(),
 });

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

@@ -23,4 +23,8 @@ export declare function injectStdioVariables(stdioConfig: any): {
     STDIO_CONFIG: string;
 };
 export type StdioVariables = ReturnType<typeof injectStdioVariables>;
-export type InjectedVariables = HttpVariables | CorsVariables | OAuthVariables | PathsVariables | StdioVariables;
+export declare function injectIdentityVariables(identityConfig: any, mode: string, projectRoot: string): {
+    IDENTITY_CONFIG: string;
+};
+export type IdentityVariables = ReturnType<typeof injectIdentityVariables>;
+export type InjectedVariables = HttpVariables | CorsVariables | OAuthVariables | PathsVariables | StdioVariables | IdentityVariables;

package/dist/compiler/config/injection.js

@@ -5,54 +5,93 @@ exports.injectCorsVariables = injectCorsVariables;
 exports.injectOAuthVariables = injectOAuthVariables;
 exports.injectPathsVariables = injectPathsVariables;
 exports.injectStdioVariables = injectStdioVariables;
+exports.injectIdentityVariables = injectIdentityVariables;
 const utils_1 = require("./utils");
 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, projectRoot) {
+    if (!identityConfig || !identityConfig.enabled) {
+        // Double-stringify for webpack DefinePlugin
+        return {
+            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(JSON.stringify({
+            enabled: true,
+            environment: identityConfig.environment || mode,
+            devIdentityPath: absoluteIdentityPath,
+            privacyMode: identityConfig.privacyMode || false,
+            debug: identityConfig.debug || mode === "development",
+        })),
     };
 }

package/dist/compiler/config/schemas/identity.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+/**
+ * Identity configuration schema
+ */
+export declare const identityConfigSchema: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodBoolean;
+    environment: z.ZodOptional<z.ZodEnum<["development", "production"]>>;
+    devIdentityPath: z.ZodOptional<z.ZodString>;
+    privacyMode: z.ZodOptional<z.ZodBoolean>;
+    debug: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    debug?: boolean | undefined;
+    environment?: "development" | "production" | undefined;
+    devIdentityPath?: string | undefined;
+    privacyMode?: boolean | undefined;
+}, {
+    enabled: boolean;
+    debug?: boolean | undefined;
+    environment?: "development" | "production" | undefined;
+    devIdentityPath?: string | undefined;
+    privacyMode?: boolean | undefined;
+}>>;
+export type IdentityConfig = z.infer<typeof identityConfigSchema>;

package/dist/compiler/config/schemas/identity.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identityConfigSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Identity configuration schema
+ */
+exports.identityConfigSchema = zod_1.z
+    .object({
+    enabled: zod_1.z.boolean().describe("Enable MCP-I identity layer"),
+    environment: zod_1.z
+        .enum(["development", "production"])
+        .optional()
+        .describe("Runtime environment"),
+    devIdentityPath: zod_1.z.string().optional().describe("Custom identity file path"),
+    privacyMode: zod_1.z
+        .boolean()
+        .optional()
+        .describe("Enable privacy mode (per-client DIDs)"),
+    debug: zod_1.z.boolean().optional().describe("Enable debug logging for identity"),
+})
+    .optional();

package/dist/compiler/config/schemas/index.d.ts

@@ -4,3 +4,4 @@ export { oauthConfigSchema, type OAuthConfig } from "./experimental/oauth";
 export { experimentalConfigSchema, type ExperimentalConfig, } from "./experimental";
 export { pathsConfigSchema, type PathsConfig } from "./paths";
 export { webpackConfigSchema, type WebpackConfig } from "./webpack";
+export { identityConfigSchema, type IdentityConfig } from "./identity";

package/dist/compiler/config/schemas/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.webpackConfigSchema = exports.pathsConfigSchema = exports.experimentalConfigSchema = exports.oauthConfigSchema = exports.stdioTransportConfigSchema = exports.corsConfigSchema = exports.httpTransportConfigSchema = void 0;
+exports.identityConfigSchema = exports.webpackConfigSchema = exports.pathsConfigSchema = exports.experimentalConfigSchema = exports.oauthConfigSchema = exports.stdioTransportConfigSchema = exports.corsConfigSchema = exports.httpTransportConfigSchema = void 0;
 // re export
 var http_1 = require("./transport/http");
 Object.defineProperty(exports, "httpTransportConfigSchema", { enumerable: true, get: function () { return http_1.httpTransportConfigSchema; } });
@@ -15,3 +15,5 @@ var paths_1 = require("./paths");
 Object.defineProperty(exports, "pathsConfigSchema", { enumerable: true, get: function () { return paths_1.pathsConfigSchema; } });
 var webpack_1 = require("./webpack");
 Object.defineProperty(exports, "webpackConfigSchema", { enumerable: true, get: function () { return webpack_1.webpackConfigSchema; } });
+var identity_1 = require("./identity");
+Object.defineProperty(exports, "identityConfigSchema", { enumerable: true, get: function () { return identity_1.identityConfigSchema; } });

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

@@ -9,17 +9,19 @@ 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, projectRoot);
     return {
         ...httpVariables,
         ...corsVariables,
         ...oauthVariables,
         ...pathsVariables,
         ...stdioVariables,
+        ...identityVariables,
     };
 }

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

@@ -27,7 +27,7 @@ function getWebpackConfig(xmcpConfig) {
     const config = {
         mode,
         watch: mode === "development",
-        devtool: mode === "development" ? "eval-cheap-module-source-map" : false,
+        devtool: false,
         output: {
             filename: outputFilename,
             path: outputPath,

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);