@frontmcp/utils 1.10.16 → 1.11.0-rc.1

package/browser/index.mjs

@@ -0,0 +1,526 @@
+// libs/utils/src/index.ts
+import { splitWords, toCase, sepFor, shortHash, ensureMaxLen, idFromString } from "./naming/index.mjs";
+import {
+  isValidMcpUri,
+  extractUriScheme,
+  isValidMcpUriTemplate,
+  parseUriTemplate,
+  matchUriTemplate,
+  expandUriTemplate,
+  extractTemplateParams,
+  isUriTemplate
+} from "./uri/index.mjs";
+import {
+  trimSlashes,
+  joinPath,
+  pathResolve,
+  pathJoin,
+  basename,
+  dirname,
+  extname,
+  isAbsolute,
+  pathToFileURL,
+  sep
+} from "./path/index.mjs";
+import { sanitizeToJson, inferMimeType, findNonFiniteNumber, findDroppedKeys } from "./content/index.mjs";
+import { validateBaseUrl, buildSetCookie, parseCookies, getCookie, isLocalhost, isSecureRequest } from "./http/index.mjs";
+import { classifyIpAddress, expandIpv6, extractEmbeddedIpv4, parseIpv4, isRedirectResponse } from "./net/index.mjs";
+import {
+  readFile,
+  readFileSync,
+  readFileBuffer,
+  writeFile,
+  appendFile,
+  mkdir,
+  rename,
+  unlink,
+  stat,
+  lstat,
+  chmod,
+  copyFile,
+  cp,
+  readdir,
+  readdirSync,
+  realpath,
+  rm,
+  mkdtemp,
+  symlink,
+  access,
+  fileExists,
+  fileExistsSync,
+  readJSON,
+  writeJSON,
+  ensureDir,
+  ensureDirSync,
+  isDirEmpty,
+  runCmd,
+  watchFile,
+  getSpawnFn
+} from "./fs/index.mjs";
+import {
+  processTreeSpawnOptions,
+  signalProcessTree,
+  isProcessTreeAlive,
+  stopProcessTree,
+  spawnOwned,
+  reapOrphans,
+  OwnedProcessError,
+  watchParent,
+  watchPath
+} from "./process/index.mjs";
+import {
+  DEV_BUFFER_FULL,
+  DEV_ERROR_MESSAGE,
+  DEV_RELOAD_DEADLINE,
+  DEV_SERVER_UNREACHABLE,
+  makeDevError,
+  listChangedNotifications,
+  createBridgeStateMachine,
+  createStdioFramer,
+  createHttpUpstream,
+  createPipeUpstream
+} from "./stdio-bridge/index.mjs";
+import { redactFields, redactJson } from "./redaction/index.mjs";
+import { escapeHtml, escapeHtmlAttr, escapeJsString, escapeScriptClose, safeJsonForScript } from "./escape/index.mjs";
+import { brandClass, isBrandedInstance } from "./class-brand/index.mjs";
+import { safeStringify } from "./serialization/index.mjs";
+import {
+  getCrypto,
+  rsaVerify,
+  rsaVerifySync,
+  pemToPublicJwk,
+  generateRsaKeyPair,
+  rsaSignBase64Url,
+  jwtAlgToNodeAlg,
+  isRsaPssAlg,
+  randomUUID,
+  randomBytes,
+  sha256,
+  sha256Hex,
+  sha256Base64url,
+  hmacSha256,
+  hkdfSha256,
+  encryptAesGcm,
+  decryptAesGcm,
+  timingSafeEqual,
+  bytesToHex,
+  base64urlEncode,
+  base64urlDecode,
+  base64Encode,
+  base64Decode,
+  isNode,
+  isBrowser,
+  assertNode,
+  EncryptedBlobError,
+  encryptValue,
+  decryptValue,
+  tryDecryptValue,
+  serializeBlob,
+  deserializeBlob,
+  tryDeserializeBlob,
+  isValidEncryptedBlob,
+  encryptAndSerialize,
+  deserializeAndDecrypt,
+  tryDeserializeAndDecrypt,
+  generateCodeVerifier,
+  generateCodeChallenge,
+  verifyCodeChallenge,
+  generatePkcePair,
+  isValidCodeVerifier,
+  isValidCodeChallenge,
+  MIN_CODE_VERIFIER_LENGTH,
+  MAX_CODE_VERIFIER_LENGTH,
+  DEFAULT_CODE_VERIFIER_LENGTH,
+  PkceError,
+  secretDataSchema,
+  validateSecretData,
+  parseSecretData,
+  isSecretPersistenceEnabled,
+  resolveSecretPath,
+  loadSecret,
+  saveSecret,
+  deleteSecret,
+  generateSecret,
+  createSecretData,
+  getOrCreateSecret,
+  clearCachedSecret,
+  isSecretCached,
+  signData,
+  verifyData,
+  isSignedData,
+  verifyOrParseData,
+  asymmetricAlgSchema,
+  secretKeyDataSchema,
+  asymmetricKeyDataSchema,
+  anyKeyDataSchema,
+  validateKeyData,
+  parseKeyData,
+  isSecretKeyData,
+  isAsymmetricKeyData,
+  KeyPersistence,
+  createKeyPersistence,
+  createKeyPersistenceWithStorage
+} from "./crypto/index.mjs";
+import {
+  AsyncContextOverlapError,
+  AsyncLocalStorage,
+  awaitOutsideRequest,
+  getAsyncContextMode,
+  runRequestExclusive
+} from "./async-context/index.mjs";
+import { EventEmitter } from "./event-emitter/index.mjs";
+import {
+  getEnv,
+  getNodeEnv,
+  getCwd,
+  isProduction,
+  isDevelopment,
+  getEnvFlag,
+  isDebug,
+  setEnv,
+  isEdgeRuntime,
+  isServerless,
+  supportsAnsi,
+  getRuntimeContext,
+  resetRuntimeContext,
+  detectRuntimeContext,
+  isEntryAvailable,
+  checkEntryAvailability,
+  entryAvailabilitySchema
+} from "./env/index.mjs";
+import {
+  analyzePattern,
+  isPatternSafe,
+  createSafeRegExp,
+  safeTest,
+  safeMatch,
+  safeReplace,
+  safeExec,
+  isInputLengthSafe,
+  DEFAULT_MAX_INPUT_LENGTH,
+  REDOS_THRESHOLDS,
+  trimLeading,
+  trimTrailing,
+  trimBoth,
+  trimChars,
+  extractBracedParams,
+  expandTemplate,
+  hasTemplatePlaceholders,
+  collapseChar,
+  collapseWhitespace
+} from "./regex/index.mjs";
+import {
+  createStorage,
+  createMemoryStorage,
+  getDetectedStorageType,
+  createChangeFeed,
+  DEFAULT_CHANGE_FEED_COALESCE_MS,
+  DEFAULT_CHANGE_FEED_POLL_INTERVAL_MS,
+  NamespacedStorageImpl,
+  createRootStorage,
+  createNamespacedStorage,
+  buildPrefix,
+  NAMESPACE_SEPARATOR,
+  StorageError,
+  StorageConnectionError,
+  StorageOperationError,
+  StorageNotSupportedError,
+  StorageConfigError,
+  StorageTTLError,
+  StoragePatternError,
+  StorageNotConnectedError,
+  EncryptedStorageError,
+  BaseStorageAdapter,
+  MemoryStorageAdapter,
+  RedisStorageAdapter,
+  createRedisClient,
+  VercelKvStorageAdapter,
+  createVercelKvClient,
+  UpstashStorageAdapter,
+  FileSystemStorageAdapter,
+  TypedStorage,
+  EncryptedTypedStorage,
+  globToRegex,
+  matchesPattern,
+  validatePattern,
+  escapeGlob,
+  MAX_TTL_SECONDS,
+  validateTTL,
+  validateOptionalTTL,
+  ttlToExpiresAt,
+  expiresAtToTTL,
+  isExpired,
+  normalizeTTL,
+  attachRedisErrorListener,
+  DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS,
+  mergeRedisUrlFields,
+  describeRedisUrlConflicts
+} from "./storage/index.mjs";
+import { processPlatformToolCalls } from "./llm/index.mjs";
+import { getHostname, getMachineId, setMachineIdOverride } from "./machine-id/index.mjs";
+export {
+  AsyncContextOverlapError,
+  AsyncLocalStorage,
+  BaseStorageAdapter,
+  DEFAULT_CHANGE_FEED_COALESCE_MS,
+  DEFAULT_CHANGE_FEED_POLL_INTERVAL_MS,
+  DEFAULT_CODE_VERIFIER_LENGTH,
+  DEFAULT_MAX_INPUT_LENGTH,
+  DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS,
+  DEV_BUFFER_FULL,
+  DEV_ERROR_MESSAGE,
+  DEV_RELOAD_DEADLINE,
+  DEV_SERVER_UNREACHABLE,
+  EncryptedBlobError,
+  EncryptedStorageError,
+  EncryptedTypedStorage,
+  EventEmitter,
+  FileSystemStorageAdapter,
+  KeyPersistence,
+  MAX_CODE_VERIFIER_LENGTH,
+  MAX_TTL_SECONDS,
+  MIN_CODE_VERIFIER_LENGTH,
+  MemoryStorageAdapter,
+  NAMESPACE_SEPARATOR,
+  NamespacedStorageImpl,
+  OwnedProcessError,
+  PkceError,
+  REDOS_THRESHOLDS,
+  RedisStorageAdapter,
+  StorageConfigError,
+  StorageConnectionError,
+  StorageError,
+  StorageNotConnectedError,
+  StorageNotSupportedError,
+  StorageOperationError,
+  StoragePatternError,
+  StorageTTLError,
+  TypedStorage,
+  UpstashStorageAdapter,
+  VercelKvStorageAdapter,
+  access,
+  analyzePattern,
+  anyKeyDataSchema,
+  appendFile,
+  assertNode,
+  asymmetricAlgSchema,
+  asymmetricKeyDataSchema,
+  attachRedisErrorListener,
+  awaitOutsideRequest,
+  base64Decode,
+  base64Encode,
+  base64urlDecode,
+  base64urlEncode,
+  basename,
+  brandClass,
+  buildPrefix,
+  buildSetCookie,
+  bytesToHex,
+  checkEntryAvailability,
+  chmod,
+  classifyIpAddress,
+  clearCachedSecret,
+  collapseChar,
+  collapseWhitespace,
+  copyFile,
+  cp,
+  createBridgeStateMachine,
+  createChangeFeed,
+  createHttpUpstream,
+  createKeyPersistence,
+  createKeyPersistenceWithStorage,
+  createMemoryStorage,
+  createNamespacedStorage,
+  createPipeUpstream,
+  createRedisClient,
+  createRootStorage,
+  createSafeRegExp,
+  createSecretData,
+  createStdioFramer,
+  createStorage,
+  createVercelKvClient,
+  decryptAesGcm,
+  decryptValue,
+  deleteSecret,
+  describeRedisUrlConflicts,
+  deserializeAndDecrypt,
+  deserializeBlob,
+  detectRuntimeContext,
+  dirname,
+  encryptAesGcm,
+  encryptAndSerialize,
+  encryptValue,
+  ensureDir,
+  ensureDirSync,
+  ensureMaxLen,
+  entryAvailabilitySchema,
+  escapeGlob,
+  escapeHtml,
+  escapeHtmlAttr,
+  escapeJsString,
+  escapeScriptClose,
+  expandIpv6,
+  expandTemplate,
+  expandUriTemplate,
+  expiresAtToTTL,
+  extname,
+  extractBracedParams,
+  extractEmbeddedIpv4,
+  extractTemplateParams,
+  extractUriScheme,
+  fileExists,
+  fileExistsSync,
+  findDroppedKeys,
+  findNonFiniteNumber,
+  generateCodeChallenge,
+  generateCodeVerifier,
+  generatePkcePair,
+  generateRsaKeyPair,
+  generateSecret,
+  getAsyncContextMode,
+  getCookie,
+  getCrypto,
+  getCwd,
+  getDetectedStorageType,
+  getEnv,
+  getEnvFlag,
+  getHostname,
+  getMachineId,
+  getNodeEnv,
+  getOrCreateSecret,
+  getRuntimeContext,
+  getSpawnFn,
+  globToRegex,
+  hasTemplatePlaceholders,
+  hkdfSha256,
+  hmacSha256,
+  idFromString,
+  inferMimeType,
+  isAbsolute,
+  isAsymmetricKeyData,
+  isBrandedInstance,
+  isBrowser,
+  isDebug,
+  isDevelopment,
+  isDirEmpty,
+  isEdgeRuntime,
+  isEntryAvailable,
+  isExpired,
+  isInputLengthSafe,
+  isLocalhost,
+  isNode,
+  isPatternSafe,
+  isProcessTreeAlive,
+  isProduction,
+  isRedirectResponse,
+  isRsaPssAlg,
+  isSecretCached,
+  isSecretKeyData,
+  isSecretPersistenceEnabled,
+  isSecureRequest,
+  isServerless,
+  isSignedData,
+  isUriTemplate,
+  isValidCodeChallenge,
+  isValidCodeVerifier,
+  isValidEncryptedBlob,
+  isValidMcpUri,
+  isValidMcpUriTemplate,
+  joinPath,
+  jwtAlgToNodeAlg,
+  listChangedNotifications,
+  loadSecret,
+  lstat,
+  makeDevError,
+  matchUriTemplate,
+  matchesPattern,
+  mergeRedisUrlFields,
+  mkdir,
+  mkdtemp,
+  normalizeTTL,
+  parseCookies,
+  parseIpv4,
+  parseKeyData,
+  parseSecretData,
+  parseUriTemplate,
+  pathJoin,
+  pathResolve,
+  pathToFileURL,
+  pemToPublicJwk,
+  processPlatformToolCalls,
+  processTreeSpawnOptions,
+  randomBytes,
+  randomUUID,
+  readFile,
+  readFileBuffer,
+  readFileSync,
+  readJSON,
+  readdir,
+  readdirSync,
+  realpath,
+  reapOrphans,
+  redactFields,
+  redactJson,
+  rename,
+  resetRuntimeContext,
+  resolveSecretPath,
+  rm,
+  rsaSignBase64Url,
+  rsaVerify,
+  rsaVerifySync,
+  runCmd,
+  runRequestExclusive,
+  safeExec,
+  safeJsonForScript,
+  safeMatch,
+  safeReplace,
+  safeStringify,
+  safeTest,
+  sanitizeToJson,
+  saveSecret,
+  secretDataSchema,
+  secretKeyDataSchema,
+  sep,
+  sepFor,
+  serializeBlob,
+  setEnv,
+  setMachineIdOverride,
+  sha256,
+  sha256Base64url,
+  sha256Hex,
+  shortHash,
+  signData,
+  signalProcessTree,
+  spawnOwned,
+  splitWords,
+  stat,
+  stopProcessTree,
+  supportsAnsi,
+  symlink,
+  timingSafeEqual,
+  toCase,
+  trimBoth,
+  trimChars,
+  trimLeading,
+  trimSlashes,
+  trimTrailing,
+  tryDecryptValue,
+  tryDeserializeAndDecrypt,
+  tryDeserializeBlob,
+  ttlToExpiresAt,
+  unlink,
+  validateBaseUrl,
+  validateKeyData,
+  validateOptionalTTL,
+  validatePattern,
+  validateSecretData,
+  validateTTL,
+  verifyCodeChallenge,
+  verifyData,
+  verifyOrParseData,
+  watchFile,
+  watchParent,
+  watchPath,
+  writeFile,
+  writeJSON
+};

package/browser/llm/index.mjs

@@ -0,0 +1,5 @@
+// libs/utils/src/llm/index.ts
+import { processPlatformToolCalls } from "./llm-tool-handlers.mjs";
+export {
+  processPlatformToolCalls
+};

package/browser/llm/llm-tool-handlers.mjs

@@ -0,0 +1,55 @@
+// libs/utils/src/llm/llm-tool-handlers.ts
+async function processPlatformToolCalls(platform, calls, callTool) {
+  switch (platform) {
+    case "openai":
+      return processOpenAI(calls, callTool);
+    case "claude":
+      return processClaude(calls, callTool);
+    case "vercel-ai":
+      return processVercel(calls, callTool);
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+}
+async function processOpenAI(toolCalls, callTool) {
+  return Promise.all(
+    toolCalls.map(async (tc) => {
+      let args;
+      try {
+        args = JSON.parse(tc.function.arguments);
+      } catch {
+        return {
+          role: "tool",
+          tool_call_id: tc.id,
+          content: JSON.stringify({ error: `Invalid JSON in tool call arguments for "${tc.function.name}"` })
+        };
+      }
+      const result = await callTool(tc.function.name, args);
+      return {
+        role: "tool",
+        tool_call_id: tc.id,
+        content: typeof result === "string" ? result : JSON.stringify(result)
+      };
+    })
+  );
+}
+async function processClaude(toolUseBlocks, callTool) {
+  return Promise.all(
+    toolUseBlocks.map(async (block) => {
+      const result = await callTool(block.name, block.input);
+      const content = Array.isArray(result) ? result.map((c) => c.text ?? "").join("\n") : typeof result === "string" ? result : JSON.stringify(result);
+      return {
+        type: "tool_result",
+        tool_use_id: block.id,
+        content
+      };
+    })
+  );
+}
+async function processVercel(info, callTool) {
+  const args = info.args != null && typeof info.args === "object" && !Array.isArray(info.args) ? info.args : void 0;
+  return callTool(info.toolName, args);
+}
+export {
+  processPlatformToolCalls
+};

package/browser/machine-id/index.mjs

@@ -0,0 +1,7 @@
+// libs/utils/src/machine-id/index.ts
+import { getHostname, getMachineId, setMachineIdOverride } from "./machine-id.mjs";
+export {
+  getHostname,
+  getMachineId,
+  setMachineIdOverride
+};

package/browser/machine-id/machine-id.mjs

@@ -0,0 +1,108 @@
+var __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// libs/utils/src/machine-id/machine-id.ts
+import { randomUUID } from "../crypto/index.mjs";
+import { isBrowser, isNode } from "../crypto/runtime.mjs";
+function getEnvDirect(key) {
+  return typeof process !== "undefined" ? process.env[key] : void 0;
+}
+function isProductionDirect() {
+  return getEnvDirect("NODE_ENV") === "production";
+}
+var DEFAULT_MACHINE_ID_PATH = ".frontmcp/machine-id";
+function isDevPersistenceEnabled() {
+  if (isBrowser()) return false;
+  return !isProductionDirect();
+}
+function resolveMachineIdPath() {
+  if (isBrowser()) return DEFAULT_MACHINE_ID_PATH;
+  const path = __require("path");
+  const machineIdPath = getEnvDirect("MACHINE_ID_PATH") ?? DEFAULT_MACHINE_ID_PATH;
+  const cwd = typeof process !== "undefined" ? process.cwd() : ".";
+  return path.isAbsolute(machineIdPath) ? machineIdPath : path.resolve(cwd, machineIdPath);
+}
+function loadMachineIdSync() {
+  if (!isDevPersistenceEnabled()) return null;
+  const machineIdPath = resolveMachineIdPath();
+  try {
+    const fs = __require("fs");
+    const content = fs.readFileSync(machineIdPath, "utf8").trim();
+    if (/^[0-9a-f-]{32,36}$/i.test(content)) return content;
+    console.warn(`[MachineId] Invalid format at ${machineIdPath}, will regenerate`);
+    return null;
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      console.warn(`[MachineId] Failed to load from ${machineIdPath}: ${error.message}`);
+    }
+    return null;
+  }
+}
+function saveMachineIdAsync(machineId) {
+  if (!isDevPersistenceEnabled()) return;
+  const machineIdPath = resolveMachineIdPath();
+  const path = __require("path");
+  const dir = path.dirname(machineIdPath);
+  (async () => {
+    try {
+      const fsp = __require("fs").promises;
+      await fsp.mkdir(dir, { recursive: true, mode: 448 });
+      await fsp.writeFile(machineIdPath, machineId, { mode: 384 });
+    } catch (error) {
+      console.warn(`[MachineId] Failed to save to ${machineIdPath}: ${error.message}`);
+    }
+  })();
+}
+function getHostname() {
+  if (!isNode()) return void 0;
+  try {
+    return __require("os").hostname();
+  } catch {
+    return void 0;
+  }
+}
+function computeMachineId() {
+  const envMachineId = getEnvDirect("MACHINE_ID");
+  if (envMachineId) return envMachineId;
+  const deploymentMode = getEnvDirect("FRONTMCP_DEPLOYMENT_MODE");
+  if (deploymentMode === "distributed") {
+    const hostname = getEnvDirect("HOSTNAME");
+    if (hostname) return hostname;
+    if (isNode()) {
+      const os = __require("os");
+      return os.hostname();
+    }
+  }
+  if (deploymentMode === "serverless") {
+    return randomUUID();
+  }
+  const loadedId = loadMachineIdSync();
+  if (loadedId) return loadedId;
+  const newId = randomUUID();
+  saveMachineIdAsync(newId);
+  return newId;
+}
+var cachedMachineId;
+var machineIdOverride;
+function getMachineId() {
+  if (machineIdOverride !== void 0) return machineIdOverride;
+  if (cachedMachineId === void 0) {
+    cachedMachineId = computeMachineId();
+  }
+  return cachedMachineId;
+}
+function setMachineIdOverride(id) {
+  machineIdOverride = id;
+}
+export {
+  getHostname,
+  getMachineId,
+  setMachineIdOverride
+};

package/browser/naming/index.mjs

@@ -0,0 +1,10 @@
+// libs/utils/src/naming/index.ts
+import { splitWords, toCase, sepFor, shortHash, ensureMaxLen, idFromString } from "./naming.mjs";
+export {
+  ensureMaxLen,
+  idFromString,
+  sepFor,
+  shortHash,
+  splitWords,
+  toCase
+};