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

package/dist/runtime/delegation-hooks.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegationMiddleware = exports.DefaultDelegationHooks = void 0;
+exports.createDelegationHooks = createDelegationHooks;
+exports.createDelegationMiddleware = createDelegationMiddleware;
+/**
+ * Default delegation hooks implementation
+ */
+class DefaultDelegationHooks {
+    delegationManager;
+    options;
+    constructor(delegationManager, options = {}) {
+        this.delegationManager = delegationManager;
+        this.options = options;
+    }
+    async beforeProof(meta) {
+        // Resolve delegation reference if needed
+        if (!meta.delegationRef && this.options.autoResolveDelegation) {
+            const context = {
+                audience: meta.audience,
+                sessionId: meta.sessionId,
+                did: meta.did,
+                kid: meta.kid,
+                scopes: meta.scopeId ? [meta.scopeId] : undefined,
+            };
+            meta.delegationRef = await this.resolveDelegation(context);
+        }
+        return meta;
+    }
+    async afterProof(meta) {
+        // Validate delegation if present
+        if (meta.delegationRef) {
+            const isActive = await this.delegationManager.isActive(meta.delegationRef);
+            if (!isActive) {
+                throw new Error(`Delegation ${meta.delegationRef} is not active or has been revoked`);
+            }
+            // Check delegation expiry
+            const delegation = await this.delegationManager.get(meta.delegationRef);
+            if (delegation) {
+                const now = Math.floor(Date.now() / 1000);
+                if (delegation.exp < now) {
+                    throw new Error(`Delegation ${meta.delegationRef} has expired`);
+                }
+                // Validate scopes if specified
+                if (meta.scopeId && !delegation.scopes.includes(meta.scopeId)) {
+                    throw new Error(`Scope ${meta.scopeId} not authorized by delegation ${meta.delegationRef}`);
+                }
+                // Validate audience if specified
+                if (delegation.aud && delegation.aud !== meta.audience) {
+                    throw new Error(`Audience ${meta.audience} not authorized by delegation ${meta.delegationRef}`);
+                }
+            }
+        }
+    }
+    async resolveDelegation(_context) {
+        // TODO: Implement delegation resolution logic
+        // This could involve:
+        // 1. Looking up active delegations for the DID
+        // 2. Matching scopes and audience
+        // 3. Selecting the most appropriate delegation
+        // For now, return undefined (no delegation)
+        return undefined;
+    }
+}
+exports.DefaultDelegationHooks = DefaultDelegationHooks;
+/**
+ * Create delegation hooks instance
+ */
+function createDelegationHooks(delegationManager, options) {
+    return new DefaultDelegationHooks(delegationManager, options);
+}
+/**
+ * Delegation middleware for runtime integration
+ */
+class DelegationMiddleware {
+    hooks;
+    options;
+    constructor(hooks, options = {}) {
+        this.hooks = hooks;
+        this.options = options;
+    }
+    /**
+     * Process request and attach delegation context
+     */
+    async processRequest(meta, context) {
+        // Apply before-proof hooks
+        if (this.hooks.beforeProof) {
+            meta = await this.hooks.beforeProof(meta);
+        }
+        // Resolve delegation if not already present
+        if (!meta.delegationRef && this.hooks.resolveDelegation) {
+            meta.delegationRef = await this.hooks.resolveDelegation(context);
+        }
+        return meta;
+    }
+    /**
+     * Validate proof after generation
+     */
+    async validateProof(meta) {
+        // Apply after-proof hooks
+        if (this.hooks.afterProof) {
+            await this.hooks.afterProof(meta);
+        }
+        // Check if delegation is required
+        if (this.options.requireDelegation && !meta.delegationRef) {
+            throw new Error("Delegation is required but not present in proof");
+        }
+    }
+}
+exports.DelegationMiddleware = DelegationMiddleware;
+/**
+ * Create delegation middleware instance
+ */
+function createDelegationMiddleware(hooks, options) {
+    return new DelegationMiddleware(hooks, options);
+}

package/dist/runtime/demo.d.ts

@@ -0,0 +1,71 @@
+/**
+ * XMCP-I Demo Features - Optional identity badge and development helpers
+ *
+ * Provides opt-in demo features for showcasing identity capabilities.
+ * All features are disabled by default and must be explicitly enabled.
+ */
+import { AgentIdentity } from "./identity";
+/**
+ * Demo configuration
+ */
+export interface DemoConfig {
+    identityBadge?: boolean;
+    environment?: "development" | "production";
+}
+/**
+ * Demo manager for optional features
+ */
+export declare class DemoManager {
+    private config;
+    private identity;
+    constructor(identity: AgentIdentity, config?: DemoConfig);
+    /**
+     * Generate identity badge if enabled
+     */
+    generateIdentityBadge(): string | null;
+    /**
+     * Add identity badge to response if enabled
+     */
+    addIdentityBadgeToResponse(response: any): any;
+    /**
+     * Check if identity badge is enabled
+     */
+    isIdentityBadgeEnabled(): boolean;
+    /**
+     * Extract short DID identifier for display
+     */
+    private extractShortDid;
+    /**
+     * Get demo configuration
+     */
+    getConfig(): DemoConfig;
+    /**
+     * Update demo configuration
+     */
+    updateConfig(updates: Partial<DemoConfig>): void;
+}
+/**
+ * Create demo manager
+ */
+export declare function createDemoManager(identity: AgentIdentity, config?: DemoConfig): DemoManager;
+/**
+ * Utility to format verify link for console output
+ */
+export declare function formatVerifyLink(baseUrl?: string): string;
+/**
+ * Console output helpers for development
+ */
+export declare const DemoConsole: {
+    /**
+     * Print verify link if enabled
+     */
+    printVerifyLink(enabled: boolean, environment: string, baseUrl?: string): void;
+    /**
+     * Print identity badge if enabled
+     */
+    printIdentityBadge(badge: string | null): void;
+    /**
+     * Print demo warning
+     */
+    printDemoWarning(): void;
+};

package/dist/runtime/demo.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * XMCP-I Demo Features - Optional identity badge and development helpers
+ *
+ * Provides opt-in demo features for showcasing identity capabilities.
+ * All features are disabled by default and must be explicitly enabled.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DemoConsole = exports.DemoManager = void 0;
+exports.createDemoManager = createDemoManager;
+exports.formatVerifyLink = formatVerifyLink;
+/**
+ * Demo manager for optional features
+ */
+class DemoManager {
+    config;
+    identity;
+    constructor(identity, config = {}) {
+        this.identity = identity;
+        this.config = {
+            identityBadge: false, // Default disabled
+            environment: "development",
+            ...config,
+        };
+        // Force disable in production
+        if (this.config.environment === "production") {
+            this.config.identityBadge = false;
+        }
+    }
+    /**
+     * Generate identity badge if enabled
+     */
+    generateIdentityBadge() {
+        if (!this.config.identityBadge ||
+            this.config.environment === "production") {
+            return null;
+        }
+        // Extract short identifier from DID
+        const shortDid = this.extractShortDid(this.identity.did);
+        return `🔐 ${shortDid}`;
+    }
+    /**
+     * Add identity badge to response if enabled
+     */
+    addIdentityBadgeToResponse(response) {
+        const badge = this.generateIdentityBadge();
+        if (!badge) {
+            return response;
+        }
+        // Add badge to response metadata
+        if (typeof response === "object" && response !== null) {
+            return {
+                ...response,
+                _identity: badge,
+            };
+        }
+        return response;
+    }
+    /**
+     * Check if identity badge is enabled
+     */
+    isIdentityBadgeEnabled() {
+        return (this.config.identityBadge === true &&
+            this.config.environment !== "production");
+    }
+    /**
+     * Extract short DID identifier for display
+     */
+    extractShortDid(did) {
+        // For did:web:example.com:agents:my-agent, return "my-agent"
+        const parts = did.split(":");
+        if (parts.length >= 2) {
+            const lastPart = parts[parts.length - 1];
+            // Truncate if too long
+            return lastPart.length > 12 ? `${lastPart.slice(0, 12)}...` : lastPart;
+        }
+        return "agent";
+    }
+    /**
+     * Get demo configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update demo configuration
+     */
+    updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+        // Force disable in production
+        if (this.config.environment === "production") {
+            this.config.identityBadge = false;
+        }
+    }
+}
+exports.DemoManager = DemoManager;
+/**
+ * Create demo manager
+ */
+function createDemoManager(identity, config = {}) {
+    return new DemoManager(identity, config);
+}
+/**
+ * Utility to format verify link for console output
+ */
+function formatVerifyLink(baseUrl = "http://localhost:3000") {
+    return `${baseUrl}/verify`;
+}
+/**
+ * Console output helpers for development
+ */
+exports.DemoConsole = {
+    /**
+     * Print verify link if enabled
+     */
+    printVerifyLink(enabled, environment, baseUrl = "http://localhost:3000") {
+        if (enabled && environment === "development") {
+            console.log(`🔍 Debug: ${formatVerifyLink(baseUrl)}`);
+        }
+    },
+    /**
+     * Print identity badge if enabled
+     */
+    printIdentityBadge(badge) {
+        if (badge) {
+            console.log(`${badge} Identity verified`);
+        }
+    },
+    /**
+     * Print demo warning
+     */
+    printDemoWarning() {
+        console.log("⚠️  Demo features enabled - disable in production");
+    },
+};

package/dist/runtime/headers.d.ts

@@ -0,0 +1 @@
+export declare const headers: () => import("http").IncomingHttpHeaders;

package/dist/runtime/headers.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.headers = void 0;
+const http_context_1 = require("./transports/http/http-context");
+const headers = () => {
+    const headers = (0, http_context_1.getHttpContext)().headers;
+    return headers;
+};
+exports.headers = headers;