@deotio/mcp-sigv4-proxy 0.4.0 → 0.4.1

package/dist/proxy.js

@@ -294,6 +294,8 @@ export async function processLine(line, config, signer) {
 const WARM_CACHEABLE = new Set([
     'initialize', 'tools/list', 'resources/list', 'prompts/list',
 ]);
+// Exported for testing
+export { syntheticInitializeResult };
 /**
  * Synthetic MCP initialize response returned when the backend hasn't responded yet.
  * Advertises tools/resources/prompts capabilities so Claude Code proceeds to list calls.
@@ -302,7 +304,7 @@ function syntheticInitializeResult() {
     return {
         protocolVersion: '2025-03-26',
         capabilities: { tools: {}, resources: {}, prompts: {} },
-        serverInfo: { name: 'mcp-sigv4-proxy-warm', version: '0.4.0' },
+        serverInfo: { name: 'mcp-sigv4-proxy-warm', version: '0.4.1' },
     };
 }
 export async function warmBackend(config, signer) {
@@ -437,29 +439,54 @@ export function tryWarmResponse(body, requestId, warmState) {
     // Claude Code sends this too, but in warm mode we intercepted initialize so we handle it.
     return true;
 }
+/**
+ * Handle a single parsed JSON-RPC message in warm mode.
+ * Returns true if the message was served locally (no need to forward to backend).
+ */
+export async function handleWarmLine(input, ws) {
+    const method = JSON.parse(input.body).method;
+    if (method === 'initialize') {
+        // Respond IMMEDIATELY — never block on ws.ready here.
+        // This is the critical path: Claude Code's 30s timeout applies to this response.
+        const result = ws.cache.initialize ?? syntheticInitializeResult();
+        process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: input.requestId, result }) + '\n');
+        log('DEBUG', `warm: served initialize ${ws.cache.initialize ? 'from cache' : 'synthetic'}`);
+        return true;
+    }
+    if (WARM_CACHEABLE.has(method)) {
+        // List methods: serve from cache immediately if available…
+        if (tryWarmResponse(input.body, input.requestId, ws))
+            return true;
+        // …otherwise wait for warm-up to complete, then try cache again before forwarding
+        await ws.ready;
+        if (tryWarmResponse(input.body, input.requestId, ws))
+            return true;
+        // Fall through to forward if warm-up failed or cache still empty
+    }
+    // Non-cacheable methods (tools/call etc): return false to forward normally.
+    // fetchWithRetry handles any residual 424s if the backend isn't warm yet.
+    return false;
+}
 // --- Main entry ---
 export function startProxy() {
     const config = validateEnv();
     const signer = createSigner(config);
     const rl = readline.createInterface({ input: process.stdin, terminal: false });
-    // Start warm-up in background if enabled (non-blocking)
-    let warmState = null;
-    if (config.warm) {
-        warmBackend(config, signer).then((state) => { warmState = state; });
-    }
+    // Start warm-up immediately. warmBackend() has no awaits before returning the WarmState
+    // object, so this promise resolves in the next microtask — effectively instant. The
+    // warmState.ready promise inside it is what takes minutes to resolve.
+    const warmStateP = config.warm
+        ? warmBackend(config, signer)
+        : null;
     let pending = Promise.resolve();
     rl.on('line', (line) => {
         pending = pending.then(async () => {
-            // In warm mode, try to serve from cache first
-            if (warmState) {
+            if (warmStateP) {
                 const input = parseInputLine(line);
                 if (input) {
-                    // Wait for warm-up to finish before deciding
-                    const warmActive = await warmState.ready;
-                    if (warmActive && tryWarmResponse(input.body, input.requestId, warmState)) {
-                        return; // served from cache
-                    }
-                    // Fall through: warm mode inactive or method not cacheable — forward normally
+                    const ws = await warmStateP; // resolves almost instantly
+                    if (await handleWarmLine(input, ws))
+                        return;
                 }
             }
             await processLine(line, config, signer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deotio/mcp-sigv4-proxy",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "stdio MCP proxy with AWS SigV4 signing — connect Claude Code to any IAM-authenticated MCP server using a named AWS profile",
   "type": "module",
   "bin": {
@@ -19,16 +19,16 @@
   "dependencies": {
     "@aws-sdk/credential-providers": "^3.0.0",
     "@aws-crypto/sha256-js": "^5.0.0",
-    "@smithy/protocol-http": "^4.0.0",
+    "@smithy/protocol-http": "^5.3.12",
     "@smithy/signature-v4": "^4.0.0"
   },
   "devDependencies": {
-    "@types/jest": "^29.0.0",
+    "@types/jest": "^30.0.0",
     "@types/node": "^22.0.0",
     "@typescript-eslint/eslint-plugin": "^7.0.0",
     "@typescript-eslint/parser": "^7.0.0",
     "eslint": "^8.0.0",
-    "jest": "^29.0.0",
+    "jest": "^30.3.0",
     "prettier": "^3.0.0",
     "ts-jest": "^29.0.0",
     "typescript": "^5.0.0"