@kya-os/mcp-i 0.1.0-alpha.3.9 → 1.2.0

package/dist/test/runtime-integration.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Runtime integration for test infrastructure
+ *
+ * This module provides integration points between the test infrastructure
+ * and the XMCP-I runtime to ensure test mode works seamlessly.
+ */
+/**
+ * Test mode runtime configuration
+ */
+export interface TestRuntimeConfig {
+    skipKTACalls: boolean;
+    useMockIdentities: boolean;
+    deterministicKeys: boolean;
+    mockKTAResponses: boolean;
+}
+/**
+ * Get test runtime configuration
+ */
+export declare function getTestRuntimeConfig(): TestRuntimeConfig | null;
+/**
+ * Intercept KTA calls in test mode
+ */
+export declare function interceptKTACall<T>(operation: string, originalCall: () => Promise<T>, mockResponse?: () => Promise<T>): Promise<T>;
+/**
+ * Get test identity for runtime use
+ */
+export declare function getTestIdentityForRuntime(identityKey?: string): {
+    did: string;
+    keyId: string;
+    privateKey: string;
+    publicKey: string;
+    createdAt: string;
+    lastRotated: string;
+};
+/**
+ * Create test session context
+ */
+export declare function createTestSessionContext(options?: {
+    sessionId?: string;
+    audience?: string;
+    nonce?: string;
+    timestamp?: number;
+}): {
+    sessionId: string;
+    audience: string;
+    nonce: string;
+    timestamp: number;
+    createdAt: number;
+    lastActivity: number;
+    ttlMinutes: number;
+};
+/**
+ * Validate test environment setup
+ */
+export declare function validateTestEnvironment(): {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+};
+/**
+ * Test mode guard decorator
+ */
+export declare function testModeOnly<T extends (...args: any[]) => any>(fn: T): T;

package/dist/test/runtime-integration.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * Runtime integration for test infrastructure
+ *
+ * This module provides integration points between the test infrastructure
+ * and the XMCP-I runtime to ensure test mode works seamlessly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTestRuntimeConfig = getTestRuntimeConfig;
+exports.interceptKTACall = interceptKTACall;
+exports.getTestIdentityForRuntime = getTestIdentityForRuntime;
+exports.createTestSessionContext = createTestSessionContext;
+exports.validateTestEnvironment = validateTestEnvironment;
+exports.testModeOnly = testModeOnly;
+const test_environment_1 = require("./test-environment");
+const mock_identity_provider_1 = require("./mock-identity-provider");
+const test_1 = require("@kya-os/contracts/test");
+/**
+ * Get test runtime configuration
+ */
+function getTestRuntimeConfig() {
+    if (!(0, test_environment_1.isTestMode)()) {
+        return null;
+    }
+    return {
+        skipKTACalls: (0, test_environment_1.shouldSkipKTACalls)(),
+        useMockIdentities: true,
+        deterministicKeys: true,
+        mockKTAResponses: true,
+    };
+}
+/**
+ * Intercept KTA calls in test mode
+ */
+async function interceptKTACall(operation, originalCall, mockResponse) {
+    const testConfig = getTestRuntimeConfig();
+    if (!testConfig || !testConfig.skipKTACalls) {
+        return originalCall();
+    }
+    if (mockResponse) {
+        return mockResponse();
+    }
+    // Default mock responses based on operation
+    switch (operation) {
+        case "register":
+            return {
+                success: true,
+                agentURL: "https://test-kta.example.com/agents/test-agent",
+                agentId: "test-agent",
+                agentSlug: "test-agent",
+                verificationEndpoint: "https://test-kta.example.com/verify/test-agent",
+                conformanceCapabilities: ["handshake", "signing", "verification"],
+                mirrorStatus: "success",
+            };
+        case "checkDelegation":
+            return {
+                status: "active",
+                valid: true,
+            };
+        case "claim":
+            return {
+                success: true,
+                claimed: true,
+                agentURL: "https://test-kta.example.com/agents/test-agent",
+            };
+        default:
+            throw new Error(`${test_1.TEST_ERROR_CODES.INVALID_TEST_CONFIGURATION}: Unknown KTA operation: ${operation}`);
+    }
+}
+/**
+ * Get test identity for runtime use
+ */
+function getTestIdentityForRuntime(identityKey = "agent1") {
+    if (!(0, test_environment_1.isTestMode)()) {
+        throw new Error(`${test_1.TEST_ERROR_CODES.INVALID_TEST_CONFIGURATION}: Test identity can only be used in test mode`);
+    }
+    const mockProvider = (0, mock_identity_provider_1.getMockIdentityProvider)();
+    const identity = mockProvider.getIdentity(identityKey);
+    if (!identity) {
+        throw new Error(`${test_1.TEST_ERROR_CODES.INVALID_TEST_CONFIGURATION}: Test identity '${identityKey}' not found`);
+    }
+    return identity;
+}
+/**
+ * Create test session context
+ */
+function createTestSessionContext(options = {}) {
+    if (!(0, test_environment_1.isTestMode)()) {
+        throw new Error(`${test_1.TEST_ERROR_CODES.INVALID_TEST_CONFIGURATION}: Test session context can only be created in test mode`);
+    }
+    const now = Math.floor(Date.now() / 1000);
+    return {
+        sessionId: options.sessionId || "sess_test_default",
+        audience: options.audience || "test.example.com",
+        nonce: options.nonce || "test_nonce_123",
+        timestamp: options.timestamp || now,
+        createdAt: now,
+        lastActivity: now,
+        ttlMinutes: 30,
+    };
+}
+/**
+ * Validate test environment setup
+ */
+function validateTestEnvironment() {
+    const errors = [];
+    const warnings = [];
+    if (!(0, test_environment_1.isTestMode)()) {
+        errors.push("XMCP_ENV is not set to 'test'");
+    }
+    if (!(0, test_environment_1.shouldSkipKTACalls)()) {
+        warnings.push("KTA calls are not being skipped in test mode");
+    }
+    try {
+        const mockProvider = (0, mock_identity_provider_1.getMockIdentityProvider)();
+        const identities = mockProvider.getAllIdentities();
+        if (Object.keys(identities).length === 0) {
+            warnings.push("No test identities are configured");
+        }
+    }
+    catch (error) {
+        errors.push(`Failed to access mock identity provider: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Test mode guard decorator
+ */
+function testModeOnly(fn) {
+    return ((...args) => {
+        if (!(0, test_environment_1.isTestMode)()) {
+            throw new Error(`${test_1.TEST_ERROR_CODES.INVALID_TEST_CONFIGURATION}: Function can only be called in test mode`);
+        }
+        return fn(...args);
+    });
+}

package/dist/test/test-environment.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Test environment detection and configuration
+ */
+/**
+ * Check if we're running in test mode
+ */
+export declare function isTestMode(): boolean;
+/**
+ * Get the current test seed for deterministic key generation
+ */
+export declare function getCurrentTestSeed(testName?: string): string;
+/**
+ * Ensure we're in test mode, throw if not
+ */
+export declare function ensureTestMode(): void;
+/**
+ * Configure test environment
+ */
+export declare function configureTestEnvironment(options?: {
+    seed?: string;
+    skipKTACalls?: boolean;
+}): void;
+/**
+ * Check if KTA calls should be skipped
+ */
+export declare function shouldSkipKTACalls(): boolean;

package/dist/test/test-environment.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Test environment detection and configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTestMode = isTestMode;
+exports.getCurrentTestSeed = getCurrentTestSeed;
+exports.ensureTestMode = ensureTestMode;
+exports.configureTestEnvironment = configureTestEnvironment;
+exports.shouldSkipKTACalls = shouldSkipKTACalls;
+const test_1 = require("@kya-os/contracts/test");
+/**
+ * Check if we're running in test mode
+ */
+function isTestMode() {
+    return (0, test_1.isTestEnvironment)();
+}
+/**
+ * Get the current test seed for deterministic key generation
+ */
+function getCurrentTestSeed(testName) {
+    return (0, test_1.getTestSeed)(testName);
+}
+/**
+ * Ensure we're in test mode, throw if not
+ */
+function ensureTestMode() {
+    if (!isTestMode()) {
+        throw new Error(`${test_1.TEST_ERROR_CODES.INVALID_TEST_CONFIGURATION}: Test utilities can only be used when XMCP_ENV=test`);
+    }
+}
+/**
+ * Configure test environment
+ */
+function configureTestEnvironment(options = {}) {
+    if (options.seed) {
+        process.env.XMCP_TEST_SEED = options.seed;
+    }
+    if (options.skipKTACalls !== false) {
+        process.env.XMCP_SKIP_KTA_CALLS = "true";
+    }
+    // Ensure we're in test mode
+    process.env.XMCP_ENV = "test";
+}
+/**
+ * Check if KTA calls should be skipped
+ */
+function shouldSkipKTACalls() {
+    return isTestMode() || process.env.XMCP_SKIP_KTA_CALLS === "true";
+}

package/dist/types/declarations.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/declarations.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// TODO: Fix module declaration
+// declare module "xmcp/headers" {
+//   export const headers: typeof import("../runtime/headers").headers;
+// }

package/dist/types/middleware.d.ts

@@ -0,0 +1,2 @@
+import { type RequestHandler } from "express";
+export type Middleware = RequestHandler | RequestHandler[];

package/dist/types/middleware.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/tool.d.ts

@@ -0,0 +1,80 @@
+import { z } from "zod";
+export interface ToolAnnotations {
+    /** Human-readable title for the tool */
+    title?: string;
+    /** If true, the tool does not modify its environment */
+    readOnlyHint?: boolean;
+    /** If true, the tool may perform destructive updates */
+    destructiveHint?: boolean;
+    /** If true, repeated calls with same args have no additional effect */
+    idempotentHint?: boolean;
+    /** If true, tool interacts with external entities */
+    openWorldHint?: boolean;
+    [key: string]: any;
+}
+export interface ToolMetadata {
+    /** Unique identifier for the tool */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** Optional hints about tool behavior */
+    annotations?: ToolAnnotations;
+}
+export type ToolSchema = Record<string, z.ZodType<unknown, z.ZodTypeDef, unknown>>;
+/**
+ * Extra arguments passed to MCP tool functions.
+ */
+export interface ToolExtraArguments {
+    /** An abort signal used to communicate if the request was cancelled from the sender's side */
+    signal: AbortSignal;
+    /** Information about a validated access token, provided to request handlers */
+    authInfo?: {
+        /** The access token */
+        token: string;
+        /** The client ID associated with this token */
+        clientId: string;
+        /** Scopes associated with this token */
+        scopes: string[];
+        /** When the token expires (in seconds since epoch) */
+        expiresAt?: number;
+        /** The RFC 8707 resource server identifier for which this token is valid */
+        resource?: URL;
+        /** Additional data associated with the token */
+        extra?: Record<string, unknown>;
+    };
+    /** The session ID from the transport, if available */
+    sessionId?: string;
+    /** Metadata from the original request */
+    _meta?: {
+        /** Progress token for tracking long-running operations */
+        progressToken?: string | number;
+    };
+    /** The JSON-RPC ID of the request being handled */
+    requestId: string | number;
+    /** The original HTTP request information */
+    requestInfo?: {
+        /** The headers of the request */
+        headers: Record<string, string | string[] | undefined>;
+    };
+    /** Sends a notification that relates to the current request being handled */
+    sendNotification: (notification: any) => Promise<void>;
+    /** Sends a request that relates to the current request being handled */
+    sendRequest: <U extends z.ZodType<object>>(request: any, resultSchema: U, options?: {
+        /** Progress notification callback */
+        onprogress?: (progress: any) => void;
+        /** Abort signal for cancelling the request */
+        signal?: AbortSignal;
+        /** Request timeout in milliseconds */
+        timeout?: number;
+        /** Whether receiving progress notifications resets the timeout */
+        resetTimeoutOnProgress?: boolean;
+        /** Maximum total time to wait for a response */
+        maxTotalTimeout?: number;
+        /** Additional transport-specific options */
+        [key: string]: unknown;
+    }) => Promise<z.infer<U>>;
+}
+export type InferSchema<T extends ToolSchema> = {
+    [K in keyof T]: z.infer<T[K]>;
+};
+export type ToolHandler = (args: Record<string, unknown>, extra?: ToolExtraArguments) => Promise<unknown> | unknown;

package/dist/types/tool.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/cli-icons.d.ts

@@ -0,0 +1,3 @@
+export declare const greenCheck = "\u2714";
+export declare const xmcpLogo = " XMCP ";
+export declare const yellowArrow = "\u2192";

package/dist/utils/cli-icons.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yellowArrow = exports.xmcpLogo = exports.greenCheck = void 0;
+// Simplified - remove chalk styling for now
+exports.greenCheck = "✔";
+exports.xmcpLogo = " XMCP ";
+exports.yellowArrow = "→";

package/dist/utils/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const runtimeFolder = ".xmcp";
+export declare const runtimeFolderPath: string;
+export declare const rootFolder: string;
+export declare const processFolder: string;
+export declare const distOutputPath: string;
+export declare const adapterOutputPath: string;

package/dist/utils/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapterOutputPath = exports.distOutputPath = exports.processFolder = exports.rootFolder = exports.runtimeFolderPath = exports.runtimeFolder = void 0;
+const path_1 = __importDefault(require("path"));
+exports.runtimeFolder = ".xmcp";
+exports.runtimeFolderPath = path_1.default.join(process.cwd(), exports.runtimeFolder);
+exports.rootFolder = path_1.default.join(process.cwd());
+exports.processFolder = process.cwd();
+exports.distOutputPath = path_1.default.join(exports.processFolder, "dist");
+exports.adapterOutputPath = path_1.default.join(exports.runtimeFolderPath, "adapter");

package/dist/utils/context.d.ts

@@ -0,0 +1,33 @@
+type DefaultContext = Object;
+type GetContext<T extends DefaultContext> = () => T;
+type SetContext<T extends DefaultContext> = (data: Partial<T>) => void;
+export interface Context<T extends DefaultContext> {
+    /** Run a callback with a specific context. */
+    provider: (initialValue: T, callback: () => void) => void;
+    /** Get the context. */
+    getContext: GetContext<T>;
+    /** Partially update the context. */
+    setContext: SetContext<T>;
+}
+interface CreateContextOptions {
+    name: string;
+}
+/**
+ * Create context allows you to create scoped variables for fucntions.
+ * Similar to React's context API.
+ * Usage:
+ * ```ts
+ * interface MyContext {
+ *   value: string;
+ * }
+ *
+ * const context = createContext({ name: "my-context" });
+ *
+ * context.provider({
+ *   value: "hello",
+ * }, () => {
+ *   // Do something with the context
+ * })```
+ */
+export declare function createContext<T extends Object>({ name, }: CreateContextOptions): Context<T>;
+export {};

package/dist/utils/context.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContext = createContext;
+const async_hooks_1 = require("async_hooks");
+const setGlobalContext = (key, context) => {
+    globalThis[key] = context;
+};
+const getGlobalContext = (key) => {
+    return globalThis[key];
+};
+/**
+ * Create context allows you to create scoped variables for fucntions.
+ * Similar to React's context API.
+ * Usage:
+ * ```ts
+ * interface MyContext {
+ *   value: string;
+ * }
+ *
+ * const context = createContext({ name: "my-context" });
+ *
+ * context.provider({
+ *   value: "hello",
+ * }, () => {
+ *   // Do something with the context
+ * })```
+ */
+function createContext({ name, }) {
+    const storageKey = Symbol.for(`xmcp-context-${name}`);
+    if (getGlobalContext(storageKey)) {
+        return getGlobalContext(storageKey);
+    }
+    const context = new async_hooks_1.AsyncLocalStorage();
+    const getContext = () => {
+        const store = context.getStore();
+        if (!store) {
+            throw new Error(`getContext() can only be used within the ${name} context.`);
+        }
+        return store;
+    };
+    const setContext = (data) => {
+        const store = context.getStore();
+        if (!store) {
+            throw new Error(`setContext() can only be used within the ${name} context.`);
+        }
+        Object.assign(store, data);
+    };
+    const provider = (initialValue, callback) => {
+        return context.run(initialValue, callback);
+    };
+    const result = {
+        provider,
+        getContext,
+        setContext,
+    };
+    setGlobalContext(storageKey, result);
+    return result;
+}

package/dist/utils/file-watcher.d.ts

@@ -0,0 +1,19 @@
+import chokidar from "chokidar";
+import { Subscribable } from "./subscribable";
+interface WatcherOptions {
+    onAdd?: (path: string) => void;
+    onUnlink?: (path: string) => void;
+    onChange?: (path: string) => void;
+}
+export declare class Watcher {
+    private watchers;
+    isReady: boolean;
+    globalOptions: chokidar.WatchOptions;
+    onReadySubscribable: Subscribable;
+    constructor(options?: chokidar.WatchOptions);
+    watch(path: string, options: WatcherOptions, chokidarOptions?: chokidar.WatchOptions): void;
+    onReady(callback: () => void): void;
+    private checkReady;
+    close(): Promise<void>;
+}
+export {};

package/dist/utils/file-watcher.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Watcher = void 0;
+const chokidar_1 = __importDefault(require("chokidar"));
+const subscribable_1 = require("./subscribable");
+class Watcher {
+    watchers = [];
+    isReady = false;
+    globalOptions = {};
+    onReadySubscribable = (0, subscribable_1.subscribable)();
+    constructor(options = {}) {
+        this.globalOptions = options;
+    }
+    watch(path, options, chokidarOptions = {}) {
+        const instance = chokidar_1.default.watch(path, {
+            ...this.globalOptions,
+            ...chokidarOptions,
+        });
+        options.onAdd && instance.on("add", options.onAdd);
+        options.onUnlink && instance.on("unlink", options.onUnlink);
+        options.onChange && instance.on("change", options.onChange);
+        const watcherInstance = {
+            isReady: false,
+            watcher: instance,
+        };
+        this.watchers.push(watcherInstance);
+        instance.on("ready", () => {
+            watcherInstance.isReady = true;
+            this.checkReady();
+        });
+    }
+    onReady(callback) {
+        this.onReadySubscribable.addCallback(callback);
+    }
+    checkReady() {
+        if (this.watchers.every((watcher) => watcher.isReady)) {
+            this.onReadySubscribable.runCallbacks();
+            this.onReadySubscribable.clearCallbacks();
+        }
+    }
+    async close() {
+        await Promise.all(this.watchers.map((watcherInstance) => watcherInstance.watcher.close()));
+        this.watchers = [];
+    }
+}
+exports.Watcher = Watcher;

package/dist/utils/fs-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function createFolder(folderPath: string): void;
+export declare function parseJson<T = any>(json: string): readonly [T, null] | readonly [null, Error];

package/dist/utils/fs-utils.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFolder = createFolder;
+exports.parseJson = parseJson;
+const fs_1 = __importDefault(require("fs"));
+const json5_1 = __importDefault(require("json5"));
+function createFolder(folderPath) {
+    if (!fs_1.default.existsSync(folderPath)) {
+        fs_1.default.mkdirSync(folderPath, { recursive: true });
+    }
+}
+function parseJson(json) {
+    try {
+        return [json5_1.default.parse(json), null];
+    }
+    catch (e) {
+        return [null, e];
+    }
+}

package/dist/utils/path-validation.d.ts

@@ -0,0 +1,3 @@
+type PathType = "tools";
+export declare function isValidPath(pathStr: string | undefined, type: PathType): string | undefined;
+export {};

package/dist/utils/path-validation.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidPath = isValidPath;
+const constants_1 = require("./constants");
+// Simplified - remove chalk styling for now
+const chalk = {
+    red: {
+        bold: (text) => text,
+    },
+    yellow: (text) => text,
+};
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function isValidPath(pathStr, type) {
+    function isNonEmptyString(str) {
+        return typeof str === "string" && str.length > 0;
+    }
+    function isGlob(str) {
+        return /[*?\[\]{}]/.test(str);
+    }
+    function normalizePath(p) {
+        // normalize to posix (forward slashes)
+        return p.split(/\\|\//).join("/");
+    }
+    function resolveAndCheckExists(p) {
+        const normalized = normalizePath(p);
+        const absPath = path_1.default.resolve(constants_1.rootFolder, normalized);
+        if (!fs_1.default.existsSync(absPath)) {
+            exitError(`The path set in xmcp config for ${type} does not exist: ${absPath}`);
+        }
+        return normalized; // still return the normalized path cause we're formatting to glob later
+    }
+    if (pathStr === undefined) {
+        return undefined;
+    }
+    // reject empty string
+    if (pathStr === "") {
+        exitError(`${type} path cannot be an empty string`);
+    }
+    if (isNonEmptyString(pathStr)) {
+        if (isGlob(pathStr)) {
+            exitError(`If you are using a glob pattern, please use a string for the ${type} path`);
+        }
+        return resolveAndCheckExists(pathStr);
+    }
+    exitError(`${type} path must be a non-empty string`);
+}
+function exitError(message) {
+    console.log("");
+    console.log(chalk.red.bold(message));
+    console.log("");
+    process.exit(1);
+}