@frontmcp/sdk 1.7.2 → 1.8.0

package/esm/index.mjs

@@ -679,6 +679,7 @@ var init_server_tokens = __esm({
       reinitialize: tokenFactory.meta("reinitialize"),
       webRequest: tokenFactory.meta("webRequest"),
       webCtx: tokenFactory.meta("webCtx"),
+      webEnv: tokenFactory.meta("webEnv"),
       webTransport: tokenFactory.meta("webTransport")
     };
   }
@@ -1938,6 +1939,7 @@ import {
   localDcrConfigSchema
 } from "@frontmcp/auth";
 import { publicAuthOptionsSchema } from "@frontmcp/auth";
+import { staticAuthOptionsSchema } from "@frontmcp/auth";
 import { transparentAuthOptionsSchema } from "@frontmcp/auth";
 import {
   localAuthSchema,
@@ -1952,6 +1954,7 @@ import { appAuthOptionsSchema } from "@frontmcp/auth";
 import {
   parseAuthOptions,
   isPublicMode,
+  isStaticMode,
   isTransparentMode,
   isLocalMode,
   isRemoteMode,
@@ -3152,6 +3155,10 @@ var init_front_mcp_metadata = __esm({
       output: outputPolicySchema.optional(),
       jobs: z24.object({
         enabled: z24.boolean(),
+        // Opt-in for `register_job` / `register_workflow` (GHSA-58v2-gpcc-jmqv).
+        // Omitting it here would let Zod strip the flag before the scope reads
+        // it, leaving the documented escape hatch permanently off.
+        allowDynamicRegistration: z24.boolean().optional(),
         store: z24.object({
           redis: redisOptionsSchema.optional(),
           keyPrefix: z24.string().optional()
@@ -5351,6 +5358,8 @@ import {
   TokenStoreRequiredError,
   NoProviderIdError,
   TokenLeakDetectedError,
+  JwtSecretRequiredError,
+  JwtSecretWeakError,
   SessionSecretRequiredError,
   CredentialProviderAlreadyRegisteredError,
   AuthProvidersNotConfiguredError,
@@ -5740,6 +5749,8 @@ __export(errors_exports, {
   InvalidUseValueError: () => InvalidUseValueError,
   InvokeStateMissingKeyError: () => InvokeStateMissingKeyError,
   JobNotAuthorizedError: () => JobNotAuthorizedError,
+  JwtSecretRequiredError: () => JwtSecretRequiredError,
+  JwtSecretWeakError: () => JwtSecretWeakError,
   MCP_ERROR_CODES: () => MCP_ERROR_CODES,
   McpError: () => McpError,
   MethodNotImplementedError: () => MethodNotImplementedError,
@@ -9349,22 +9360,24 @@ function hasValidSessionStructure(dec) {
 function isValidSessionPayload(dec, sig) {
   return hasValidSessionStructure(dec) && dec.authSig === sig;
 }
-function isValidPublicSessionPayload(dec) {
+function isValidPublicSessionPayload(dec, expectedAuthSig = "public") {
   if (typeof dec !== "object" || dec === null) return false;
   const d = dec;
-  return typeof d["nodeId"] === "string" && d["authSig"] === "public" && typeof d["uuid"] === "string" && typeof d["iat"] === "number" && d["isPublic"] === true;
+  return typeof d["nodeId"] === "string" && d["authSig"] === expectedAuthSig && typeof d["uuid"] === "string" && typeof d["iat"] === "number" && // `isPublic` is set only for public mode, so it must track the signature —
+  // a static-mode session must never decrypt as a public one.
+  d["isPublic"] === (expectedAuthSig === "public");
 }
 function decryptSessionId(sessionId, sig) {
   const dec = safeDecrypt(sessionId);
   return isValidSessionPayload(dec, sig) ? dec : null;
 }
-function decryptPublicSession(sessionId) {
+function decryptPublicSession(sessionId, expectedAuthSig = "public") {
   const cached = cache.get(sessionId);
-  if (cached && isValidPublicSessionPayload(cached)) {
+  if (cached && isValidPublicSessionPayload(cached, expectedAuthSig)) {
     return cached;
   }
   const dec = safeDecrypt(sessionId);
-  if (isValidPublicSessionPayload(dec)) {
+  if (isValidPublicSessionPayload(dec, expectedAuthSig)) {
     cache.set(sessionId, dec);
     return dec;
   }
@@ -18182,7 +18195,7 @@ function isUIResourceUri(uri) {
   return uri.startsWith("ui://");
 }
 function parseWidgetUri(uri) {
-  const match = uri.match(/^ui:\/\/widget\/([^.]+)\.(\w+)$/);
+  const match = uri.match(WIDGET_URI_PATTERN);
   if (!match) return null;
   return { toolName: match[1], extension: match[2] };
 }
@@ -18191,7 +18204,7 @@ function getUIResourceMimeType(_platformOrUri) {
   if (_platformOrUri?.endsWith(".css")) return "text/css";
   return MCP_APPS_MIME_TYPE;
 }
-var ToolUIRegistry;
+var ToolUIRegistry, WIDGET_URI_PATTERN;
 var init_ui_shared = __esm({
   "libs/sdk/src/tool/ui/ui-shared.ts"() {
     "use strict";
@@ -18316,6 +18329,7 @@ var init_ui_shared = __esm({
         return { meta: result.meta };
       }
     };
+    WIDGET_URI_PATTERN = /^ui:\/\/widget\/([A-Za-z0-9_:@-]+)\.(html|js|css)$/;
   }
 });
 
@@ -23202,8 +23216,180 @@ var init_adapter_registry = __esm({
   }
 });
 
+// libs/sdk/src/common/utils/path.utils.ts
+import { joinPath, trimSlashes } from "@frontmcp/utils";
+import { trimSlashes as trimSlashes2, joinPath as joinPath2 } from "@frontmcp/utils";
+function normalizeEntryPrefix(entryPath) {
+  const t = trimSlashes(entryPath ?? "");
+  return t ? `/${t}` : "";
+}
+function resolveEntryPath(entryPath) {
+  if (entryPath !== void 0) return entryPath;
+  return process.env["FRONTMCP_HTTP_ENTRY_PATH"] ?? "";
+}
+function normalizeScopeBase(scopeBase) {
+  const t = trimSlashes(scopeBase ?? "");
+  return t ? `/${t}` : "";
+}
+function readPublicUrlPin() {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      const v = process.env["FRONTMCP_PUBLIC_URL"];
+      if (typeof v === "string" && v.trim()) {
+        return v.trim().replace(/\/+$/, "");
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function isPublicUrlPinned() {
+  return readPublicUrlPin() !== void 0;
+}
+function isProxyTrusted() {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      const v = process.env["FRONTMCP_TRUST_PROXY"];
+      return typeof v === "string" && /^(1|true|yes|on)$/i.test(v.trim());
+    }
+  } catch {
+  }
+  return false;
+}
+function getRequestBaseUrl(req, entryPath) {
+  const pin = readPublicUrlPin();
+  if (pin) {
+    return `${pin}${entryPath ?? ""}`;
+  }
+  const trustProxy = isProxyTrusted();
+  const fwdProto = trustProxy ? req.headers["x-forwarded-proto"] : void 0;
+  const fwdHost = trustProxy ? req.headers["x-forwarded-host"] : void 0;
+  const proto = fwdProto || req.protocol || "http";
+  const host = fwdHost || req.headers["host"];
+  return `${proto}://${host}${entryPath ?? ""}`;
+}
+function computeIssuer(req, entryPath, scopeBase) {
+  const entryPrefix = normalizeEntryPrefix(entryPath);
+  const scope = normalizeScopeBase(scopeBase);
+  return `${getRequestBaseUrl(req)}${entryPrefix}${scope}`;
+}
+function computeResource(req, entryPath, scopeBase) {
+  const entryPrefix = normalizeEntryPrefix(entryPath);
+  const scope = normalizeScopeBase(scopeBase);
+  return `${getRequestBaseUrl(req)}${entryPrefix}${scope}`;
+}
+function normalizeResourceUri(uri) {
+  try {
+    const url = new URL(uri);
+    let normalized = `${url.protocol}//${url.hostname}`;
+    const isDefaultPort = url.protocol === "https:" && url.port === "443" || url.protocol === "http:" && url.port === "80";
+    if (url.port && !isDefaultPort) {
+      normalized += `:${url.port}`;
+    }
+    let path3 = url.pathname;
+    if (path3.length > 1 && path3.endsWith("/")) {
+      path3 = path3.slice(0, -1);
+    }
+    normalized += path3;
+    return normalized;
+  } catch {
+    return uri;
+  }
+}
+function resourceUriMatches(provided, canonical) {
+  return normalizeResourceUri(provided) === normalizeResourceUri(canonical);
+}
+function urlToSafeId(url) {
+  const u = new URL(url);
+  const raw = (u.host + (u.pathname && u.pathname !== "/" ? u.pathname : "")).replace(/\/+$/, "");
+  return trimSlashes(raw).replace(/[^a-zA-Z0-9_-]/g, "-");
+}
+function makeWellKnownPaths(name42, entryPrefix, scopeBase = "") {
+  const prefix = normalizeEntryPrefix(entryPrefix);
+  const scope = normalizeScopeBase(scopeBase);
+  const reversed = joinPath(".well-known", name42) + `${prefix}${scope}`;
+  const inPrefixRoot = `${prefix}${joinPath(".well-known", name42)}${scope}`;
+  const inPrefixScope = `${prefix}${scope}${joinPath(".well-known", name42)}`;
+  return /* @__PURE__ */ new Set([reversed, inPrefixRoot, inPrefixScope]);
+}
+var init_path_utils = __esm({
+  "libs/sdk/src/common/utils/path.utils.ts"() {
+    "use strict";
+  }
+});
+
 // libs/sdk/src/context/metadata.utils.ts
-function extractMetadata(headers) {
+function isIpv4(value) {
+  const match = IPV4_PATTERN.exec(value);
+  if (!match) return false;
+  return match.slice(1).every((octet) => {
+    if (octet.length > 1 && octet.startsWith("0")) return false;
+    return Number(octet) <= 255;
+  });
+}
+function isIpv6(value) {
+  const text = value.includes("%") ? value.slice(0, value.indexOf("%")) : value;
+  if (text.length === 0) return false;
+  let head = text;
+  let embedded = 0;
+  const lastColon = head.lastIndexOf(":");
+  const tail = lastColon === -1 ? "" : head.slice(lastColon + 1);
+  if (tail.includes(".")) {
+    if (!isIpv4(tail)) return false;
+    head = head.slice(0, lastColon + 1);
+    embedded = 2;
+  }
+  const halves = head.split("::");
+  if (halves.length > 2) return false;
+  const countGroups = (part) => {
+    if (part === "") return 0;
+    const groups = part.split(":").filter((group, index, all) => !(group === "" && index === all.length - 1));
+    for (const group of groups) {
+      if (!/^[0-9A-Fa-f]{1,4}$/.test(group)) return null;
+    }
+    return groups.length;
+  };
+  const headCount = countGroups(halves[0]);
+  if (headCount === null) return false;
+  if (halves.length === 1) {
+    return headCount + embedded === 8;
+  }
+  const tailCount = countGroups(halves[1]);
+  if (tailCount === null) return false;
+  return headCount + tailCount + embedded <= 7;
+}
+function isIpAddress(value) {
+  const candidate = value.startsWith("[") && value.endsWith("]") ? value.slice(1, -1) : value;
+  return candidate.includes(":") ? isIpv6(candidate) : isIpv4(candidate);
+}
+function normalizeIp(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  return isIpAddress(trimmed) ? trimmed : void 0;
+}
+function readTrustedProxyDepth() {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      const parsed = Number(process.env["FRONTMCP_TRUSTED_PROXY_DEPTH"]);
+      if (Number.isInteger(parsed) && parsed > 0) return parsed;
+    }
+  } catch {
+  }
+  return 1;
+}
+function normalizeDepth(depth) {
+  if (depth === void 0) return readTrustedProxyDepth();
+  return Number.isInteger(depth) && depth > 0 ? depth : readTrustedProxyDepth();
+}
+function headerValues(header) {
+  if (typeof header === "string") return header.split(",");
+  if (Array.isArray(header)) {
+    return header.filter((entry) => typeof entry === "string").flatMap((entry) => entry.split(","));
+  }
+  return [];
+}
+function extractMetadata(headers, options) {
   const customHeaders = {};
   for (const [key, value] of Object.entries(headers)) {
     if (key.toLowerCase().startsWith("x-frontmcp-") && typeof value === "string") {
@@ -23214,30 +23400,34 @@ function extractMetadata(headers) {
     userAgent: typeof headers["user-agent"] === "string" ? headers["user-agent"] : void 0,
     contentType: typeof headers["content-type"] === "string" ? headers["content-type"] : void 0,
     accept: typeof headers["accept"] === "string" ? headers["accept"] : void 0,
-    clientIp: extractClientIp(headers),
+    clientIp: extractClientIp(headers, options),
     customHeaders
   };
 }
-function extractClientIp(headers) {
-  const xff = headers["x-forwarded-for"];
-  if (typeof xff === "string") {
-    return xff.split(",")[0]?.trim();
-  }
-  if (Array.isArray(xff) && typeof xff[0] === "string") {
-    return xff[0].split(",")[0]?.trim();
+function extractClientIp(headers, options) {
+  const peerIp = normalizeIp(options?.peerAddress);
+  const trustProxy = options?.trustProxy ?? isProxyTrusted();
+  if (!trustProxy) {
+    return peerIp;
   }
-  const realIp = headers["x-real-ip"];
-  if (typeof realIp === "string") {
-    return realIp;
+  const depth = normalizeDepth(options?.trustedProxyDepth);
+  const forwarded = headerValues(headers["x-forwarded-for"]).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  if (forwarded.length > 0) {
+    if (forwarded.length < depth) return peerIp;
+    return normalizeIp(forwarded[forwarded.length - depth]) ?? peerIp;
   }
-  if (Array.isArray(realIp) && typeof realIp[0] === "string") {
-    return realIp[0];
+  if (depth === 1) {
+    const realIp = normalizeIp(headerValues(headers["x-real-ip"])[0]);
+    if (realIp) return realIp;
   }
-  return void 0;
+  return peerIp;
 }
+var IPV4_PATTERN;
 var init_metadata_utils = __esm({
   "libs/sdk/src/context/metadata.utils.ts"() {
     "use strict";
+    init_path_utils();
+    IPV4_PATTERN = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
   }
 });
 
@@ -23282,10 +23472,11 @@ var init_frontmcp_context_storage = __esm({
        * @returns Result of the callback
        */
       runFromHeaders(headers, args, fn) {
+        const { peerAddress, ...contextArgs } = args;
         const traceContext = parseTraceContext(headers);
-        const metadata = extractMetadata(headers);
+        const metadata = extractMetadata(headers, { peerAddress });
         const context = new FrontMcpContext({
-          ...args,
+          ...contextArgs,
           traceContext,
           metadata
         });
@@ -24465,11 +24656,13 @@ var init_flow_instance = __esm({
         const headerSessionId = typeof headers["mcp-session-id"] === "string" ? headers["mcp-session-id"].trim() : "";
         const sessionId = headerSessionId.length > 0 ? headerSessionId : `anon:${randomUUID13()}`;
         const scope = this.globalProviders.getActiveScope();
+        const peerAddress = request.socket?.remoteAddress;
         return storage.runFromHeaders(
           headers,
           {
             sessionId,
-            scopeId: scope.id
+            scopeId: scope.id,
+            peerAddress
           },
           async () => {
             return this.run(input, deps);
@@ -34413,13 +34606,13 @@ var init_esm_module_loader = __esm({
             URL.revokeObjectURL(url);
           }
         }
-        const { ensureDir, fileExists: fileExists9, sha256Hex: sha256Hex11, writeFile } = await import("@frontmcp/utils");
+        const { ensureDir, fileExists: fileExists9, sha256Hex: sha256Hex12, writeFile } = await import("@frontmcp/utils");
         const nodePath = await import("node:path");
         const nodeOs = await import("node:os");
         const { pathToFileURL } = await import("node:url");
         const dir = nodePath.join(nodeOs.tmpdir(), "frontmcp-esm-modules");
         await ensureDir(dir);
-        const tempPath = nodePath.join(dir, `${sha256Hex11(bundleContent)}.mjs`);
+        const tempPath = nodePath.join(dir, `${sha256Hex12(bundleContent)}.mjs`);
         if (!await fileExists9(tempPath)) {
           await writeFile(tempPath, bundleContent);
         }
@@ -36340,6 +36533,7 @@ var init_oauth_authorize_flow = __esm({
         const localAuth = auth;
         const store = localAuth.authorizationStore;
         let effectiveIncremental = isIncrementalAuth;
+        let effectivePriorAppIds = priorAuthorizedAppIds;
         if (incrementalTicket) {
           const claimed = await localAuth.claimIncrementalTicket(
             incrementalTicket.jti,
@@ -36348,7 +36542,13 @@ var init_oauth_authorize_flow = __esm({
           if (!claimed) {
             this.logger.warn("Incremental auth ticket already used \u2014 falling back to an ordinary login");
             effectiveIncremental = false;
-            this.state.set({ isIncrementalAuth: false, targetAppId: void 0, targetToolId: void 0 });
+            effectivePriorAppIds = void 0;
+            this.state.set({
+              isIncrementalAuth: false,
+              targetAppId: void 0,
+              targetToolId: void 0,
+              priorAuthorizedAppIds: void 0
+            });
           }
         }
         let federatedLogin;
@@ -36407,7 +36607,7 @@ var init_oauth_authorize_flow = __esm({
           targetAppId: effectiveIncremental ? targetAppId : void 0,
           targetToolId: effectiveIncremental ? targetToolId : void 0,
           existingSessionId,
-          priorAuthorizedAppIds,
+          priorAuthorizedAppIds: effectivePriorAppIds,
           // Federated Login State
           federatedLogin,
           // Consent State
@@ -39585,7 +39785,23 @@ import {
   validateAudience
 } from "@frontmcp/auth";
 import { z as z71 } from "@frontmcp/lazy-zod";
-import { getMachineId as getMachineId2, randomUUID as randomUUID20 } from "@frontmcp/utils";
+import { getMachineId as getMachineId2, randomUUID as randomUUID20, sha256, sha256Hex as sha256Hex9, timingSafeEqual as timingSafeEqual2 } from "@frontmcp/utils";
+function constantTimeEquals(a, b) {
+  const encoder5 = new TextEncoder();
+  return timingSafeEqual2(sha256(encoder5.encode(a)), sha256(encoder5.encode(b)));
+}
+function quoteHeaderParam(value) {
+  return value.replace(/[^\x20-\x21\x23-\x7e]/g, "");
+}
+function buildStaticChallenge(options, description) {
+  const scheme = options.scheme.trim();
+  if (!scheme) return "";
+  const parts = [`${quoteHeaderParam(scheme)} realm="${quoteHeaderParam(options.realm)}"`];
+  if (description) {
+    parts.push('error="invalid_token"', `error_description="${quoteHeaderParam(description)}"`);
+  }
+  return parts.join(", ");
+}
 var inputSchema23, stateSchema22, UnauthorizedSchema, AuthorizedSchema, ForbiddenSchema, sessionVerifyOutputSchema, plan22, name22, Stage22, warnedUnpinnedAudience, SessionVerifyFlow;
 var init_session_verify_flow = __esm({
   "libs/sdk/src/auth/flows/session.verify.flow.ts"() {
@@ -39626,7 +39842,14 @@ var init_session_verify_flow = __esm({
     }).describe("403 Forbidden \u2014 token valid but insufficient scope");
     sessionVerifyOutputSchema = z71.union([UnauthorizedSchema, AuthorizedSchema, ForbiddenSchema]);
     plan22 = {
-      pre: ["parseInput", "handlePublicMode", "handleAnonymousFallback", "requireAuthorizationHeader", "verifyIfJwt"],
+      pre: [
+        "parseInput",
+        "handleStaticToken",
+        "handlePublicMode",
+        "handleAnonymousFallback",
+        "requireAuthorizationHeader",
+        "verifyIfJwt"
+      ],
       execute: ["deriveUser", "parseSessionHeader", "buildAuthorizedOutput"]
     };
     name22 = "session:verify";
@@ -39644,14 +39867,20 @@ var init_session_verify_flow = __esm({
        * Encapsulates the shared logic for session creation, payload encryption, and user derivation.
        */
       createAnonymousSession(options) {
-        const { authMode, issuer, scopes = ["anonymous"], sessionIdHeader } = options;
+        const { authMode, issuer, scopes = ["anonymous"], subject, sessionIdHeader } = options;
         this.logger.verbose("createAnonymousSession", { authMode, hasExistingSession: !!sessionIdHeader });
         const machineId = getMachineId2();
+        const authSignature = subject ? `${authMode}:${subject}` : authMode;
         if (sessionIdHeader) {
-          const existingPayload = decryptPublicSession(sessionIdHeader);
+          const existingPayload = decryptPublicSession(sessionIdHeader, authSignature);
           if (existingPayload && existingPayload.nodeId === machineId) {
             const anonId = existingPayload.uuid ?? `${existingPayload.iat * 1e3}`;
-            const user2 = { sub: `anon:${anonId}`, iss: issuer, name: "Anonymous", scope: scopes.join(" ") };
+            const user2 = {
+              sub: subject ?? `anon:${anonId}`,
+              iss: issuer,
+              name: subject ? "Static token" : "Anonymous",
+              scope: scopes.join(" ")
+            };
             this.respond({
               kind: "authorized",
               authorization: {
@@ -39666,9 +39895,9 @@ var init_session_verify_flow = __esm({
         }
         const now = Date.now();
         const user = {
-          sub: `anon:${randomUUID20()}`,
+          sub: subject ?? `anon:${randomUUID20()}`,
           iss: issuer,
-          name: "Anonymous",
+          name: subject ? "Static token" : "Anonymous",
           scope: scopes.join(" ")
         };
         const uuid = randomUUID20();
@@ -39677,7 +39906,7 @@ var init_session_verify_flow = __esm({
         const payload = {
           uuid,
           nodeId: machineId,
-          authSig: authMode,
+          authSig: authSignature,
           iat: Math.floor(now / 1e3),
           isPublic: authMode === "public",
           authMode,
@@ -39727,14 +39956,68 @@ var init_session_verify_flow = __esm({
           prmUrl
         });
       }
+      async handleStaticToken() {
+        const authOptions = this.scope.auth?.options;
+        if (!authOptions || !isStaticMode(authOptions)) return;
+        const options = authOptions;
+        const presented = this.readStaticCredential(options);
+        if (!presented) {
+          this.logger.warn("handleStaticToken: no credential presented, returning 401");
+          this.respond({
+            kind: "unauthorized",
+            prmMetadataHeader: buildStaticChallenge(options)
+          });
+          return;
+        }
+        const matched = options.tokens.reduce(
+          (found, candidate) => constantTimeEquals(candidate, presented) ? candidate : found,
+          void 0
+        );
+        if (!matched) {
+          this.logger.warn("handleStaticToken: credential did not match, returning 401");
+          this.respond({
+            kind: "unauthorized",
+            prmMetadataHeader: buildStaticChallenge(options, "The access token is invalid")
+          });
+          return;
+        }
+        this.logger.verbose("handleStaticToken: credential accepted");
+        this.createAnonymousSession({
+          authMode: "static",
+          issuer: "static",
+          scopes: options.scopes,
+          subject: `static:${sha256Hex9(matched).slice(0, 12)}`,
+          sessionIdHeader: this.state.sessionIdHeader
+        });
+      }
+      /**
+       * Pull the credential out of the configured header, stripping the scheme
+       * prefix when one is configured (case-insensitively, per RFC 7235).
+       */
+      readStaticCredential(options) {
+        const headers = this.rawInput.request.headers ?? {};
+        const raw = headers[options.header.toLowerCase()];
+        const value = (Array.isArray(raw) ? raw[0] : raw)?.trim();
+        if (!value) return void 0;
+        const { scheme } = options;
+        if (!scheme) return value;
+        if (value.slice(0, scheme.length).toLowerCase() !== scheme.toLowerCase()) return void 0;
+        if (value[scheme.length] !== " ") return void 0;
+        return value.slice(scheme.length + 1).trim() || void 0;
+      }
       async handlePublicMode() {
         const authOptions = this.scope.auth?.options;
         if (!authOptions || !isPublicMode(authOptions)) {
           return;
         }
-        if (this.state.token) {
+        if (this.state.token && isJwt(this.state.token)) {
           return;
         }
+        if (this.state.token) {
+          this.logger.verbose(
+            "handlePublicMode: ignoring non-JWT bearer token (public mode has nothing to verify it against)"
+          );
+        }
         this.logger.info("handlePublicMode: allowing anonymous access (public mode)");
         this.createAnonymousSession({
           authMode: "public",
@@ -39908,6 +40191,14 @@ var init_session_verify_flow = __esm({
     __decorateClass([
       Stage22("parseInput")
     ], SessionVerifyFlow.prototype, "parseInput", 1);
+    __decorateClass([
+      Stage22("handleStaticToken", {
+        filter: ({ scope }) => {
+          const authOptions = scope.auth?.options;
+          return !!authOptions && isStaticMode(authOptions);
+        }
+      })
+    ], SessionVerifyFlow.prototype, "handleStaticToken", 1);
     __decorateClass([
       Stage22("handlePublicMode")
     ], SessionVerifyFlow.prototype, "handlePublicMode", 1);
@@ -40402,7 +40693,7 @@ import {
   MemoryStorageAdapter,
   randomBytes as randomBytes6,
   randomUUID as randomUUID21,
-  sha256Hex as sha256Hex9,
+  sha256Hex as sha256Hex10,
   StorageNotSupportedError
 } from "@frontmcp/utils";
 function getDefaultNoAuthSecret() {
@@ -40428,13 +40719,14 @@ function validateAuthorizationIssuer(received, expected) {
 function isUnsupportedOperation(error) {
   return error instanceof StorageNotSupportedError;
 }
-var defaultNoAuthSecret, RESERVED_JWT_CLAIMS, LocalPrimaryAuth;
+var MIN_HS256_SECRET_BYTES, defaultNoAuthSecret, RESERVED_JWT_CLAIMS, LocalPrimaryAuth;
 var init_instance_local_primary_auth = __esm({
   "libs/sdk/src/auth/instances/instance.local-primary-auth.ts"() {
     "use strict";
     init_common();
     init_auth2();
     init_context_extension();
+    init_errors();
     init_cimd();
     init_credentials();
     init_credentials_context_extension();
@@ -40452,6 +40744,7 @@ var init_instance_local_primary_auth = __esm({
     init_well_known_prm_flow();
     init_secure_store();
     init_secure_store_context_extension();
+    MIN_HS256_SECRET_BYTES = 32;
     RESERVED_JWT_CLAIMS = /* @__PURE__ */ new Set([
       "sub",
       "iss",
@@ -40479,10 +40772,22 @@ var init_instance_local_primary_auth = __esm({
         this.host = getEnv4("FRONTMCP_PUBLIC_HOST")?.trim() || "localhost";
         this.issuer = this.deriveIssuer(options);
         const jwtSecret = getEnv4("JWT_SECRET");
-        if (jwtSecret) {
-          this.secret = new TextEncoder().encode(jwtSecret);
+        const hasJwtSecret = !!jwtSecret?.trim();
+        if (hasJwtSecret && jwtSecret) {
+          const encoded = new TextEncoder().encode(jwtSecret);
+          if (encoded.length < MIN_HS256_SECRET_BYTES) {
+            if (isProduction4()) throw new JwtSecretWeakError(encoded.length);
+            this.logger.warn(
+              `JWT_SECRET is ${encoded.length} bytes; HS256 wants at least ${MIN_HS256_SECRET_BYTES} (RFC 7518). This is refused in production \u2014 generate one with \`openssl rand -hex 32\`.`
+            );
+          }
+          this.secret = encoded;
+        } else if (isProduction4() && isOrchestratedMode(options)) {
+          throw new JwtSecretRequiredError(options.mode);
         } else {
-          this.logger.warn("JWT_SECRET is not set, using default secret");
+          this.logger.warn(
+            "JWT_SECRET is not set; signing with a random per-process secret. Tokens will not survive a restart and will not verify across instances. Set JWT_SECRET for any deployment that mints tokens."
+          );
           this.secret = getDefaultNoAuthSecret();
         }
         this.tokenStorage = this.readTokenStorage(options);
@@ -41042,7 +41347,7 @@ var init_instance_local_primary_auth = __esm({
             const pendingAuthId = `pending:${codeRecord.pendingAuthId}`;
             const parts = accessToken.split(".");
             const signature = parts[2] || accessToken;
-            const newAuthId = sha256Hex9(signature).substring(0, 16);
+            const newAuthId = sha256Hex10(signature).substring(0, 16);
             await this.orchestratedTokenStore.migrateTokens(pendingAuthId, newAuthId);
             this.logger.info(`Migrated tokens from ${pendingAuthId} to ${newAuthId}`);
           } catch (err) {
@@ -41754,6 +42059,9 @@ var init_auth_registry = __esm({
         if (isPublicMode(options)) {
           return new LocalPrimaryAuth(scope, providers, options);
         }
+        if (isStaticMode(options)) {
+          return new LocalPrimaryAuth(scope, providers, options);
+        }
         if (isTransparentMode(options)) {
           return new RemotePrimaryAuth(scope, providers, options);
         }
@@ -45862,7 +46170,9 @@ var init_workflow_step_executor = __esm({
   "libs/sdk/src/workflow/engine/workflow-step.executor.ts"() {
     "use strict";
     init_errors();
+    init_job_errors();
     init_workflow_errors();
+    init_job_permission_guard();
     WorkflowStepExecutor = class {
       jobRegistry;
       logger;
@@ -45877,6 +46187,16 @@ var init_workflow_step_executor = __esm({
         if (!job) {
           throw new InvalidEntityError("job", step.jobName, `a registered job (referenced by step "${step.id}")`);
         }
+        const allowed = await JobPermissionGuard.check(
+          job.metadata.permissions,
+          "execute",
+          this.extra.authInfo,
+          this.extra.authoritiesContextBuilder
+        );
+        if (!allowed) {
+          this.logger.warn(`Step "${step.id}" denied: caller does not satisfy the execute permissions of "${job.name}"`);
+          throw new JobNotAuthorizedError(job.name);
+        }
         const retryConfig = step.retry ?? job.metadata.retry ?? {};
         const maxAttempts = retryConfig.maxAttempts ?? 3;
         const backoffMs = retryConfig.backoffMs ?? 1e3;
@@ -46290,7 +46610,8 @@ var init_job_execution_manager = __esm({
         try {
           const engine = new WorkflowEngine(workflow.metadata, jobRegistry, this.logger, {
             authInfo: opts.authInfo ?? {},
-            contextProviders: opts.contextProviders
+            contextProviders: opts.contextProviders,
+            authoritiesContextBuilder: opts.authoritiesContextBuilder
           });
           const result = await engine.execute(opts.workflowInput);
           await this.stateStore.updateRun(runId, {
@@ -49204,7 +49525,7 @@ var init_load_skill_flow = __esm({
 });
 
 // libs/sdk/src/skill/auth/skill-http-auth.ts
-import { timingSafeEqual as timingSafeEqual2 } from "@frontmcp/utils";
+import { timingSafeEqual as timingSafeEqual3 } from "@frontmcp/utils";
 function createSkillHttpAuthValidator(skillsConfig, logger) {
   if (!skillsConfig?.auth || skillsConfig.auth === "public" || skillsConfig.auth === "inherit") {
     return null;
@@ -49291,7 +49612,7 @@ var init_skill_http_auth = __esm({
           const keyBytes = encoder5.encode(key);
           if (keyBytes.length === candidateBytes.length) {
             try {
-              if (timingSafeEqual2(keyBytes, candidateBytes)) {
+              if (timingSafeEqual3(keyBytes, candidateBytes)) {
                 found = true;
               }
             } catch {
@@ -52257,104 +52578,6 @@ var init_decide_request_intent_utils = __esm({
   }
 });
 
-// libs/sdk/src/common/utils/path.utils.ts
-import { joinPath, trimSlashes } from "@frontmcp/utils";
-import { trimSlashes as trimSlashes2, joinPath as joinPath2 } from "@frontmcp/utils";
-function normalizeEntryPrefix(entryPath) {
-  const t = trimSlashes(entryPath ?? "");
-  return t ? `/${t}` : "";
-}
-function normalizeScopeBase(scopeBase) {
-  const t = trimSlashes(scopeBase ?? "");
-  return t ? `/${t}` : "";
-}
-function readPublicUrlPin() {
-  try {
-    if (typeof process !== "undefined" && process.env) {
-      const v = process.env["FRONTMCP_PUBLIC_URL"];
-      if (typeof v === "string" && v.trim()) {
-        return v.trim().replace(/\/+$/, "");
-      }
-    }
-  } catch {
-  }
-  return void 0;
-}
-function isPublicUrlPinned() {
-  return readPublicUrlPin() !== void 0;
-}
-function isProxyTrusted() {
-  try {
-    if (typeof process !== "undefined" && process.env) {
-      const v = process.env["FRONTMCP_TRUST_PROXY"];
-      return typeof v === "string" && /^(1|true|yes|on)$/i.test(v.trim());
-    }
-  } catch {
-  }
-  return false;
-}
-function getRequestBaseUrl(req, entryPath) {
-  const pin = readPublicUrlPin();
-  if (pin) {
-    return `${pin}${entryPath ?? ""}`;
-  }
-  const trustProxy = isProxyTrusted();
-  const fwdProto = trustProxy ? req.headers["x-forwarded-proto"] : void 0;
-  const fwdHost = trustProxy ? req.headers["x-forwarded-host"] : void 0;
-  const proto = fwdProto || req.protocol || "http";
-  const host = fwdHost || req.headers["host"];
-  return `${proto}://${host}${entryPath ?? ""}`;
-}
-function computeIssuer(req, entryPath, scopeBase) {
-  const entryPrefix = normalizeEntryPrefix(entryPath);
-  const scope = normalizeScopeBase(scopeBase);
-  return `${getRequestBaseUrl(req)}${entryPrefix}${scope}`;
-}
-function computeResource(req, entryPath, scopeBase) {
-  const entryPrefix = normalizeEntryPrefix(entryPath);
-  const scope = normalizeScopeBase(scopeBase);
-  return `${getRequestBaseUrl(req)}${entryPrefix}${scope}`;
-}
-function normalizeResourceUri(uri) {
-  try {
-    const url = new URL(uri);
-    let normalized = `${url.protocol}//${url.hostname}`;
-    const isDefaultPort = url.protocol === "https:" && url.port === "443" || url.protocol === "http:" && url.port === "80";
-    if (url.port && !isDefaultPort) {
-      normalized += `:${url.port}`;
-    }
-    let path3 = url.pathname;
-    if (path3.length > 1 && path3.endsWith("/")) {
-      path3 = path3.slice(0, -1);
-    }
-    normalized += path3;
-    return normalized;
-  } catch {
-    return uri;
-  }
-}
-function resourceUriMatches(provided, canonical) {
-  return normalizeResourceUri(provided) === normalizeResourceUri(canonical);
-}
-function urlToSafeId(url) {
-  const u = new URL(url);
-  const raw = (u.host + (u.pathname && u.pathname !== "/" ? u.pathname : "")).replace(/\/+$/, "");
-  return trimSlashes(raw).replace(/[^a-zA-Z0-9_-]/g, "-");
-}
-function makeWellKnownPaths(name42, entryPrefix, scopeBase = "") {
-  const prefix = normalizeEntryPrefix(entryPrefix);
-  const scope = normalizeScopeBase(scopeBase);
-  const reversed = joinPath(".well-known", name42) + `${prefix}${scope}`;
-  const inPrefixRoot = `${prefix}${joinPath(".well-known", name42)}${scope}`;
-  const inPrefixScope = `${prefix}${scope}${joinPath(".well-known", name42)}`;
-  return /* @__PURE__ */ new Set([reversed, inPrefixRoot, inPrefixScope]);
-}
-var init_path_utils = __esm({
-  "libs/sdk/src/common/utils/path.utils.ts"() {
-    "use strict";
-  }
-});
-
 // libs/sdk/src/common/utils/global-config.utils.ts
 function getGlobalStoreConfig(pluginName, config) {
   if (!config.redis) {
@@ -52689,7 +52912,7 @@ async function tryResolvedSubFile(instance, kind, tail) {
       return parseSkillMdFrontmatter(inline).body;
     }
     const absolutePath = entry.path;
-    const resolvedPath = resolveEntryPath(instance, kind, absolutePath, filename);
+    const resolvedPath = resolveEntryPath2(instance, kind, absolutePath, filename);
     if (!resolvedPath) continue;
     try {
       const buf = await readFileBuffer(resolvedPath);
@@ -52704,7 +52927,7 @@ async function tryResolvedSubFile(instance, kind, tail) {
   }
   return void 0;
 }
-function resolveEntryPath(instance, kind, absolutePath, filename) {
+function resolveEntryPath2(instance, kind, absolutePath, filename) {
   if (absolutePath && isAbsolute3(absolutePath)) return absolutePath;
   if (!filename) return void 0;
   const baseDir = instance.getBaseDir();
@@ -56845,7 +57068,7 @@ var init_transport_remote = __esm({
 });
 
 // libs/sdk/src/transport/transport.registry.ts
-import { getMachineId as getMachineId5, sha256Hex as sha256Hex10 } from "@frontmcp/utils";
+import { getMachineId as getMachineId5, sha256Hex as sha256Hex11 } from "@frontmcp/utils";
 var TransportService;
 var init_transport_registry = __esm({
   "libs/sdk/src/transport/transport.registry.ts"() {
@@ -57381,7 +57604,7 @@ var init_transport_registry = __esm({
       }
       /* --------------------------------- internals -------------------------------- */
       sha256(value) {
-        return sha256Hex10(value);
+        return sha256Hex11(value);
       }
       /**
        * Create a history key from components.
@@ -57674,13 +57897,28 @@ var init_http_request_flow = __esm({
       }
       async acquireQuota() {
         const manager = this.scope.rateLimitManager;
-        if (!manager?.config?.global) return;
+        if (!manager) return;
         const context = this.tryGetContext();
         const partitionCtx = context ? {
           sessionId: context.sessionId,
           clientIp: context.metadata?.clientIp,
           userId: context.authInfo?.clientId
         } : void 0;
+        const ipResult = manager.checkIpFilter(partitionCtx?.clientIp);
+        if (ipResult && !ipResult.allowed) {
+          this.logger.warn(`[${this.requestId}] request rejected by ipFilter`, { reason: ipResult.reason });
+          this.respond(
+            httpRespond.json(
+              {
+                jsonrpc: "2.0",
+                error: { code: -32001, message: "Forbidden: client IP rejected by ipFilter" }
+              },
+              { status: 403 }
+            )
+          );
+          return;
+        }
+        if (!manager.config?.global) return;
         const result = await manager.checkGlobalRateLimit(partitionCtx);
         if (!result.allowed) {
           const retryAfter = Math.ceil((result.retryAfterMs ?? 6e4) / 1e3);
@@ -58301,6 +58539,7 @@ var init_scope_instance = __esm({
     init_channel_scope_helper();
     init_common();
     init_sqlite();
+    init_path_utils();
     init_complete_flow();
     init_context();
     init_elicitation2();
@@ -58401,7 +58640,7 @@ var init_scope_instance = __esm({
         this.logger = globalProviders.get(FrontMcpLogger).child("FrontMcp.MultiAppScope");
         this.globalProviders = globalProviders;
         this.server = this.globalProviders.get(FrontMcpServer);
-        this.entryPath = rec.metadata.http?.entryPath ?? "";
+        this.entryPath = resolveEntryPath(rec.metadata.http?.entryPath);
         if (rec.kind === "SPLIT_BY_APP") {
           this.routeBase = `/${rec.metadata.id}`;
         } else {
@@ -58505,16 +58744,25 @@ var init_scope_instance = __esm({
         })() : void 0;
         const tasksConfig = this.metadata.tasks;
         const tasksExplicitlyDisabled = tasksConfig?.enabled === false;
+        const tasksExplicitlyEnabled = tasksConfig?.enabled === true;
         const isTaskWorker = !!this.metadata["__taskWorkerMode"];
         const hasPersistentBackend = Boolean(
           tasksConfig?.sqlite || tasksConfig?.redis || this.metadata.redis || this.metadata.sqlite
         );
         const tasksEnabledForCli = this.cliMode && hasPersistentBackend;
-        const shouldInitTasks = !tasksExplicitlyDisabled && (!this.cliMode || tasksEnabledForCli || isTaskWorker);
+        const hasDistributedTaskBackend = Boolean(tasksConfig?.redis ?? this.metadata.redis);
+        const onEdgeRuntime = isEdgeRuntime();
+        const tasksUnavailableOnEdge = onEdgeRuntime && !hasDistributedTaskBackend && !tasksExplicitlyEnabled;
+        if (tasksUnavailableOnEdge) {
+          this.logger.info(
+            "[tasks] Background tasks are unavailable on this edge/serverless runtime: the in-process runner cannot continue past the HTTP response, and an in-memory store is not shared between isolates. Serving without tasks. Configure `tasks.redis` (Upstash Redis over HTTP works on Workers) to enable them."
+          );
+        }
+        const shouldInitTasks = !tasksExplicitlyDisabled && !tasksUnavailableOnEdge && (!this.cliMode || tasksEnabledForCli || isTaskWorker);
         const tasksPromise = shouldInitTasks ? (async () => {
           const tasksRedis = tasksConfig?.redis ?? this.metadata.redis;
           const tasksSqlite = tasksConfig?.sqlite ?? (tasksRedis ? void 0 : resolvedTopLevelSqlite);
-          const onEdge = isEdgeRuntime();
+          const onEdge = onEdgeRuntime;
           if (onEdge) {
             const msg = "[tasks] Background tasks are enabled on an edge/serverless runtime. The in-process runner cannot continue past the HTTP response on this platform \u2014 task bodies will not execute. Run on a long-lived Node process, or set `tasks.enabled: false`.";
             if (tasksConfig?.strict) {
@@ -60660,7 +60908,7 @@ function createWebFetchHandler(scope, options = {}) {
     while (end > 1 && withSlash.charCodeAt(end - 1) === 47) end--;
     return withSlash.slice(0, end);
   };
-  const rawEntry = options.entryPath ?? (normalizeEntryPrefix(httpConfig?.entryPath) || "/");
+  const rawEntry = options.entryPath ?? (normalizeEntryPrefix(resolveEntryPath(httpConfig?.entryPath)) || "/");
   const entryPaths = new Set((Array.isArray(rawEntry) ? rawEntry : [rawEntry]).map(normalizePath));
   const cors2 = options.cors ?? mapHttpCors(httpConfig?.cors, scope);
   const corsEnabled = cors2?.origin !== void 0 && cors2.origin !== false;
@@ -60725,7 +60973,7 @@ function createWebFetchHandler(scope, options = {}) {
       );
     }
     if (!entryPaths.has(normalizePath(url.pathname))) {
-      const authResponse = await runMatchingHttpFlowWeb(scope, request);
+      const authResponse = await runMatchingHttpFlowWeb(scope, request, { ctx, env });
       if (authResponse) return withCors(authResponse, request);
       return withCors(Response.json({ error: "Not Found", entryPaths: [...entryPaths] }, { status: 404 }), request);
     }
@@ -60733,13 +60981,13 @@ function createWebFetchHandler(scope, options = {}) {
       const routed = await options.sessionRouter(request, env, ctx);
       if (routed) return withCors(routed, request);
     }
-    const rendered = await runHttpRequestFlowWeb(scope, request, { ctx });
+    const rendered = await runHttpRequestFlowWeb(scope, request, { ctx, env });
     return withCors(rendered ?? Response.json({ error: "Not Found" }, { status: 404 }), request);
   };
 }
 async function runHttpRequestFlowWeb(scope, request, opts = {}) {
   const url = new URL(request.url);
-  const serverRequest = await toServerRequest(request, url, opts.ctx, opts.persistent);
+  const serverRequest = await toServerRequest(request, url, opts.ctx, opts.persistent, opts.env);
   let output;
   try {
     output = await scope.runFlow("http:request", {
@@ -60751,9 +60999,9 @@ async function runHttpRequestFlowWeb(scope, request, opts = {}) {
   }
   return output ? renderHttpOutputToWebResponse(output) : void 0;
 }
-async function runMatchingHttpFlowWeb(scope, request) {
+async function runMatchingHttpFlowWeb(scope, request, opts = {}) {
   const url = new URL(request.url);
-  const serverRequest = await toServerRequest(request, url);
+  const serverRequest = await toServerRequest(request, url, opts.ctx, void 0, opts.env);
   const flowName = await scope.findHttpFlowName(serverRequest);
   if (!flowName) return void 0;
   let output;
@@ -60767,7 +61015,7 @@ async function runMatchingHttpFlowWeb(scope, request) {
   }
   return output ? renderHttpOutputToWebResponse(output) : void 0;
 }
-async function toServerRequest(request, url, ctx, persistent) {
+async function toServerRequest(request, url, ctx, persistent, env) {
   const headers = {};
   request.headers.forEach((v, k) => {
     headers[k] = v;
@@ -60811,10 +61059,39 @@ async function toServerRequest(request, url, ctx, persistent) {
   const tokenized = serverRequest;
   tokenized[ServerRequestTokens.webRequest] = webRequest;
   tokenized[ServerRequestTokens.webCtx] = ctx;
+  tokenized[ServerRequestTokens.webEnv] = env;
   if (persistent) tokenized[ServerRequestTokens.webTransport] = persistent;
   return serverRequest;
 }
+function misconfigurationResponse(error) {
+  const misconfiguration = findMisconfiguration(error);
+  if (!misconfiguration) return void 0;
+  return Response.json(
+    { error: "server_misconfigured", code: misconfiguration.code, message: misconfiguration.remedy },
+    { status: 500 }
+  );
+}
+function findMisconfiguration(error) {
+  let current = error;
+  for (let depth = 0; current instanceof Error && depth < 5; depth++) {
+    const code = current.code;
+    if (typeof code === "string" && MISCONFIGURATION_REMEDIES[code]) {
+      return { code, remedy: MISCONFIGURATION_REMEDIES[code] };
+    }
+    current = current.cause;
+  }
+  return void 0;
+}
 function flowErrorToHttpOutput(error) {
+  const misconfiguration = findMisconfiguration(error);
+  if (misconfiguration) {
+    return {
+      kind: "json",
+      status: 500,
+      contentType: "application/json; charset=utf-8",
+      body: { error: "server_misconfigured", code: misconfiguration.code, message: misconfiguration.remedy }
+    };
+  }
   if (error instanceof FlowControl) {
     switch (error.type) {
       case "respond":
@@ -60838,6 +61115,7 @@ function flowErrorToHttpOutput(error) {
   }
   return { kind: "text", status: 500, body: "Internal Server Error", contentType: "text/plain; charset=utf-8" };
 }
+var MISCONFIGURATION_REMEDIES;
 var init_web_fetch_handler = __esm({
   "libs/sdk/src/transport/web-fetch-handler.ts"() {
     "use strict";
@@ -60847,6 +61125,11 @@ var init_web_fetch_handler = __esm({
     init_errors();
     init_host_validation();
     init_web_response_renderer();
+    MISCONFIGURATION_REMEDIES = {
+      SESSION_SECRET_REQUIRED: "Set MCP_SESSION_SECRET in the deployment environment (e.g. `wrangler secret put MCP_SESSION_SECRET`). Session IDs are encrypted with it, and production refuses the development machine-id fallback.",
+      JWT_SECRET_INVALID: "JWT_SECRET is present but too weak: HS256 requires at least 32 bytes (RFC 7518). Replace it with `openssl rand -hex 32`.",
+      JWT_SECRET_REQUIRED: "Set JWT_SECRET in the deployment environment (e.g. `wrangler secret put JWT_SECRET`). Tokens are signed with it; production refuses the random per-process fallback because tokens would not survive a restart or verify across instances."
+    };
   }
 });
 
@@ -61200,17 +61483,16 @@ var init_express_host_adapter = __esm({
           });
         } else {
           this.deriveHostValidation = (portOrSocketPath, bindAddress) => {
-            const isSocket = typeof portOrSocketPath === "string";
+            if (typeof portOrSocketPath === "string") return void 0;
             const derivation = {
               // `start()` binds `bindAddress ?? '0.0.0.0'`; mirror that exactly.
-              bindAddress: isSocket ? void 0 : bindAddress ?? "0.0.0.0",
-              port: isSocket ? void 0 : portOrSocketPath,
-              socketPath: isSocket ? portOrSocketPath : void 0,
+              bindAddress: bindAddress ?? "0.0.0.0",
+              port: portOrSocketPath,
               issuer: options?.listen?.issuer
             };
             if (!shouldEnforceDerivedHosts(derivation)) {
               console.warn(
-                `[frontmcp] DNS-rebinding protection is not enforcing a Host allow-list: the server binds a routable address (${derivation.bindAddress ?? "unknown"}) and no allowed hosts are configured. Set security.dnsRebindingProtection.allowedHosts (or FRONTMCP_ALLOWED_HOSTS) to your public hostname(s).`
+                `[frontmcp] DNS-rebinding protection is not enforcing a Host allow-list: the server binds a routable address (${derivation.bindAddress}) and no allowed hosts are configured. Set security.dnsRebindingProtection.allowedHosts (or FRONTMCP_ALLOWED_HOSTS) to your public hostname(s).`
               );
               return void 0;
             }
@@ -61266,7 +61548,6 @@ var init_express_host_adapter = __esm({
         return this.app;
       }
       async start(portOrSocketPath, bindAddress) {
-        this.enableDerivedHostValidation(portOrSocketPath, bindAddress);
         this.prepare();
         const server = http.createServer(this.app);
         server.requestTimeout = 0;
@@ -61274,6 +61555,7 @@ var init_express_host_adapter = __esm({
         server.keepAliveTimeout = 75e3;
         if (typeof portOrSocketPath === "string") {
           await this.cleanupStaleSocket(portOrSocketPath);
+          this.enableDerivedHostValidation(portOrSocketPath);
           await new Promise((resolve, reject) => {
             server.on("error", reject);
             server.listen(portOrSocketPath, () => {
@@ -61291,7 +61573,11 @@ var init_express_host_adapter = __esm({
           await new Promise((resolve, reject) => {
             server.on("error", reject);
             server.listen(portOrSocketPath, host, () => {
-              console.log(`MCP HTTP (Express) on ${host}:${portOrSocketPath}`);
+              const bound = server.address();
+              const boundPort = typeof bound === "object" && bound ? bound.port : portOrSocketPath;
+              const boundAddress = typeof bound === "object" && bound ? bound.address : host;
+              this.enableDerivedHostValidation(boundPort, boundAddress);
+              console.log(`MCP HTTP (Express) on ${host}:${boundPort}`);
               resolve();
             });
           });
@@ -61693,7 +61979,7 @@ var init_front_mcp = __esm({
           frontMcp.log?.info("FrontMCP fetch handler created (web-standard transport)");
           return createWebFetchHandler(scope);
         };
-        return async (request) => {
+        return async (request, ctx, env) => {
           if (!inner) {
             if (!building) {
               building = build().catch((err) => {
@@ -61701,9 +61987,15 @@ var init_front_mcp = __esm({
                 throw err;
               });
             }
-            inner = await building;
+            try {
+              inner = await building;
+            } catch (err) {
+              const misconfigured = misconfigurationResponse(err);
+              if (misconfigured) return misconfigured;
+              throw err;
+            }
           }
-          return inner(request);
+          return inner(request, ctx, env);
         };
       }
       /**
@@ -64685,6 +64977,8 @@ export {
   JobNotAuthorizedError,
   JobPermissionGuard,
   JobRegistry,
+  JwtSecretRequiredError,
+  JwtSecretWeakError,
   LLM_ADAPTER,
   LazyZodSchema,
   ListJobsTool,
@@ -65112,6 +65406,7 @@ export {
   isOrchestratedMode,
   isOrchestratedRemote,
   isPackageSpecifier,
+  isProxyTrusted,
   isPublicError,
   isPublicMode,
   isPublicUrlPinned,
@@ -65120,6 +65415,7 @@ export {
   isRemoteMode,
   isSkillDecorated,
   isSkillRecord,
+  isStaticMode,
   isTaskWorkerProcess,
   isTerminal,
   isToolRefWithClass,
@@ -65197,6 +65493,7 @@ export {
   remoteAuthSchema,
   remoteProviderConfigSchema,
   resolveDefaultSqlitePath,
+  resolveEntryPath,
   resolveNameConflicts,
   resolveOutputSchemaMode,
   resolvePendingTC39HooksForClass,
@@ -65239,6 +65536,7 @@ export {
   skillsConfigOptionsSchema,
   skippedAppBehaviorSchema,
   sqliteOptionsSchema,
+  staticAuthOptionsSchema,
   storageProviderSchema,
   supportsStreaming,
   toJSONSchema9 as toJSONSchema,