@frontmcp/utils 1.8.7 → 1.9.0

package/esm/env/runtime-context.mjs

@@ -0,0 +1,172 @@
+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/runtime-context.ts
+import { z } from "@frontmcp/lazy-zod";
+import { getNodeEnv, isEdgeRuntime, isServerless } from "#env";
+
+// libs/utils/src/env/build-target.ts
+var cached;
+function getBuildTarget() {
+  if (cached) return cached;
+  cached = resolveBuildTarget();
+  return cached;
+}
+function resolveBuildTarget() {
+  const globalAny = globalThis;
+  const fromGlobal = globalAny.FRONTMCP_BUILD_TARGET;
+  if (typeof fromGlobal === "string" && isKnownTarget(fromGlobal)) return fromGlobal;
+  const fromEnv = typeof process !== "undefined" ? process.env?.["FRONTMCP_BUILD_TARGET"] : void 0;
+  if (typeof fromEnv === "string" && isKnownTarget(fromEnv)) return fromEnv;
+  return "unknown";
+}
+function isKnownTarget(value) {
+  return value === "unknown" || value === "node" || value === "distributed" || value === "cli" || value === "vercel" || value === "lambda" || value === "cloudflare" || value === "browser" || value === "sdk" || value === "mcpb";
+}
+
+// libs/utils/src/env/provider.ts
+var cached2;
+function detectProvider() {
+  if (cached2) return cached2;
+  cached2 = detectProviderUncached();
+  return cached2;
+}
+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";
+}
+
+// libs/utils/src/env/runtime-context.ts
+var entryAvailabilitySchema = z.object({
+  os: z.array(z.string().min(1)).optional(),
+  platform: z.array(z.string().min(1)).optional(),
+  runtime: z.array(z.string().min(1)).optional(),
+  deployment: z.array(z.string().min(1)).optional(),
+  provider: z.array(z.string().min(1)).optional(),
+  target: z.array(z.string().min(1)).optional(),
+  surface: z.array(z.enum(["mcp", "cli", "http-trigger", "job", "agent", "webmcp"])).optional(),
+  env: z.array(z.string().min(1)).optional()
+}).strict();
+var PROCESS_AXES = [
+  // `os` and `platform` both compare against the same RuntimeContext value
+  // — keeping `platform` as a deprecated alias lets pre-#417 metadata
+  // continue to match without any code change.
+  { key: "os", ctxKey: "os" },
+  { key: "platform", ctxKey: "platform" },
+  { key: "runtime", ctxKey: "runtime" },
+  { key: "deployment", ctxKey: "deployment" },
+  { key: "provider", ctxKey: "provider" },
+  { key: "target", ctxKey: "target" },
+  { key: "env", ctxKey: "env" }
+];
+function isEntryAvailable(availability, ctx, callCtx) {
+  if (!availability) return true;
+  for (const { key, ctxKey } of PROCESS_AXES) {
+    const allowed = availability[key];
+    if (allowed === void 0) continue;
+    if (allowed.length === 0) return false;
+    if (!allowed.includes(ctx[ctxKey])) return false;
+  }
+  if (availability.surface !== void 0) {
+    if (availability.surface.length === 0) return false;
+    if (callCtx?.surface !== void 0 && !availability.surface.includes(callCtx.surface)) {
+      return false;
+    }
+  }
+  return true;
+}
+function checkEntryAvailability(availability, ctx, callCtx) {
+  if (!availability) return { available: true, missingAxes: [] };
+  const missing = [];
+  for (const { key, ctxKey } of PROCESS_AXES) {
+    const allowed = availability[key];
+    if (allowed === void 0) continue;
+    if (allowed.length === 0 || !allowed.includes(ctx[ctxKey])) {
+      missing.push(key);
+    }
+  }
+  if (availability.surface !== void 0) {
+    if (availability.surface.length === 0) {
+      missing.push("surface");
+    } else if (callCtx?.surface !== void 0 && !availability.surface.includes(callCtx.surface)) {
+      missing.push("surface");
+    }
+  }
+  return { available: missing.length === 0, missingAxes: missing };
+}
+function detectRuntime() {
+  if (typeof globalThis !== "undefined" && "Bun" in globalThis) return "bun";
+  if (typeof globalThis !== "undefined" && "Deno" in globalThis) return "deno";
+  if (isEdgeRuntime()) return "edge";
+  return "node";
+}
+function detectDeployment(runtime) {
+  const explicit = process.env["FRONTMCP_DEPLOYMENT_MODE"];
+  if (explicit === "distributed") return "distributed";
+  if (explicit === "serverless") return "serverless";
+  if (runtime === "browser") return "browser";
+  if (isServerless()) return "serverless";
+  return "standalone";
+}
+function detectRuntimeContext() {
+  const runtime = detectRuntime();
+  const os = process.platform;
+  return {
+    os,
+    platform: os,
+    runtime,
+    deployment: detectDeployment(runtime),
+    provider: detectProvider(),
+    target: getBuildTarget(),
+    env: getNodeEnv() || "development"
+  };
+}
+var cached3;
+function getRuntimeContext() {
+  if (!cached3) {
+    const detected = detectRuntimeContext();
+    Object.defineProperty(detected, "env", {
+      get: () => getNodeEnv() || "development",
+      enumerable: true,
+      configurable: true
+    });
+    cached3 = detected;
+  }
+  return cached3;
+}
+function resetRuntimeContext() {
+  cached3 = void 0;
+}
+export {
+  checkEntryAvailability,
+  detectRuntimeContext,
+  entryAvailabilitySchema,
+  getRuntimeContext,
+  isEntryAvailable,
+  resetRuntimeContext
+};

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

@@ -1,4 +1,4 @@
-const __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+var __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
 const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
 // __frontmcpCreateRequire
 // libs/utils/src/event-emitter/browser-event-emitter.ts

package/esm/event-emitter/node-event-emitter.mjs

@@ -1,4 +1,4 @@
-const __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+var __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
 const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
 // __frontmcpCreateRequire
 // libs/utils/src/event-emitter/node-event-emitter.ts