@knitli/openapi-mcp 1.4.0 → 1.4.1

package/dist/operations.js

@@ -90,7 +90,11 @@ export function resolveCanonicalPointer(doc, pointer) {
                 !Object.hasOwn(node, index)) {
                 throw new Error("JSON Pointer array index was not found");
             }
-            node = node[index];
+            const element = Object.getOwnPropertyDescriptor(node, index);
+            if (element === undefined || !("value" in element)) {
+                throw new Error("JSON Pointer array index was not found");
+            }
+            node = element.value;
             continue;
         }
         if (typeof node !== "object" ||

package/dist/runtime/manifest.js

@@ -90,7 +90,8 @@ function requireString(value, label, maximum, pattern) {
     if (typeof value !== "string" ||
         value.length === 0 ||
         value.length > maximum ||
-        (pattern && !pattern.test(value))) {
+        (pattern && !pattern.test(value)) // nosemgrep -- anchored linear-time literal; length capped by maximum above
+    ) {
         throw manifestInvalid(`${label} is invalid`);
     }
     return value;
@@ -107,7 +108,10 @@ function requireInteger(value, label) {
     return value;
 }
 function requireDigest(value, label) {
-    if (typeof value !== "string" || !digestPattern.test(value))
+    if (typeof value !== "string" ||
+        value.length !== 64 ||
+        !digestPattern.test(value) // nosemgrep -- anchored fixed-length linear literal; length pinned to 64 above
+    )
         throw manifestInvalid(`${label} is invalid`);
     return value;
 }

package/dist/runtime/references.js

@@ -17,7 +17,8 @@ function assertSegment(value, maximumLength, pattern, label) {
         value.length > maximumLength ||
         value === "." ||
         value === ".." ||
-        !pattern.test(value)) {
+        !pattern.test(value) // nosemgrep -- anchored linear-time literal; length capped by maximumLength above
+    ) {
         throw invalidReference(`${label} is invalid`);
     }
 }

package/dist/runtime/strict-json.js

@@ -530,7 +530,7 @@ function serializeCanonical(value, ancestors) {
 }
 function isCanonicalArrayIndex(key, length) {
     if (!/^(?:0|[1-9]\d*)$/.test(key))
-        return false;
+        return false; // nosemgrep -- anchored literal, disjoint alternation, single star: linear-time
     const index = Number(key);
     return (Number.isSafeInteger(index) &&
         index >= 0 &&

package/dist/sqlite/generation-store.js

@@ -70,7 +70,7 @@ function requireIdentity(catalogId, issuer) {
         catalogId.length > 128 ||
         catalogId === "." ||
         catalogId === ".." ||
-        !identityPattern.test(catalogId) ||
+        !identityPattern.test(catalogId) || // nosemgrep -- anchored linear-time literal; input length is capped at 128 above
         typeof issuer !== "string" ||
         issuer.length === 0 ||
         issuer.length > 256 ||
@@ -299,16 +299,76 @@ async function validateMutexMetadata(mutex) {
     }
     return before;
 }
-function regexEscape(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const mutexInitSuffix = ".mutex-init";
+const mutexInitUuidSegments = [8, 4, 4, 4, 12];
+function isAsciiHexDigit(code) {
+    return ((code >= 0x30 && code <= 0x39) ||
+        (code >= 0x41 && code <= 0x46) ||
+        (code >= 0x61 && code <= 0x66));
+}
+function isMutexInitializerUuid(candidate) {
+    // 8-4-4-4-12 lowercase/uppercase hex with version 1-5 and variant 8/9/a/b.
+    if (candidate.length !== 36)
+        return false;
+    let position = 0;
+    for (let segment = 0; segment < mutexInitUuidSegments.length; segment += 1) {
+        if (segment > 0) {
+            if (candidate[position] !== "-")
+                return false;
+            position += 1;
+        }
+        const length = mutexInitUuidSegments[segment];
+        for (let index = 0; index < length; index += 1) {
+            const code = candidate.charCodeAt(position);
+            if (segment === 2 && index === 0) {
+                if (code < 0x31 || code > 0x35)
+                    return false;
+            }
+            else if (segment === 3 && index === 0) {
+                if (code !== 0x38 &&
+                    code !== 0x39 &&
+                    code !== 0x41 &&
+                    code !== 0x42 &&
+                    code !== 0x61 &&
+                    code !== 0x62)
+                    return false;
+            }
+            else if (!isAsciiHexDigit(code)) {
+                return false;
+            }
+            position += 1;
+        }
+    }
+    return true;
+}
+function isMutexInitializerAlias(name, targetName) {
+    // Matches `.<target>.<digits>.<uuid>.mutex-init` case-insensitively,
+    // without building a RegExp from the target name.
+    const prefix = `.${targetName}.`;
+    if (name.length < prefix.length + 1 + 1 + 36 + mutexInitSuffix.length)
+        return false;
+    if (name.slice(0, prefix.length).toLowerCase() !== prefix.toLowerCase())
+        return false;
+    if (name.slice(-mutexInitSuffix.length).toLowerCase() !== mutexInitSuffix)
+        return false;
+    const middle = name.slice(prefix.length, -mutexInitSuffix.length);
+    const separator = middle.indexOf(".");
+    if (separator <= 0)
+        return false;
+    const counter = middle.slice(0, separator);
+    for (let index = 0; index < counter.length; index += 1) {
+        const code = counter.charCodeAt(index);
+        if (code < 0x30 || code > 0x39)
+            return false;
+    }
+    return isMutexInitializerUuid(middle.slice(separator + 1));
 }
 async function clearMutexInitializerAlias(location) {
     const final = await lstat(location.mutex);
-    const namePattern = new RegExp(`^\\.${regexEscape(basename(location.target))}\\.\\d+\\.` +
-        "[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\\.mutex-init$", "i");
+    const targetName = basename(location.target);
     let removed = false;
     for (const name of await readdir(location.parent)) {
-        if (!namePattern.test(name))
+        if (!isMutexInitializerAlias(name, targetName))
             continue;
         const candidate = join(location.parent, name);
         let metadata;

package/dist/stdio/authorizer.js

@@ -1,3 +1,4 @@
+import { timingSafeEqual } from "node:crypto";
 import { acceptedContent, inputResponse, } from "@modelcontextprotocol/server";
 import { z } from "zod";
 import { snapshotCredentialAuthorizationBinding } from "../runtime/credential-binding.js";
@@ -54,6 +55,11 @@ function hexRandom(randomBytes) {
     }
     return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
+function randomIdsEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return timingSafeEqual(Buffer.from(left), Buffer.from(right));
+}
 function exactPayloadMatch(payload, pending) {
     return (payload.pendingId === pending.pendingId &&
         payload.callDigest === pending.callDigest &&
@@ -416,7 +422,7 @@ class LedgerActionAuthorizer {
             const authorizationId = Object.freeze(Object.create(null));
             let collision = false;
             for (const existing of this.#receipts.values()) {
-                if (existing.randomId === token) {
+                if (randomIdsEqual(existing.randomId, token)) {
                     collision = true;
                     break;
                 }

package/dist/stdio/server.js

@@ -138,12 +138,45 @@ function outcome(value, snapshot) {
     ]
         .filter(Boolean)
         .sort((left, right) => right.length - left.length);
-    const pattern = variants.length
-        ? new RegExp(variants
-            .map((entry) => entry.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
-            .join("|"), "g")
-        : undefined;
-    const redact = (text) => pattern ? text.replace(pattern, "[REDACTED]") : text;
+    // Literal redaction without a dynamic RegExp: find the earliest occurrence
+    // across variants (ties broken longest-first, matching the previous
+    // longest-first alternation), redact it, and resume after the match.
+    // indexOf skips non-matching regions in native code, so adversarial
+    // long-prefix inputs stay linear instead of quadratic per offset.
+    const redact = (text) => {
+        if (variants.length === 0 || text.length === 0)
+            return text;
+        const parts = [];
+        let cursor = 0;
+        let redacted = false;
+        for (;;) {
+            let at = -1;
+            let match = "";
+            for (const variant of variants) {
+                const found = text.indexOf(variant, cursor);
+                if (found === -1)
+                    continue;
+                if (at === -1 ||
+                    found < at ||
+                    (found === at && variant.length > match.length)) {
+                    at = found;
+                    match = variant;
+                }
+            }
+            if (at === -1)
+                break;
+            if (at > cursor)
+                parts.push(text.slice(cursor, at));
+            parts.push("[REDACTED]");
+            cursor = at + match.length;
+            redacted = true;
+        }
+        if (!redacted)
+            return text;
+        if (cursor < text.length)
+            parts.push(text.slice(cursor));
+        return parts.join("");
+    };
     // Only upstream values are untrusted. Keep protocol fields and opaque tokens intact.
     if (value.kind === "success") {
         try {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@knitli/openapi-mcp",
   "private": false,
-  "version": "1.4.0",
+  "version": "1.4.1",
   "type": "module",
   "description": "Compile signed OpenAPI catalogs and serve verified search and authorized API calls over MCP.",
   "license": "MIT OR Apache-2.0",
@@ -73,7 +73,7 @@
   "dependencies": {
     "@modelcontextprotocol/server": "2.0.0",
     "undici": "8.10.2",
-    "yaml": "^2.9.0",
+    "yaml": "2.9.0",
     "zod": "4.5.4"
   },
   "devDependencies": {