@frontmcp/utils 0.12.2 → 1.0.0-beta.1

package/env/node-env.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Node.js environment access.
+ */
+export declare function getEnv(key: string): string | undefined;
+export declare function getEnv(key: string, defaultValue: string): string;
+export declare function getCwd(): string;
+export declare function isProduction(): boolean;
+export declare function isDevelopment(): boolean;
+export declare function getEnvFlag(key: string): boolean;
+export declare function isDebug(): boolean;
+export declare function setEnv(key: string, value: string): void;
+export declare function isEdgeRuntime(): boolean;
+export declare function isServerless(): boolean;
+export declare function supportsAnsi(): boolean;

package/env/node-env.js

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/utils/src/env/node-env.ts
+var node_env_exports = {};
+__export(node_env_exports, {
+  getCwd: () => getCwd,
+  getEnv: () => getEnv,
+  getEnvFlag: () => getEnvFlag,
+  isDebug: () => isDebug,
+  isDevelopment: () => isDevelopment,
+  isEdgeRuntime: () => isEdgeRuntime,
+  isProduction: () => isProduction,
+  isServerless: () => isServerless,
+  setEnv: () => setEnv,
+  supportsAnsi: () => supportsAnsi
+});
+module.exports = __toCommonJS(node_env_exports);
+function getEnv(key, defaultValue) {
+  return process.env[key] ?? defaultValue;
+}
+function getCwd() {
+  return process.cwd();
+}
+function isProduction() {
+  return process.env["NODE_ENV"] === "production";
+}
+function isDevelopment() {
+  return process.env["NODE_ENV"] === "development";
+}
+function getEnvFlag(key) {
+  const v = process.env[key];
+  return v === "1" || v === "true";
+}
+function isDebug() {
+  return getEnvFlag("DEBUG");
+}
+function setEnv(key, value) {
+  process.env[key] = value;
+}
+function isEdgeRuntime() {
+  if (typeof globalThis !== "undefined" && "EdgeRuntime" in globalThis) return true;
+  if (typeof globalThis !== "undefined" && "caches" in globalThis && !("window" in globalThis)) return true;
+  return process.env["EDGE_RUNTIME"] !== void 0 && process.env["VERCEL_ENV"] !== void 0;
+}
+function isServerless() {
+  return !!(process.env["VERCEL"] || process.env["NETLIFY"] || process.env["CF_PAGES"] || process.env["AWS_LAMBDA_FUNCTION_NAME"] || process.env["AZURE_FUNCTIONS_ENVIRONMENT"] || process.env["K_SERVICE"] || process.env["RAILWAY_ENVIRONMENT"] || process.env["RENDER"] || process.env["FLY_APP_NAME"]);
+}
+function supportsAnsi() {
+  if (process.env["NO_COLOR"]) return false;
+  const forceColor = process.env["FORCE_COLOR"];
+  if (forceColor !== void 0) {
+    return forceColor !== "0" && forceColor.toLowerCase() !== "false";
+  }
+  return process.stdout?.isTTY === true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCwd,
+  getEnv,
+  getEnvFlag,
+  isDebug,
+  isDevelopment,
+  isEdgeRuntime,
+  isProduction,
+  isServerless,
+  setEnv,
+  supportsAnsi
+});

package/esm/async-context/browser-async-context.mjs

@@ -0,0 +1,24 @@
+// libs/utils/src/async-context/browser-async-context.ts
+var AsyncLocalStorage = class {
+  stack = [];
+  run(store, callback, ...args) {
+    this.stack.push(store);
+    try {
+      const result = callback(...args);
+      if (result instanceof Promise) {
+        return result.finally(() => this.stack.pop());
+      }
+      this.stack.pop();
+      return result;
+    } catch (err) {
+      this.stack.pop();
+      throw err;
+    }
+  }
+  getStore() {
+    return this.stack.length > 0 ? this.stack[this.stack.length - 1] : void 0;
+  }
+};
+export {
+  AsyncLocalStorage
+};

package/esm/async-context/node-async-context.mjs

@@ -0,0 +1,5 @@
+// libs/utils/src/async-context/node-async-context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+export {
+  AsyncLocalStorage
+};

package/esm/crypto/browser.mjs

@@ -0,0 +1,131 @@
+// libs/utils/src/crypto/browser.ts
+import { sha256 as sha256Hash } from "@noble/hashes/sha2.js";
+import { hmac } from "@noble/hashes/hmac.js";
+import { hkdf } from "@noble/hashes/hkdf.js";
+import { randomBytes as nobleRandomBytes } from "@noble/hashes/utils.js";
+import { gcm } from "@noble/ciphers/aes.js";
+
+// libs/utils/src/crypto/jwt-alg.ts
+function isRsaPssAlg(jwtAlg) {
+  return jwtAlg.startsWith("PS");
+}
+var JWT_ALG_TO_WEB_CRYPTO = {
+  RS256: "SHA-256",
+  RS384: "SHA-384",
+  RS512: "SHA-512",
+  PS256: "SHA-256",
+  PS384: "SHA-384",
+  PS512: "SHA-512"
+};
+function jwtAlgToWebCryptoAlg(jwtAlg) {
+  const webAlg = JWT_ALG_TO_WEB_CRYPTO[jwtAlg];
+  if (!webAlg) {
+    throw new Error(`Unsupported JWT algorithm for WebCrypto: ${jwtAlg}`);
+  }
+  return webAlg;
+}
+
+// libs/utils/src/crypto/browser.ts
+function toBytes(data) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data);
+  }
+  return data;
+}
+function toHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const bytes = nobleRandomBytes(16);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = toHex(bytes);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let result = 0;
+  for (let i = 0; i < a.length; i++) {
+    result |= a[i] ^ b[i];
+  }
+  return result === 0;
+}
+var browserCrypto = {
+  randomUUID() {
+    return generateUUID();
+  },
+  randomBytes(length) {
+    return nobleRandomBytes(length);
+  },
+  sha256(data) {
+    return sha256Hash(toBytes(data));
+  },
+  sha256Hex(data) {
+    return toHex(sha256Hash(toBytes(data)));
+  },
+  hmacSha256(key, data) {
+    return hmac(sha256Hash, key, data);
+  },
+  hkdfSha256(ikm, salt, info, length) {
+    const effectiveSalt = salt.length > 0 ? salt : new Uint8Array(32);
+    return hkdf(sha256Hash, ikm, effectiveSalt, info, length);
+  },
+  encryptAesGcm(key, plaintext, iv) {
+    const cipher = gcm(key, iv);
+    const sealed = cipher.encrypt(plaintext);
+    const ciphertext = sealed.slice(0, -16);
+    const tag = sealed.slice(-16);
+    return { ciphertext, tag };
+  },
+  decryptAesGcm(key, ciphertext, iv, tag) {
+    const cipher = gcm(key, iv);
+    const sealed = new Uint8Array(ciphertext.length + tag.length);
+    sealed.set(ciphertext);
+    sealed.set(tag, ciphertext.length);
+    return cipher.decrypt(sealed);
+  },
+  timingSafeEqual(a, b) {
+    return constantTimeEqual(a, b);
+  }
+};
+async function rsaVerifyBrowser(jwtAlg, data, publicJwk, signature) {
+  if (typeof globalThis.crypto?.subtle === "undefined") {
+    throw new Error("WebCrypto API (crypto.subtle) is not available in this environment");
+  }
+  const webAlg = jwtAlgToWebCryptoAlg(jwtAlg);
+  const isPss = isRsaPssAlg(jwtAlg);
+  const algorithm = {
+    name: isPss ? "RSA-PSS" : "RSASSA-PKCS1-v1_5",
+    hash: { name: webAlg }
+  };
+  const key = await globalThis.crypto.subtle.importKey("jwk", publicJwk, algorithm, false, ["verify"]);
+  const verifyAlgorithm = isPss ? { name: "RSA-PSS", saltLength: getSaltLength(jwtAlg) } : { name: "RSASSA-PKCS1-v1_5" };
+  const sigBuf = new Uint8Array(signature).buffer;
+  const dataBuf = new Uint8Array(data).buffer;
+  return globalThis.crypto.subtle.verify(verifyAlgorithm, key, sigBuf, dataBuf);
+}
+function getSaltLength(jwtAlg) {
+  switch (jwtAlg) {
+    case "PS256":
+      return 32;
+    // SHA-256 digest length
+    case "PS384":
+      return 48;
+    // SHA-384 digest length
+    case "PS512":
+      return 64;
+    // SHA-512 digest length
+    default:
+      return 32;
+  }
+}
+export {
+  browserCrypto,
+  browserCrypto as cryptoProvider,
+  isRsaPssAlg,
+  jwtAlgToWebCryptoAlg,
+  rsaVerifyBrowser
+};

package/esm/crypto/node.mjs

@@ -0,0 +1,143 @@
+// libs/utils/src/crypto/node.ts
+import crypto from "node:crypto";
+
+// libs/utils/src/crypto/jwt-alg.ts
+var JWT_ALG_TO_NODE_DIGEST = {
+  RS256: "RSA-SHA256",
+  RS384: "RSA-SHA384",
+  RS512: "RSA-SHA512",
+  // For RSA-PSS, Node's crypto.sign/verify uses the digest algorithm + explicit PSS padding options.
+  PS256: "RSA-SHA256",
+  PS384: "RSA-SHA384",
+  PS512: "RSA-SHA512"
+};
+function jwtAlgToNodeAlg(jwtAlg) {
+  const nodeAlg = JWT_ALG_TO_NODE_DIGEST[jwtAlg];
+  if (!nodeAlg) {
+    throw new Error(`Unsupported JWT algorithm: ${jwtAlg}`);
+  }
+  return nodeAlg;
+}
+function isRsaPssAlg(jwtAlg) {
+  return jwtAlg.startsWith("PS");
+}
+
+// libs/utils/src/crypto/node.ts
+function toUint8Array(buf) {
+  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+function toBuffer(data) {
+  if (typeof data === "string") {
+    return Buffer.from(data, "utf8");
+  }
+  return Buffer.from(data);
+}
+var nodeCrypto = {
+  randomUUID() {
+    return crypto.randomUUID();
+  },
+  randomBytes(length) {
+    return toUint8Array(crypto.randomBytes(length));
+  },
+  sha256(data) {
+    const hash = crypto.createHash("sha256").update(toBuffer(data)).digest();
+    return toUint8Array(hash);
+  },
+  sha256Hex(data) {
+    return crypto.createHash("sha256").update(toBuffer(data)).digest("hex");
+  },
+  hmacSha256(key, data) {
+    const hmac = crypto.createHmac("sha256", Buffer.from(key)).update(Buffer.from(data)).digest();
+    return toUint8Array(hmac);
+  },
+  hkdfSha256(ikm, salt, info, length) {
+    const ikmBuf = Buffer.from(ikm);
+    const saltBuf = salt.length > 0 ? Buffer.from(salt) : Buffer.alloc(32);
+    const prk = crypto.createHmac("sha256", saltBuf).update(ikmBuf).digest();
+    const hashLen = 32;
+    const n = Math.ceil(length / hashLen);
+    const chunks = [];
+    let prev = Buffer.alloc(0);
+    for (let i = 1; i <= n; i++) {
+      prev = crypto.createHmac("sha256", prk).update(Buffer.concat([prev, Buffer.from(info), Buffer.from([i])])).digest();
+      chunks.push(prev);
+    }
+    return toUint8Array(Buffer.concat(chunks).subarray(0, length));
+  },
+  encryptAesGcm(key, plaintext, iv) {
+    const cipher = crypto.createCipheriv("aes-256-gcm", Buffer.from(key), Buffer.from(iv));
+    const encrypted = Buffer.concat([cipher.update(Buffer.from(plaintext)), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return {
+      ciphertext: toUint8Array(encrypted),
+      tag: toUint8Array(tag)
+    };
+  },
+  decryptAesGcm(key, ciphertext, iv, tag) {
+    const decipher = crypto.createDecipheriv("aes-256-gcm", Buffer.from(key), Buffer.from(iv));
+    decipher.setAuthTag(Buffer.from(tag));
+    const decrypted = Buffer.concat([decipher.update(Buffer.from(ciphertext)), decipher.final()]);
+    return toUint8Array(decrypted);
+  },
+  timingSafeEqual(a, b) {
+    if (a.length !== b.length) return false;
+    return crypto.timingSafeEqual(Buffer.from(a), Buffer.from(b));
+  }
+};
+function generateRsaKeyPair(modulusLength = 2048, alg = "RS256") {
+  const kid = `rsa-key-${Date.now()}-${crypto.randomBytes(8).toString("hex")}`;
+  const { privateKey, publicKey } = crypto.generateKeyPairSync("rsa", {
+    modulusLength
+  });
+  const exported = publicKey.export({ format: "jwk" });
+  const publicJwk = {
+    ...exported,
+    kid,
+    alg,
+    use: "sig",
+    kty: "RSA"
+  };
+  return { privateKey, publicKey, publicJwk };
+}
+function rsaSign(algorithm, data, privateKey, options) {
+  const signingKey = options ? { key: privateKey, ...options } : privateKey;
+  return crypto.sign(algorithm, data, signingKey);
+}
+function rsaVerify(jwtAlg, data, publicJwk, signature) {
+  const publicKey = crypto.createPublicKey({ key: publicJwk, format: "jwk" });
+  const nodeAlgorithm = jwtAlgToNodeAlg(jwtAlg);
+  const verifyKey = isRsaPssAlg(jwtAlg) ? {
+    key: publicKey,
+    padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
+    saltLength: crypto.constants.RSA_PSS_SALTLEN_DIGEST
+  } : publicKey;
+  return crypto.verify(nodeAlgorithm, data, verifyKey, signature);
+}
+function createSignedJwt(payload, privateKey, kid, alg = "RS256") {
+  const header = { alg, typ: "JWT", kid };
+  const headerB64 = Buffer.from(JSON.stringify(header)).toString("base64url");
+  const payloadB64 = Buffer.from(JSON.stringify(payload)).toString("base64url");
+  const signatureInput = `${headerB64}.${payloadB64}`;
+  const nodeAlgorithm = jwtAlgToNodeAlg(alg);
+  const signature = rsaSign(
+    nodeAlgorithm,
+    Buffer.from(signatureInput),
+    privateKey,
+    isRsaPssAlg(alg) ? {
+      padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
+      saltLength: crypto.constants.RSA_PSS_SALTLEN_DIGEST
+    } : void 0
+  );
+  const signatureB64 = signature.toString("base64url");
+  return `${headerB64}.${payloadB64}.${signatureB64}`;
+}
+export {
+  createSignedJwt,
+  nodeCrypto as cryptoProvider,
+  generateRsaKeyPair,
+  isRsaPssAlg,
+  jwtAlgToNodeAlg,
+  nodeCrypto,
+  rsaSign,
+  rsaVerify
+};

package/esm/env/browser-env.mjs

@@ -0,0 +1,44 @@
+// libs/utils/src/env/browser-env.ts
+function getEnv(_key, defaultValue) {
+  return defaultValue;
+}
+function getCwd() {
+  return "/";
+}
+function isProduction() {
+  return false;
+}
+function isDevelopment() {
+  return false;
+}
+function getEnvFlag(_key) {
+  return false;
+}
+function isDebug() {
+  return false;
+}
+function setEnv(_key, _value) {
+}
+function isEdgeRuntime() {
+  if (typeof globalThis !== "undefined" && "EdgeRuntime" in globalThis) return true;
+  if (typeof globalThis !== "undefined" && "caches" in globalThis && !("window" in globalThis)) return true;
+  return false;
+}
+function isServerless() {
+  return false;
+}
+function supportsAnsi() {
+  return false;
+}
+export {
+  getCwd,
+  getEnv,
+  getEnvFlag,
+  isDebug,
+  isDevelopment,
+  isEdgeRuntime,
+  isProduction,
+  isServerless,
+  setEnv,
+  supportsAnsi
+};

package/esm/env/node-env.mjs

@@ -0,0 +1,51 @@
+// libs/utils/src/env/node-env.ts
+function getEnv(key, defaultValue) {
+  return process.env[key] ?? defaultValue;
+}
+function getCwd() {
+  return process.cwd();
+}
+function isProduction() {
+  return process.env["NODE_ENV"] === "production";
+}
+function isDevelopment() {
+  return process.env["NODE_ENV"] === "development";
+}
+function getEnvFlag(key) {
+  const v = process.env[key];
+  return v === "1" || v === "true";
+}
+function isDebug() {
+  return getEnvFlag("DEBUG");
+}
+function setEnv(key, value) {
+  process.env[key] = value;
+}
+function isEdgeRuntime() {
+  if (typeof globalThis !== "undefined" && "EdgeRuntime" in globalThis) return true;
+  if (typeof globalThis !== "undefined" && "caches" in globalThis && !("window" in globalThis)) return true;
+  return process.env["EDGE_RUNTIME"] !== void 0 && process.env["VERCEL_ENV"] !== void 0;
+}
+function isServerless() {
+  return !!(process.env["VERCEL"] || process.env["NETLIFY"] || process.env["CF_PAGES"] || process.env["AWS_LAMBDA_FUNCTION_NAME"] || process.env["AZURE_FUNCTIONS_ENVIRONMENT"] || process.env["K_SERVICE"] || process.env["RAILWAY_ENVIRONMENT"] || process.env["RENDER"] || process.env["FLY_APP_NAME"]);
+}
+function supportsAnsi() {
+  if (process.env["NO_COLOR"]) return false;
+  const forceColor = process.env["FORCE_COLOR"];
+  if (forceColor !== void 0) {
+    return forceColor !== "0" && forceColor.toLowerCase() !== "false";
+  }
+  return process.stdout?.isTTY === true;
+}
+export {
+  getCwd,
+  getEnv,
+  getEnvFlag,
+  isDebug,
+  isDevelopment,
+  isEdgeRuntime,
+  isProduction,
+  isServerless,
+  setEnv,
+  supportsAnsi
+};

package/esm/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/esm/event-emitter/node-event-emitter.mjs

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