@frontmcp/utils 1.10.16 → 1.11.0-rc.1

package/browser/env/index.mjs

@@ -0,0 +1,47 @@
+// libs/utils/src/env/index.ts
+import {
+  getEnv,
+  getCwd,
+  getNodeEnv,
+  isProduction,
+  isDevelopment,
+  getEnvFlag,
+  isDebug,
+  setEnv,
+  isEdgeRuntime,
+  isServerless,
+  supportsAnsi
+} from "./browser-env.mjs";
+import {
+  getRuntimeContext,
+  resetRuntimeContext,
+  detectRuntimeContext,
+  isEntryAvailable,
+  checkEntryAvailability,
+  entryAvailabilitySchema
+} from "./browser-runtime-context.mjs";
+import { detectProvider, resetProviderCacheForTesting } from "./provider.mjs";
+import { getBuildTarget, resetBuildTargetCacheForTesting } from "./build-target.mjs";
+export {
+  checkEntryAvailability,
+  detectProvider,
+  detectRuntimeContext,
+  entryAvailabilitySchema,
+  getBuildTarget,
+  getCwd,
+  getEnv,
+  getEnvFlag,
+  getNodeEnv,
+  getRuntimeContext,
+  isDebug,
+  isDevelopment,
+  isEdgeRuntime,
+  isEntryAvailable,
+  isProduction,
+  isServerless,
+  resetBuildTargetCacheForTesting,
+  resetProviderCacheForTesting,
+  resetRuntimeContext,
+  setEnv,
+  supportsAnsi
+};

package/browser/env/provider.mjs

@@ -0,0 +1,46 @@
+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/env/provider.ts
+var cached;
+function detectProvider() {
+  if (cached) return cached;
+  cached = detectProviderUncached();
+  return cached;
+}
+function detectProviderUncached() {
+  const explicit = process.env["FRONTMCP_PROVIDER"];
+  if (explicit && isKnownProvider(explicit)) return explicit;
+  if (process.env["VERCEL"]) return "vercel";
+  if (process.env["AWS_LAMBDA_FUNCTION_NAME"]) return "lambda";
+  if (process.env["CF_PAGES"]) return "cloudflare";
+  if (process.env["NETLIFY"]) return "netlify";
+  if (process.env["AZURE_FUNCTIONS_ENVIRONMENT"]) return "azure";
+  if (process.env["K_SERVICE"]) return "gcp";
+  if (process.env["FLY_APP_NAME"]) return "fly";
+  if (process.env["RENDER"]) return "render";
+  if (process.env["RAILWAY_ENVIRONMENT"]) return "railway";
+  try {
+    const nodeFs = __require("node:fs");
+    if (nodeFs.existsSync("/.dockerenv")) return "docker";
+  } catch {
+  }
+  return "bare";
+}
+function isKnownProvider(value) {
+  return value === "bare" || value === "docker" || value === "vercel" || value === "lambda" || value === "cloudflare" || value === "netlify" || value === "azure" || value === "gcp" || value === "fly" || value === "render" || value === "railway";
+}
+function resetProviderCacheForTesting() {
+  cached = void 0;
+}
+export {
+  detectProvider,
+  resetProviderCacheForTesting
+};

package/browser/escape/escape.mjs

@@ -0,0 +1,43 @@
+// libs/utils/src/escape/escape.ts
+function escapeHtml(str) {
+  if (str === null || str === void 0) {
+    return "";
+  }
+  const s = String(str);
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function escapeHtmlAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function escapeJsString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function escapeScriptClose(jsonString) {
+  return jsonString.replace(/<\//g, "<\\/");
+}
+function safeJsonForScript(value) {
+  if (value === void 0) {
+    return "null";
+  }
+  try {
+    const jsonString = JSON.stringify(value, (_key, val) => {
+      if (typeof val === "bigint") {
+        return val.toString();
+      }
+      return val;
+    });
+    if (jsonString === void 0) {
+      return "null";
+    }
+    return escapeScriptClose(jsonString);
+  } catch {
+    return '{"error":"Value could not be serialized"}';
+  }
+}
+export {
+  escapeHtml,
+  escapeHtmlAttr,
+  escapeJsString,
+  escapeScriptClose,
+  safeJsonForScript
+};

package/browser/escape/index.mjs

@@ -0,0 +1,9 @@
+// libs/utils/src/escape/index.ts
+import { escapeHtml, escapeHtmlAttr, escapeJsString, escapeScriptClose, safeJsonForScript } from "./escape.mjs";
+export {
+  escapeHtml,
+  escapeHtmlAttr,
+  escapeJsString,
+  escapeScriptClose,
+  safeJsonForScript
+};

package/browser/event-emitter/browser-event-emitter.mjs

@@ -0,0 +1,49 @@
+// libs/utils/src/event-emitter/browser-event-emitter.ts
+var EventEmitter = class {
+  events = /* @__PURE__ */ new Map();
+  emit(event, ...args) {
+    const handlers = this.events.get(event);
+    if (!handlers || handlers.length === 0) return false;
+    for (const handler of [...handlers]) {
+      handler(...args);
+    }
+    return true;
+  }
+  on(event, handler) {
+    const list = this.events.get(event) ?? [];
+    list.push(handler);
+    this.events.set(event, list);
+    return this;
+  }
+  off(event, handler) {
+    const list = this.events.get(event);
+    if (list) {
+      const idx = list.indexOf(handler);
+      if (idx >= 0) list.splice(idx, 1);
+    }
+    return this;
+  }
+  addListener(event, handler) {
+    return this.on(event, handler);
+  }
+  removeListener(event, handler) {
+    return this.off(event, handler);
+  }
+  removeAllListeners(event) {
+    if (event !== void 0) {
+      this.events.delete(event);
+    } else {
+      this.events.clear();
+    }
+    return this;
+  }
+  setMaxListeners(_n) {
+    return this;
+  }
+  listenerCount(event) {
+    return this.events.get(event)?.length ?? 0;
+  }
+};
+export {
+  EventEmitter
+};

package/browser/event-emitter/index.mjs

@@ -0,0 +1,5 @@
+// libs/utils/src/event-emitter/index.ts
+import { EventEmitter } from "./browser-event-emitter.mjs";
+export {
+  EventEmitter
+};

package/browser/fs/fs.mjs

@@ -0,0 +1,227 @@
+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/fs/fs.ts
+import { assertNode } from "../crypto/runtime.mjs";
+var _fsp = null;
+var _fs = null;
+var _spawn = null;
+function getFsp() {
+  if (!_fsp) {
+    assertNode("File system operations");
+    _fsp = __require("fs").promises;
+  }
+  return _fsp;
+}
+function getFs() {
+  if (!_fs) {
+    assertNode("File system operations");
+    _fs = __require("fs");
+  }
+  return _fs;
+}
+function getSpawn() {
+  if (!_spawn) {
+    assertNode("Child process operations");
+    _spawn = __require("child_process").spawn;
+  }
+  return _spawn;
+}
+function getSpawnFn() {
+  return getSpawn();
+}
+var F_OK = 0;
+async function readFile(p, encoding = "utf8") {
+  const fsp = getFsp();
+  return fsp.readFile(p, encoding);
+}
+function readFileSync(p, encoding = "utf8") {
+  const fs = getFs();
+  return fs.readFileSync(p, encoding);
+}
+async function readFileBuffer(p) {
+  const fsp = getFsp();
+  return fsp.readFile(p);
+}
+async function writeFile(p, content, options) {
+  const fsp = getFsp();
+  await fsp.writeFile(p, content, { encoding: "utf8", mode: options?.mode, flag: options?.flag });
+}
+async function appendFile(p, content, options) {
+  const fsp = getFsp();
+  await fsp.appendFile(p, content, { encoding: "utf8", mode: options?.mode });
+}
+async function mkdir(p, options) {
+  const fsp = getFsp();
+  await fsp.mkdir(p, options);
+}
+function ensureDirSync(p) {
+  const fs = getFs();
+  fs.mkdirSync(p, { recursive: true });
+}
+async function rename(oldPath, newPath) {
+  const fsp = getFsp();
+  await fsp.rename(oldPath, newPath);
+}
+async function unlink(p) {
+  const fsp = getFsp();
+  await fsp.unlink(p);
+}
+async function fileExists(p) {
+  try {
+    const fsp = getFsp();
+    await fsp.access(p, F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function fileExistsSync(p) {
+  return getFs().existsSync(p);
+}
+function isMissingSync(p) {
+  try {
+    getFs().statSync(p);
+    return false;
+  } catch (error) {
+    const code = error.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+  }
+}
+async function readJSON(jsonPath) {
+  try {
+    const fsp = getFsp();
+    const buf = await fsp.readFile(jsonPath, "utf8");
+    return JSON.parse(buf);
+  } catch {
+    return null;
+  }
+}
+async function writeJSON(p, obj) {
+  const fsp = getFsp();
+  await fsp.writeFile(p, JSON.stringify(obj, null, 2) + "\n", "utf8");
+}
+async function ensureDir(p) {
+  const fsp = getFsp();
+  await fsp.mkdir(p, { recursive: true });
+}
+async function stat(p) {
+  const fsp = getFsp();
+  return fsp.stat(p);
+}
+async function lstat(p) {
+  const fsp = getFsp();
+  return fsp.lstat(p);
+}
+async function chmod(p, mode) {
+  const fsp = getFsp();
+  await fsp.chmod(p, mode);
+}
+async function symlink(target, linkPath, type) {
+  const fsp = getFsp();
+  await fsp.symlink(target, linkPath, type);
+}
+async function realpath(p) {
+  const fsp = getFsp();
+  return fsp.realpath(p);
+}
+async function copyFile(src, dest) {
+  const fsp = getFsp();
+  await fsp.copyFile(src, dest);
+}
+async function cp(src, dest, options) {
+  const fsp = getFsp();
+  await fsp.cp(src, dest, options);
+}
+async function readdir(p) {
+  const fsp = getFsp();
+  return fsp.readdir(p);
+}
+function readdirSync(p) {
+  const fs = getFs();
+  return fs.readdirSync(p);
+}
+async function rm(p, options) {
+  const fsp = getFsp();
+  await fsp.rm(p, options);
+}
+async function isDirEmpty(dir) {
+  try {
+    const fsp = getFsp();
+    const items = await fsp.readdir(dir);
+    return items.length === 0;
+  } catch (e) {
+    if (e?.code === "ENOENT") return true;
+    throw e;
+  }
+}
+async function mkdtemp(prefix) {
+  const fsp = getFsp();
+  return fsp.mkdtemp(prefix);
+}
+async function access(p, mode) {
+  const fsp = getFsp();
+  await fsp.access(p, mode ?? F_OK);
+}
+function runCmd(cmd, args, opts = {}) {
+  const spawn = getSpawn();
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: "inherit", shell: false, ...opts });
+    child.on("close", (code) => code === 0 ? resolve() : reject(new Error(`${cmd} exited with code ${code}`)));
+    child.on("error", reject);
+  });
+}
+function watchFile(p, onChange, options) {
+  const fs = getFs();
+  const watcher = fs.watch(p, { persistent: false, recursive: options?.recursive === true }, (eventType, filename) => {
+    onChange(eventType, filename);
+  });
+  return {
+    close() {
+      watcher.close();
+    },
+    onError(handler) {
+      watcher.on("error", handler);
+    }
+  };
+}
+export {
+  access,
+  appendFile,
+  chmod,
+  copyFile,
+  cp,
+  ensureDir,
+  ensureDirSync,
+  fileExists,
+  fileExistsSync,
+  getSpawnFn,
+  isDirEmpty,
+  isMissingSync,
+  lstat,
+  mkdir,
+  mkdtemp,
+  readFile,
+  readFileBuffer,
+  readFileSync,
+  readJSON,
+  readdir,
+  readdirSync,
+  realpath,
+  rename,
+  rm,
+  runCmd,
+  stat,
+  symlink,
+  unlink,
+  watchFile,
+  writeFile,
+  writeJSON
+};

package/browser/fs/index.mjs

@@ -0,0 +1,65 @@
+// libs/utils/src/fs/index.ts
+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.mjs";
+export {
+  access,
+  appendFile,
+  chmod,
+  copyFile,
+  cp,
+  ensureDir,
+  ensureDirSync,
+  fileExists,
+  fileExistsSync,
+  getSpawnFn,
+  isDirEmpty,
+  lstat,
+  mkdir,
+  mkdtemp,
+  readFile,
+  readFileBuffer,
+  readFileSync,
+  readJSON,
+  readdir,
+  readdirSync,
+  realpath,
+  rename,
+  rm,
+  runCmd,
+  stat,
+  symlink,
+  unlink,
+  watchFile,
+  writeFile,
+  writeJSON
+};

package/browser/http/cookie.mjs

@@ -0,0 +1,85 @@
+// libs/utils/src/http/cookie.ts
+import { isNode } from "../crypto/runtime.mjs";
+var LOCALHOST_PATTERNS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "0.0.0.0"]);
+function isLocalhost(host) {
+  if (!host) return false;
+  if (host.startsWith("[")) {
+    const closeBracket = host.indexOf("]");
+    if (closeBracket > 0) {
+      return LOCALHOST_PATTERNS.has(host.slice(1, closeBracket));
+    }
+  }
+  if (LOCALHOST_PATTERNS.has(host)) return true;
+  const lastColon = host.lastIndexOf(":");
+  if (lastColon > 0) {
+    const hostname = host.slice(0, lastColon);
+    return LOCALHOST_PATTERNS.has(hostname);
+  }
+  return false;
+}
+function isSecureRequest(req) {
+  if (!req) return false;
+  if (req.protocol === "https") return true;
+  const forwarded = req.headers?.["x-forwarded-proto"];
+  const forwardedStr = (Array.isArray(forwarded) ? forwarded[0] : forwarded)?.split(",")[0]?.trim()?.toLowerCase();
+  if (forwardedStr === "https") return true;
+  if (req.socket?.encrypted) return true;
+  return false;
+}
+function buildSetCookie(options, req) {
+  if (!isNode()) return null;
+  const { name, value, path = "/", maxAge = 86400, httpOnly = true, sameSite = "Strict", domain } = options;
+  let secure;
+  if (options.secure !== void 0) {
+    secure = options.secure;
+  } else {
+    const host = req?.headers?.["host"];
+    const hostStr = Array.isArray(host) ? host[0] : host;
+    if (isLocalhost(hostStr)) {
+      secure = false;
+    } else if (req) {
+      secure = isSecureRequest(req);
+    } else {
+      secure = process.env["NODE_ENV"] === "production";
+    }
+  }
+  if (sameSite === "None" && !secure) {
+    secure = true;
+  }
+  const parts = [`${encodeURIComponent(name)}=${encodeURIComponent(value)}`];
+  parts.push(`Path=${path}`);
+  parts.push(`Max-Age=${maxAge}`);
+  if (httpOnly) parts.push("HttpOnly");
+  if (secure) parts.push("Secure");
+  parts.push(`SameSite=${sameSite}`);
+  if (domain) parts.push(`Domain=${domain}`);
+  return parts.join("; ");
+}
+function parseCookies(cookieHeader) {
+  const cookies = {};
+  if (!cookieHeader) return cookies;
+  const pairs = cookieHeader.split(";");
+  for (const pair of pairs) {
+    const eqIdx = pair.indexOf("=");
+    if (eqIdx < 0) continue;
+    try {
+      const name = decodeURIComponent(pair.slice(0, eqIdx).trim());
+      const value = decodeURIComponent(pair.slice(eqIdx + 1).trim());
+      if (name) cookies[name] = value;
+    } catch {
+      continue;
+    }
+  }
+  return cookies;
+}
+function getCookie(cookieHeader, name) {
+  if (!cookieHeader) return void 0;
+  return parseCookies(cookieHeader)[name];
+}
+export {
+  buildSetCookie,
+  getCookie,
+  isLocalhost,
+  isSecureRequest,
+  parseCookies
+};

package/browser/http/http.mjs

@@ -0,0 +1,18 @@
+// libs/utils/src/http/http.ts
+function validateBaseUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      throw new Error(`Unsupported protocol: ${parsed.protocol}. Only http: and https: are supported.`);
+    }
+    return parsed;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("Unsupported protocol")) {
+      throw err;
+    }
+    throw new Error(`Invalid base URL: ${url}`);
+  }
+}
+export {
+  validateBaseUrl
+};

package/browser/http/index.mjs

@@ -0,0 +1,11 @@
+// libs/utils/src/http/index.ts
+import { validateBaseUrl } from "./http.mjs";
+import { buildSetCookie, parseCookies, getCookie, isLocalhost, isSecureRequest } from "./cookie.mjs";
+export {
+  buildSetCookie,
+  getCookie,
+  isLocalhost,
+  isSecureRequest,
+  parseCookies,
+  validateBaseUrl
+};