@frontmcp/utils 1.10.16 → 1.11.0-rc.2

package/browser/process/process-watch.mjs

@@ -0,0 +1,48 @@
+// libs/utils/src/process/process-watch.ts
+import { isMissingSync } from "../fs/fs.mjs";
+import { isPidRunning } from "./process-tree.mjs";
+var DEFAULT_INTERVAL_MS = 1e3;
+function watchParent(options, deps) {
+  const d = { ppid: () => process.ppid, kill: (pid, signal) => process.kill(pid, signal), ...deps };
+  const parentPid = d.ppid();
+  const stdin = options.stdin;
+  let timer;
+  let closed = false;
+  const close = () => {
+    closed = true;
+    clearInterval(timer);
+    stdin?.removeListener("end", onStdinEnded);
+    stdin?.removeListener("close", onStdinEnded);
+  };
+  const report = (reason) => {
+    if (closed) return;
+    close();
+    options.onGone(reason);
+  };
+  function onStdinEnded() {
+    report("stdin-ended");
+  }
+  if (stdin?.readableEnded || stdin?.destroyed) queueMicrotask(onStdinEnded);
+  stdin?.once("end", onStdinEnded);
+  stdin?.once("close", onStdinEnded);
+  if (parentPid > 1) {
+    timer = setInterval(() => {
+      if (d.ppid() !== parentPid || !isPidRunning(parentPid, d)) report("parent-exited");
+    }, options.intervalMs ?? DEFAULT_INTERVAL_MS);
+    timer.unref();
+  }
+  return { close };
+}
+function watchPath(path, options) {
+  const timer = setInterval(() => {
+    if (!isMissingSync(path)) return;
+    clearInterval(timer);
+    options.onGone();
+  }, options.intervalMs ?? DEFAULT_INTERVAL_MS);
+  timer.unref();
+  return { close: () => clearInterval(timer) };
+}
+export {
+  watchParent,
+  watchPath
+};

package/browser/redaction/index.mjs

@@ -0,0 +1,6 @@
+// libs/utils/src/redaction/index.ts
+import { redactFields, redactJson } from "./redaction.mjs";
+export {
+  redactFields,
+  redactJson
+};

package/browser/redaction/redaction.mjs

@@ -0,0 +1,74 @@
+// libs/utils/src/redaction/redaction.ts
+var REDACTED = "[REDACTED]";
+function redactFields(obj, fields, maxDepth = 5) {
+  if (typeof fields !== "function" && fields.length === 0) return obj;
+  return redactRecord(obj, 0, { isSensitive: sensitiveKeyTest(fields), maxDepth, jsonText: false });
+}
+function redactJson(value, fields) {
+  return redactValue(value, 0, { isSensitive: sensitiveKeyTest(fields), maxDepth: Infinity, jsonText: true });
+}
+function sensitiveKeyTest(fields) {
+  if (typeof fields === "function") return fields;
+  const names = new Set(fields.map((field) => field.toLowerCase()));
+  return (key) => names.has(key.toLowerCase());
+}
+function redactValue(value, depth, options) {
+  if (typeof value === "string") return options.jsonText ? redactJsonText(value, depth, options) : value;
+  if (Array.isArray(value)) return value.map((item) => redactValue(item, depth, options));
+  if (isPlainObject(value)) return redactRecord(value, depth, options);
+  return value;
+}
+function redactRecord(obj, depth, options) {
+  if (depth >= options.maxDepth) return obj;
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    result[key] = options.isSensitive(key) ? REDACTED : redactValue(value, depth + 1, options);
+  }
+  return result;
+}
+var AUTH_SCHEME_CREDENTIAL = /\b(Bearer|Basic)([ \t]+)(?=[\w.~+/-]*[\d.~+/_-])[\w.~+/-]{8,}=*/gi;
+var JWT = /(?<![\w-])eyJ[\w-]+(?:\.[\w-]*){2,4}/g;
+var URL_CREDENTIALS = /(?<![a-z\d+.-])([a-z][a-z\d+.-]*:\/\/)[^\s/?#@]+@/gi;
+var VALUE_NAME = /(?:^|[?&#;,{("'\s])(["']?)([A-Za-z_][\w.-]*)\1[ \t]*[:=][ \t]*/g;
+var NAMED_VALUE = /"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'|[^\s"'&#;?,)}]+/y;
+function redactNamedValues(text, isSensitive) {
+  let redacted = "";
+  let copiedUpTo = 0;
+  VALUE_NAME.lastIndex = 0;
+  for (let name = VALUE_NAME.exec(text); name; name = VALUE_NAME.exec(text)) {
+    if (!isSensitive(name[2])) continue;
+    NAMED_VALUE.lastIndex = VALUE_NAME.lastIndex;
+    const value = NAMED_VALUE.exec(text)?.[0];
+    if (value === void 0) continue;
+    const quote = value[0] === '"' || value[0] === "'" ? value[0] : "";
+    redacted += `${text.slice(copiedUpTo, VALUE_NAME.lastIndex)}${quote}${REDACTED}${quote}`;
+    copiedUpTo = VALUE_NAME.lastIndex + value.length;
+    VALUE_NAME.lastIndex = copiedUpTo;
+  }
+  return copiedUpTo === 0 ? text : redacted + text.slice(copiedUpTo);
+}
+function redactCredentialText(text, isSensitive) {
+  const withoutCredentials = text.replace(AUTH_SCHEME_CREDENTIAL, `$1$2${REDACTED}`).replace(JWT, REDACTED).replace(URL_CREDENTIALS, `$1${REDACTED}@`);
+  return redactNamedValues(withoutCredentials, isSensitive);
+}
+function redactJsonText(text, depth, options) {
+  const start = text.trimStart()[0];
+  if (start !== "{" && start !== "[") return redactCredentialText(text, options.isSensitive);
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return redactCredentialText(text, options.isSensitive);
+  }
+  const redacted = JSON.stringify(redactValue(parsed, depth, options));
+  return redacted === JSON.stringify(parsed) ? text : redacted;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+export {
+  redactFields,
+  redactJson
+};

package/browser/regex/index.mjs

@@ -0,0 +1,3 @@
+// libs/utils/src/regex/index.ts
+export { DEFAULT_MAX_INPUT_LENGTH, REDOS_THRESHOLDS, analyzePattern, createSafeRegExp, isInputLengthSafe, isPatternSafe, safeExec, safeMatch, safeReplace, safeTest } from "./safe-regex.mjs";
+export { collapseChar, collapseWhitespace, expandTemplate, extractBracedParams, hasTemplatePlaceholders, trimBoth, trimChars, trimLeading, trimTrailing } from "./patterns.mjs";

package/browser/regex/patterns.mjs

@@ -0,0 +1,167 @@
+// libs/utils/src/regex/patterns.ts
+import { DEFAULT_MAX_INPUT_LENGTH } from "./safe-regex.mjs";
+function trimLeading(input, char) {
+  if (!input || char.length !== 1) {
+    return input ?? "";
+  }
+  let start = 0;
+  while (start < input.length && input[start] === char) {
+    start++;
+  }
+  return start === 0 ? input : input.slice(start);
+}
+function trimTrailing(input, char) {
+  if (!input || char.length !== 1) {
+    return input ?? "";
+  }
+  let end = input.length;
+  while (end > 0 && input[end - 1] === char) {
+    end--;
+  }
+  return end === input.length ? input : input.slice(0, end);
+}
+function trimBoth(input, char) {
+  return trimTrailing(trimLeading(input, char), char);
+}
+function trimChars(input, chars) {
+  if (!input || chars.size === 0) {
+    return input ?? "";
+  }
+  let start = 0;
+  while (start < input.length && chars.has(input[start])) {
+    start++;
+  }
+  let end = input.length;
+  while (end > start && chars.has(input[end - 1])) {
+    end--;
+  }
+  return input.slice(start, end);
+}
+function extractBracedParams(template, maxLength = DEFAULT_MAX_INPUT_LENGTH) {
+  if (!template || template.length > maxLength) {
+    return [];
+  }
+  const params = [];
+  let i = 0;
+  while (i < template.length) {
+    const openBrace = template.indexOf("{", i);
+    if (openBrace === -1) {
+      break;
+    }
+    const closeBrace = template.indexOf("}", openBrace + 1);
+    if (closeBrace === -1) {
+      break;
+    }
+    const nestedOpen = template.indexOf("{", openBrace + 1);
+    if (nestedOpen !== -1 && nestedOpen < closeBrace) {
+      i = nestedOpen + 1;
+      continue;
+    }
+    const paramName = template.slice(openBrace + 1, closeBrace).trim();
+    if (paramName && !paramName.includes("{") && !paramName.includes("}")) {
+      params.push(paramName);
+    }
+    i = closeBrace + 1;
+  }
+  return params;
+}
+function expandTemplate(template, values, maxLength = DEFAULT_MAX_INPUT_LENGTH) {
+  if (!template || template.length > maxLength) {
+    return template ?? "";
+  }
+  let result = "";
+  let i = 0;
+  while (i < template.length) {
+    const openBrace = template.indexOf("{", i);
+    if (openBrace === -1) {
+      result += template.slice(i);
+      break;
+    }
+    result += template.slice(i, openBrace);
+    const closeBrace = template.indexOf("}", openBrace + 1);
+    if (closeBrace === -1) {
+      result += template.slice(openBrace);
+      break;
+    }
+    const nestedOpen = template.indexOf("{", openBrace + 1);
+    if (nestedOpen !== -1 && nestedOpen < closeBrace) {
+      result += "{";
+      i = openBrace + 1;
+      continue;
+    }
+    const paramName = template.slice(openBrace + 1, closeBrace).trim();
+    if (paramName in values) {
+      result += values[paramName];
+    } else {
+      result += template.slice(openBrace, closeBrace + 1);
+    }
+    i = closeBrace + 1;
+  }
+  return result;
+}
+function hasTemplatePlaceholders(str, maxLength = DEFAULT_MAX_INPUT_LENGTH) {
+  if (!str || str.length > maxLength) {
+    return false;
+  }
+  const openBrace = str.indexOf("{");
+  if (openBrace === -1) {
+    return false;
+  }
+  const closeBrace = str.indexOf("}", openBrace + 1);
+  return closeBrace > openBrace + 1;
+}
+function collapseChar(input, char) {
+  if (!input || char.length !== 1) {
+    return input ?? "";
+  }
+  let result = "";
+  let lastWasChar = false;
+  for (let i = 0; i < input.length; i++) {
+    const c = input[i];
+    if (c === char) {
+      if (!lastWasChar) {
+        result += c;
+        lastWasChar = true;
+      }
+    } else {
+      result += c;
+      lastWasChar = false;
+    }
+  }
+  return result;
+}
+function collapseWhitespace(input, maxLength = DEFAULT_MAX_INPUT_LENGTH) {
+  if (!input) {
+    return "";
+  }
+  if (input.length > maxLength) {
+    return input;
+  }
+  let result = "";
+  let lastWasWhitespace = false;
+  for (let i = 0; i < input.length; i++) {
+    const c = input[i];
+    const isWhitespace = c === " " || c === "	" || c === "\n" || c === "\r" || c === "\f" || c === "\v";
+    if (isWhitespace) {
+      if (!lastWasWhitespace) {
+        result += " ";
+        lastWasWhitespace = true;
+      }
+    } else {
+      result += c;
+      lastWasWhitespace = false;
+    }
+  }
+  return result;
+}
+export {
+  collapseChar,
+  collapseWhitespace,
+  expandTemplate,
+  extractBracedParams,
+  hasTemplatePlaceholders,
+  trimBoth,
+  trimChars,
+  trimLeading,
+  trimTrailing
+};

package/browser/regex/safe-regex.mjs

@@ -0,0 +1,93 @@
+// libs/utils/src/regex/safe-regex.ts
+import { analyzeForReDoS, REDOS_THRESHOLDS } from "@enclave-vm/ast/redos";
+var DEFAULT_MAX_INPUT_LENGTH = 5e4;
+function analyzePattern(pattern, level = "polynomial") {
+  const patternStr = typeof pattern === "string" ? pattern : pattern.source;
+  try {
+    new RegExp(patternStr);
+  } catch {
+    return {
+      safe: false,
+      score: 100,
+      vulnerabilityType: "invalid_syntax",
+      explanation: "Pattern has invalid regex syntax"
+    };
+  }
+  try {
+    const result = analyzeForReDoS(patternStr, level);
+    return {
+      safe: !result.vulnerable,
+      score: result.score,
+      vulnerabilityType: result.vulnerabilityType,
+      explanation: result.explanation
+    };
+  } catch {
+    return {
+      safe: false,
+      score: 100,
+      vulnerabilityType: "analysis_failed",
+      explanation: "Pattern analysis failed - treating as potentially unsafe"
+    };
+  }
+}
+function isPatternSafe(pattern, level = "polynomial") {
+  return analyzePattern(pattern, level).safe;
+}
+function createSafeRegExp(pattern, flags, options = {}) {
+  const { level = "polynomial", throwOnVulnerable = false } = options;
+  const analysis = analyzePattern(pattern, level);
+  if (!analysis.safe) {
+    if (throwOnVulnerable) {
+      throw new Error(`Vulnerable regex pattern detected: ${analysis.explanation || analysis.vulnerabilityType}`);
+    }
+    return null;
+  }
+  try {
+    return new RegExp(pattern, flags);
+  } catch {
+    return null;
+  }
+}
+function safeTest(pattern, input, options = {}) {
+  const { maxInputLength = DEFAULT_MAX_INPUT_LENGTH } = options;
+  if (input.length > maxInputLength) {
+    return null;
+  }
+  return pattern.test(input);
+}
+function safeMatch(pattern, input, options = {}) {
+  const { maxInputLength = DEFAULT_MAX_INPUT_LENGTH } = options;
+  if (input.length > maxInputLength) {
+    return null;
+  }
+  return input.match(pattern);
+}
+function safeReplace(input, pattern, replacement, options = {}) {
+  const { maxInputLength = DEFAULT_MAX_INPUT_LENGTH } = options;
+  if (input.length > maxInputLength) {
+    return input;
+  }
+  return input.replace(pattern, replacement);
+}
+function safeExec(pattern, input, options = {}) {
+  const { maxInputLength = DEFAULT_MAX_INPUT_LENGTH } = options;
+  if (input.length > maxInputLength) {
+    return null;
+  }
+  return pattern.exec(input);
+}
+function isInputLengthSafe(input, maxLength = DEFAULT_MAX_INPUT_LENGTH) {
+  return input.length <= maxLength;
+}
+export {
+  DEFAULT_MAX_INPUT_LENGTH,
+  REDOS_THRESHOLDS,
+  analyzePattern,
+  createSafeRegExp,
+  isInputLengthSafe,
+  isPatternSafe,
+  safeExec,
+  safeMatch,
+  safeReplace,
+  safeTest
+};

package/browser/serialization/index.mjs

@@ -0,0 +1,5 @@
+// libs/utils/src/serialization/index.ts
+import { safeStringify } from "./serialization.mjs";
+export {
+  safeStringify
+};

package/browser/serialization/serialization.mjs

@@ -0,0 +1,22 @@
+// libs/utils/src/serialization/serialization.ts
+function safeStringify(value, space) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(
+      value,
+      (_key, val) => {
+        if (typeof val === "object" && val !== null) {
+          if (seen.has(val)) return "[Circular]";
+          seen.add(val);
+        }
+        return val;
+      },
+      space
+    );
+  } catch {
+    return JSON.stringify({ error: "Output could not be serialized" });
+  }
+}
+export {
+  safeStringify
+};

package/browser/stdio-bridge/errors.mjs

@@ -0,0 +1,27 @@
+// libs/utils/src/stdio-bridge/errors.ts
+var DEV_SERVER_UNREACHABLE = -32099;
+var DEV_BUFFER_FULL = -32098;
+var DEV_RELOAD_DEADLINE = -32097;
+var DEV_ERROR_MESSAGE = {
+  [DEV_SERVER_UNREACHABLE]: "dev_server_unreachable",
+  [DEV_BUFFER_FULL]: "dev_buffer_full",
+  [DEV_RELOAD_DEADLINE]: "dev_reload_deadline"
+};
+function makeDevError(id, code, data) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code,
+      message: DEV_ERROR_MESSAGE[code] ?? "dev_error",
+      ...data ? { data } : {}
+    }
+  };
+}
+export {
+  DEV_BUFFER_FULL,
+  DEV_ERROR_MESSAGE,
+  DEV_RELOAD_DEADLINE,
+  DEV_SERVER_UNREACHABLE,
+  makeDevError
+};

package/browser/stdio-bridge/index.mjs

@@ -0,0 +1,24 @@
+// libs/utils/src/stdio-bridge/index.ts
+import {
+  DEV_BUFFER_FULL,
+  DEV_ERROR_MESSAGE,
+  DEV_RELOAD_DEADLINE,
+  DEV_SERVER_UNREACHABLE,
+  makeDevError
+} from "./errors.mjs";
+import { listChangedNotifications } from "./list-changed.mjs";
+import { createBridgeStateMachine } from "./state-machine.mjs";
+import { createStdioFramer } from "./stdio-framer.mjs";
+import { createHttpUpstream, createPipeUpstream } from "./upstream-client.mjs";
+export {
+  DEV_BUFFER_FULL,
+  DEV_ERROR_MESSAGE,
+  DEV_RELOAD_DEADLINE,
+  DEV_SERVER_UNREACHABLE,
+  createBridgeStateMachine,
+  createHttpUpstream,
+  createPipeUpstream,
+  createStdioFramer,
+  listChangedNotifications,
+  makeDevError
+};

package/browser/stdio-bridge/list-changed.mjs

@@ -0,0 +1,21 @@
+// libs/utils/src/stdio-bridge/list-changed.ts
+var LIST_CHANGED = {
+  tools: "notifications/tools/list_changed",
+  resources: "notifications/resources/list_changed",
+  prompts: "notifications/prompts/list_changed"
+};
+function listChangedNotifications(initializeResult) {
+  const capabilities = initializeResult?.["capabilities"];
+  if (typeof capabilities !== "object" || capabilities === null) return [];
+  const frames = [];
+  for (const [capability, method] of Object.entries(LIST_CHANGED)) {
+    const entry = capabilities[capability];
+    if (typeof entry === "object" && entry !== null && entry.listChanged === true) {
+      frames.push({ jsonrpc: "2.0", method });
+    }
+  }
+  return frames;
+}
+export {
+  listChangedNotifications
+};