@kya-os/mcp-i 1.10.0 → 1.11.1

package/dist/runtime/resume-token-store-kv.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Cloudflare KV Resume Token Store
+ *
+ * Durable resume-token store backed by a Cloudflare Workers KV namespace, so a
+ * resume token minted at consent time survives cold starts, process restarts,
+ * and multi-instance deployments (the failure mode the in-memory store causes —
+ * the user gets re-prompted because the token vanished). Mirrors the
+ * delegation-verifier-kv.ts adapter shape.
+ *
+ * Key structure:
+ * - `resume:{token}` — JSON-encoded {@link StoredResumeToken}
+ *
+ * Tokens are minted with CSPRNG entropy (see generateResumeToken in
+ * @kya-os/mcp-i-core), never time+Math.random.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudflareKVResumeTokenStore = void 0;
+const mcp_i_core_1 = require("@kya-os/mcp-i-core");
+// Cloudflare KV requires expirationTtl >= 60 seconds.
+const MIN_KV_TTL_SECONDS = 60;
+function toTtlSeconds(ms) {
+    return Math.max(MIN_KV_TTL_SECONDS, Math.ceil(ms / 1000));
+}
+class CloudflareKVResumeTokenStore {
+    kv;
+    ttlMs;
+    constructor(kv, ttlMs = 600_000) {
+        this.kv = kv;
+        this.ttlMs = ttlMs;
+    }
+    key(token) {
+        return `resume:${token}`;
+    }
+    async read(token) {
+        const raw = await this.kv.get(this.key(token));
+        if (!raw)
+            return null;
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    async create(agentDid, scopes, metadata) {
+        const token = (0, mcp_i_core_1.generateResumeToken)("rt");
+        const now = Date.now();
+        const record = {
+            agentDid,
+            scopes,
+            createdAt: now,
+            expiresAt: now + this.ttlMs,
+            metadata,
+            fulfilled: false,
+        };
+        await this.kv.put(this.key(token), JSON.stringify(record), {
+            expirationTtl: toTtlSeconds(this.ttlMs),
+        });
+        return token;
+    }
+    async get(token) {
+        const record = await this.read(token);
+        if (!record)
+            return null;
+        if (Date.now() > record.expiresAt) {
+            await this.kv.delete(this.key(token));
+            return null;
+        }
+        if (record.fulfilled)
+            return null;
+        return {
+            agentDid: record.agentDid,
+            scopes: record.scopes,
+            createdAt: record.createdAt,
+            expiresAt: record.expiresAt,
+            metadata: record.metadata,
+        };
+    }
+    async fulfill(token) {
+        const record = await this.read(token);
+        if (!record)
+            return;
+        record.fulfilled = true;
+        // Preserve the original expiry window so a fulfilled token can't outlive
+        // its TTL; floor at the KV minimum.
+        const remainingMs = Math.max(0, record.expiresAt - Date.now());
+        await this.kv.put(this.key(token), JSON.stringify(record), {
+            expirationTtl: toTtlSeconds(remainingMs),
+        });
+    }
+}
+exports.CloudflareKVResumeTokenStore = CloudflareKVResumeTokenStore;

package/dist/runtime/resume-token-store.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Resume Token Store Factory
+ *
+ * Selects a {@link ResumeTokenStore} implementation from config, mirroring the
+ * delegation-verifier factory (`createDelegationVerifier`). This replaces the
+ * hardcoded in-memory store in the runtime so consent→reuse can be made durable
+ * (Cloudflare KV) on multi-instance / serverless deployments, while keeping the
+ * in-memory store as an EXPLICIT single-process dev default.
+ */
+import { type ResumeTokenStore } from "@kya-os/mcp-i-core";
+import { type ResumeTokenKVNamespace } from "./resume-token-store-kv";
+/**
+ * Configuration for resume-token stores.
+ *
+ * - `memory` — in-memory TTL map. Single-process dev only; tokens are lost on
+ *   restart and not shared across instances.
+ * - `cloudflare-kv` — durable, edge-replicated. Survives cold starts/restarts.
+ */
+export interface ResumeTokenStoreConfig {
+    type: "memory" | "cloudflare-kv";
+    /** Token TTL in milliseconds (default: 600_000 = 10 minutes). */
+    ttlMs?: number;
+    /** Cloudflare KV namespace (required for `cloudflare-kv`). */
+    kvNamespace?: ResumeTokenKVNamespace;
+}
+/**
+ * Create a resume-token store from config. Memory is an explicit opt-in for
+ * single-process development; durable stores must be selected deliberately.
+ */
+export declare function createResumeTokenStore(config: ResumeTokenStoreConfig): ResumeTokenStore;

package/dist/runtime/resume-token-store.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Resume Token Store Factory
+ *
+ * Selects a {@link ResumeTokenStore} implementation from config, mirroring the
+ * delegation-verifier factory (`createDelegationVerifier`). This replaces the
+ * hardcoded in-memory store in the runtime so consent→reuse can be made durable
+ * (Cloudflare KV) on multi-instance / serverless deployments, while keeping the
+ * in-memory store as an EXPLICIT single-process dev default.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResumeTokenStore = createResumeTokenStore;
+const mcp_i_core_1 = require("@kya-os/mcp-i-core");
+const resume_token_store_kv_1 = require("./resume-token-store-kv");
+const DEFAULT_TTL_MS = 600_000;
+function invalidConfig(message) {
+    const runtimeError = {
+        error: "invalid_config",
+        message,
+        httpStatus: 500,
+    };
+    const error = new Error(runtimeError.message);
+    Object.assign(error, runtimeError);
+    return error;
+}
+/**
+ * Create a resume-token store from config. Memory is an explicit opt-in for
+ * single-process development; durable stores must be selected deliberately.
+ */
+function createResumeTokenStore(config) {
+    const ttlMs = config.ttlMs ?? DEFAULT_TTL_MS;
+    switch (config.type) {
+        case "cloudflare-kv": {
+            if (!config.kvNamespace) {
+                throw invalidConfig("Resume token store 'cloudflare-kv' requires kvNamespace in config");
+            }
+            return new resume_token_store_kv_1.CloudflareKVResumeTokenStore(config.kvNamespace, ttlMs);
+        }
+        case "memory":
+            return new mcp_i_core_1.MemoryResumeTokenStore(ttlMs);
+        default: {
+            const configType = "type" in config ? config.type : "unknown";
+            throw invalidConfig(`Unknown resume token store type: ${configType}`);
+        }
+    }
+}

package/dist/runtime/session.d.ts

@@ -7,8 +7,8 @@
  *
  * Requirements: 4.5-4.9, 19.1-19.2
  */
-import { SessionManager as CoreSessionManager, createHandshakeRequest, validateHandshakeFormat, type SessionConfig, type HandshakeResult } from "@kya-os/mcp-i-core";
-import { CryptoProvider } from "@kya-os/mcp-i-core";
+import { SessionManager as CoreSessionManager, createHandshakeRequest, validateHandshakeFormat, type SessionConfig, type HandshakeResult } from "@kya-os/mcp-i-runtime";
+import { CryptoProvider } from "@kya-os/mcp-i-runtime";
 export type { SessionConfig, HandshakeResult };
 export { createHandshakeRequest, validateHandshakeFormat };
 export declare class SessionManager extends CoreSessionManager {

package/dist/runtime/session.js

@@ -10,10 +10,16 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultSessionManager = exports.SessionManager = exports.validateHandshakeFormat = exports.createHandshakeRequest = void 0;
-const mcp_i_core_1 = require("@kya-os/mcp-i-core");
-Object.defineProperty(exports, "createHandshakeRequest", { enumerable: true, get: function () { return mcp_i_core_1.createHandshakeRequest; } });
-Object.defineProperty(exports, "validateHandshakeFormat", { enumerable: true, get: function () { return mcp_i_core_1.validateHandshakeFormat; } });
-const mcp_i_core_2 = require("@kya-os/mcp-i-core");
+const mcp_i_runtime_1 = require("@kya-os/mcp-i-runtime");
+Object.defineProperty(exports, "createHandshakeRequest", { enumerable: true, get: function () { return mcp_i_runtime_1.createHandshakeRequest; } });
+Object.defineProperty(exports, "validateHandshakeFormat", { enumerable: true, get: function () { return mcp_i_runtime_1.validateHandshakeFormat; } });
+const mcp_i_runtime_2 = require("@kya-os/mcp-i-runtime");
+// C2 (#2916): the CJS/ESM (TS1479) blocker is resolved — PR-0's loadDifCore()
+// seam (mcp-i-core/src/runtime/dif-core.ts) reaches the ESM-only @kya-os/mcp from
+// CJS. The SessionManager re-home stays deferred on the remaining blocker: DIF
+// emits kyaos_* session IDs, a wire-format change owned by the C4 (#2918)
+// dual-accept window. Keep importing the OLD SessionManager from @kya-os/mcp-i-core
+// until then.
 const node_providers_1 = require("../providers/node-providers");
 function resolveNodeConfig(config) {
     const skewEnv = process.env["XMCP_I_TS_SKEW_SEC"];
@@ -28,9 +34,9 @@ function resolveNodeConfig(config) {
             (parsedTtl !== undefined && !isNaN(parsedTtl) ? parsedTtl : undefined),
     };
 }
-class SessionManager extends mcp_i_core_1.SessionManager {
+class SessionManager extends mcp_i_runtime_1.SessionManager {
     constructor(configOrCrypto, config) {
-        if (configOrCrypto instanceof mcp_i_core_2.CryptoProvider) {
+        if (configOrCrypto instanceof mcp_i_runtime_2.CryptoProvider) {
             super(configOrCrypto, resolveNodeConfig(config ?? {}));
         }
         else {