veryfront 0.1.95 → 0.1.97

package/src/src/jobs/runtime-env.ts

@@ -0,0 +1,132 @@
+import { logger as baseLogger } from "../utils/index.js";
+
+const logger = baseLogger.component("job-runtime-env");
+
+export const INJECTED_TASK_ENV_JSON = "VERYFRONT_TASK_ENV_JSON";
+
+const UNSAFE_INJECTED_ENV_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+const HIDDEN_TASK_CONTEXT_ENV_KEYS = new Set([
+  "VERYFRONT_API_TOKEN",
+  "VERYFRONT_API_URL",
+  "VERYFRONT_PROJECT_API_URL",
+  "VERYFRONT_API_BASE_URL",
+  "VERYFRONT_PROJECT_ID",
+  "VERYFRONT_PROJECT_SLUG",
+  "VERYFRONT_BRANCH_REF",
+  "VERYFRONT_API_USER",
+  "VERYFRONT_API_PASS",
+  "VERYFRONT_JOB_RESULT_PATH",
+  INJECTED_TASK_ENV_JSON,
+]);
+
+const DISALLOWED_INJECTED_ENV_KEYS = new Set([
+  "VERYFRONT_API_TOKEN",
+  "VERYFRONT_API_URL",
+  "VERYFRONT_PROJECT_API_URL",
+  "VERYFRONT_API_BASE_URL",
+  "VERYFRONT_PROJECT_ID",
+  "VERYFRONT_PROJECT_SLUG",
+  "VERYFRONT_BRANCH_REF",
+  "VERYFRONT_API_USER",
+  "VERYFRONT_API_PASS",
+  "VERYFRONT_JOB_RESULT_PATH",
+  INJECTED_TASK_ENV_JSON,
+]);
+
+function isHiddenTaskContextEnvKey(key: string): boolean {
+  return key.startsWith("TENANT_") || HIDDEN_TASK_CONTEXT_ENV_KEYS.has(key);
+}
+
+function isDisallowedInjectedEnvKey(key: string): boolean {
+  return key.startsWith("TENANT_") || DISALLOWED_INJECTED_ENV_KEYS.has(key);
+}
+
+function filterExistingProjectEnv(
+  env: Record<string, string> | undefined,
+): Record<string, string> {
+  const filtered: Record<string, string> = {};
+  for (const [key, value] of Object.entries(env ?? {})) {
+    if (
+      UNSAFE_INJECTED_ENV_KEYS.has(key) ||
+      isDisallowedInjectedEnvKey(key) ||
+      typeof value !== "string"
+    ) {
+      continue;
+    }
+    filtered[key] = value;
+  }
+  return filtered;
+}
+
+export function readInjectedProjectEnv(
+  allEnv: Record<string, string>,
+): Record<string, string> {
+  const raw = allEnv[INJECTED_TASK_ENV_JSON];
+  if (!raw) {
+    return {};
+  }
+
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {};
+    }
+
+    const injectedEnv = Object.create(null) as Record<string, string>;
+    for (const [key, value] of Object.entries(parsed)) {
+      if (
+        UNSAFE_INJECTED_ENV_KEYS.has(key) ||
+        isDisallowedInjectedEnvKey(key) ||
+        typeof value !== "string"
+      ) {
+        continue;
+      }
+      injectedEnv[key] = value;
+    }
+
+    return injectedEnv;
+  } catch {
+    logger.warn(`Ignoring invalid ${INJECTED_TASK_ENV_JSON}`);
+    return {};
+  }
+}
+
+export function buildTaskContextEnv(
+  allEnv: Record<string, string>,
+  envAllowlist?: string[],
+): Record<string, string> {
+  const allowlistedEnvKeys = envAllowlist ? new Set(envAllowlist) : null;
+  const env: Record<string, string> = {};
+
+  for (const [key, value] of Object.entries(allEnv)) {
+    if (isHiddenTaskContextEnvKey(key)) {
+      continue;
+    }
+    if (allowlistedEnvKeys && !allowlistedEnvKeys.has(key)) {
+      continue;
+    }
+    env[key] = value;
+  }
+
+  for (const [key, value] of Object.entries(readInjectedProjectEnv(allEnv))) {
+    if (allowlistedEnvKeys && !allowlistedEnvKeys.has(key)) {
+      continue;
+    }
+    env[key] = value;
+  }
+
+  return env;
+}
+
+export function mergeInjectedWorkflowEnv(
+  existingEnv: Record<string, string> | undefined,
+  allEnv: Record<string, string>,
+): Record<string, string> | undefined {
+  const mergedEnv = {
+    ...filterExistingProjectEnv(existingEnv),
+    ...readInjectedProjectEnv(allEnv),
+  };
+
+  return Object.keys(mergedEnv).length > 0 ? mergedEnv : undefined;
+}

package/src/src/modules/react-loader/ssr-module-loader/loader.ts

@@ -54,6 +54,7 @@ import { preflightLocalImports } from "./preflight-imports.js";
 import { resolveVfModuleImports } from "./vf-module-resolver.js";
 import { registerCSSImport } from "../css-import-collector.js";
 import { injectNodePositions } from "../../../transforms/plugins/babel-node-positions.js";
+import { ensureMdxModuleDependencies } from "../../../transforms/mdx/esm-module-loader/module-fetcher/dependency-recovery.js";
 
 const logger = rendererLogger.component("ssr-module-loader");
 
@@ -230,6 +231,35 @@ export class SSRModuleLoader {
       }
 
       if (classifiedError.type === "module-not-found") {
+        if (this.options.contentSourceId) {
+          try {
+            const cachedCode = await this.cache.getFs().readTextFile(cacheEntry.tempPath);
+            const recovered = await ensureMdxModuleDependencies(cachedCode, {
+              projectId: this.options.projectId,
+              contentSourceId: this.options.contentSourceId,
+              log: logger,
+            });
+            if (recovered.missing.length === 0 && recovered.recovered.length > 0) {
+              const retryTempPath = cacheEntry.tempPath.replace(/\.mjs$/, "") +
+                `-recovered-${cacheEntry.contentHash}.mjs`;
+              await this.cache.getFs().writeTextFile(retryTempPath, cachedCode);
+              logger.info("Recovered vfmod dependencies for cached SSR module, retrying import", {
+                file: filePath.slice(-40),
+                recovered: recovered.recovered.slice(0, 5),
+                retryTempPath,
+              });
+              return (await import(
+                `file://${retryTempPath}?v=${cacheEntry.contentHash}&retry=1`
+              )) as Record<string, unknown>;
+            }
+          } catch (recoveryError) {
+            logger.debug("Failed to recover vfmod dependencies for cached SSR module", {
+              file: filePath.slice(-40),
+              error: recoveryError instanceof Error ? recoveryError.message : String(recoveryError),
+            });
+          }
+        }
+
         logger.error(
           "[SSR-MODULE-LOADER] Cached module has missing dependency, invalidating cache",
           {
@@ -426,6 +456,10 @@ export class SSRModuleLoader {
         mdxCacheDir,
         this.options.projectDir,
         contentHash,
+        {
+          projectId: this.options.projectId,
+          contentSourceId: this.options.contentSourceId,
+        },
       );
 
       if (mdxCacheResult.status === "hit") {

package/src/src/modules/react-loader/ssr-module-loader/ssr-cache-manager.ts

@@ -26,6 +26,7 @@ import {
 } from "./http-bundle-helpers.js";
 import { buildTempModulePath, buildTmpDirPath, getTmpDirCacheKey } from "./tmp-paths.js";
 import type { ModuleCacheEntry, SSRModuleLoaderOptions } from "./types.js";
+import { ensureMdxModuleDependencies } from "../../../transforms/mdx/esm-module-loader/module-fetcher/dependency-recovery.js";
 
 const logger = rendererLogger.component("ssr-module-loader");
 
@@ -169,7 +170,7 @@ export class SSRCacheManager {
     try {
       const cachedCode = await this.fs.readTextFile(cachedEntry.tempPath);
       const isValid = await this.validateCachedCode(cachedCode, filePath, "memory-cache", {
-        checkLocalPaths: false,
+        checkLocalPaths: true,
         checkInvalidEsmShPath: false,
       });
       if (!isValid) {
@@ -237,11 +238,14 @@ export class SSRCacheManager {
 
   private async hasMissingLocalPaths(code: string, filePath: string): Promise<boolean> {
     const allPaths = extractAllFilePaths(code);
+    let hasMissingPath = false;
+
     for (const path of allPaths) {
       try {
         const stat = await this.fs.stat(path);
         if (!stat.isFile) {
-          return true;
+          hasMissingPath = true;
+          break;
         }
       } catch (error) {
         logger.debug("Redis cache has invalid local path, re-transforming", {
@@ -249,6 +253,34 @@ export class SSRCacheManager {
           missingPath: path.slice(-60),
           error,
         });
+        hasMissingPath = true;
+        break;
+      }
+    }
+
+    if (
+      hasMissingPath &&
+      this.options.projectId &&
+      this.options.contentSourceId
+    ) {
+      const recovered = await ensureMdxModuleDependencies(code, {
+        projectId: this.options.projectId,
+        contentSourceId: this.options.contentSourceId,
+        log: logger,
+      });
+      if (recovered.recovered.length > 0) {
+        logger.debug("Recovered missing local vfmod dependencies for SSR cache entry", {
+          file: filePath.slice(-40),
+          recovered: recovered.recovered.slice(0, 5),
+        });
+      }
+    }
+
+    for (const path of allPaths) {
+      try {
+        const stat = await this.fs.stat(path);
+        if (!stat.isFile) return true;
+      } catch (_) {
         return true;
       }
     }

package/src/src/modules/react-loader/ssr-module-loader/vf-module-resolver.ts

@@ -78,6 +78,7 @@ export async function resolveVfModuleImports(
     options.projectDir,
     options.projectId,
     {
+      contentSourceId: options.contentSourceId,
       reactVersion: options.reactVersion,
       projectSlug: options.projectId,
       strictMissingModules: false,

package/src/src/rendering/orchestrator/module-loader/index.ts

@@ -223,7 +223,18 @@ export async function transformModuleWithDeps(
     const sourceKey = encodeURIComponent(contentSourceId);
     const mdxCacheDir = join(baseCacheDir, projectKey, sourceKey);
 
-    const mdxCacheResult = await lookupMdxEsmCache(filePath, mdxCacheDir, projectDir);
+    const mdxCacheResult = await lookupMdxEsmCache(
+      filePath,
+      mdxCacheDir,
+      projectDir,
+      undefined,
+      contentSourceId
+        ? {
+          projectId,
+          contentSourceId,
+        }
+        : undefined,
+    );
     if (mdxCacheResult.status === "hit") {
       moduleCache.set(cacheKey, mdxCacheResult.path);
       return mdxCacheResult.path;

package/src/src/rendering/page-rendering.ts

@@ -15,6 +15,64 @@ interface MDXPageResult {
   collectedMetadata: Record<string, unknown>;
 }
 
+interface PreparedMDXPageBundles {
+  pageBundle: PageBundle;
+  serverModuleCode: string;
+}
+
+export async function prepareMDXPageBundles(
+  pageInfo: EntityInfo,
+  projectDir: string,
+  options?: {
+    precompiledModule?: string;
+    studioEmbed?: boolean;
+  },
+): Promise<PreparedMDXPageBundles> {
+  const { frontmatter, content, path } = pageInfo.entity;
+  const fmArg = frontmatter && Object.keys(frontmatter).length > 0 ? frontmatter : undefined;
+
+  const ssrBundle = await compileContent(
+    "development",
+    projectDir,
+    content,
+    fmArg,
+    path,
+    "server",
+    undefined,
+    options?.studioEmbed,
+  );
+
+  const pageBundle = ssrBundle as PageBundle;
+
+  if (options?.precompiledModule) {
+    pageBundle.clientModuleCode = options.precompiledModule;
+  } else {
+    const browserBundle = await compileContent(
+      "development",
+      projectDir,
+      content,
+      fmArg,
+      path,
+      "browser",
+      undefined,
+      options?.studioEmbed,
+    );
+    pageBundle.clientModuleCode = browserBundle.compiledCode;
+  }
+
+  const clientModuleCode = pageBundle.clientModuleCode;
+  if (!clientModuleCode) {
+    throw RENDER_ERROR.create({
+      detail: "MDX compilation produced no client module code",
+    });
+  }
+
+  return {
+    pageBundle,
+    serverModuleCode: ssrBundle.compiledCode,
+  };
+}
+
 export function handleMDXPage(
   pageInfo: EntityInfo,
   slug: string,
@@ -42,49 +100,16 @@ export function handleMDXPage(
   return withSpan(
     "rendering.handleMDXPage",
     async () => {
-      const { frontmatter, content, path } = pageInfo.entity;
-      const fmArg = frontmatter && Object.keys(frontmatter).length > 0 ? frontmatter : undefined;
-
-      const ssrBundle = await compileContent(
-        "development",
-        projectDir,
-        content,
-        fmArg,
-        path,
-        "server",
-        undefined,
-        options?.studioEmbed,
-      );
-
-      const pageBundle = ssrBundle as PageBundle;
+      const { frontmatter, path } = pageInfo.entity;
+      const { pageBundle, serverModuleCode } = await prepareMDXPageBundles(pageInfo, projectDir, {
+        precompiledModule: options?.precompiledModule,
+        studioEmbed: options?.studioEmbed,
+      });
       let collectedMetadata: Record<string, unknown> = {};
 
       try {
-        if (options?.precompiledModule) {
-          pageBundle.clientModuleCode = options.precompiledModule;
-        } else {
-          const browserBundle = await compileContent(
-            "development",
-            projectDir,
-            content,
-            fmArg,
-            path,
-            "browser",
-            undefined,
-            options?.studioEmbed,
-          );
-          pageBundle.clientModuleCode = browserBundle.compiledCode;
-        }
-
-        const clientModuleCode = pageBundle.clientModuleCode;
-        if (!clientModuleCode) {
-          throw RENDER_ERROR.create({
-            detail: "MDX compilation produced no client module code",
-          });
-        }
-
         const mod = (await mdxRenderer.loadModuleESM(
-          clientModuleCode,
+          serverModuleCode,
           adapter,
           options?.projectId,
           projectDir,

package/src/src/task/runner.ts

@@ -7,6 +7,7 @@
 
 import { logger as baseLogger } from "../utils/index.js";
 import { env as getProcessEnv } from "../platform/compat/process.js";
+import { buildTaskContextEnv } from "../jobs/runtime-env.js";
 import type { DiscoveredTask } from "./discovery.js";
 import type { TaskContext } from "./types.js";
 
@@ -61,14 +62,7 @@ export async function runTask(options: RunTaskOptions): Promise<TaskRunResult> {
   }
 
   const allEnv = getProcessEnv();
-  const env: Record<string, string> = envAllowlist
-    ? Object.fromEntries(
-      envAllowlist.flatMap((k) => {
-        const value = allEnv[k];
-        return value === undefined ? [] : [[k, value] as const];
-      }),
-    )
-    : { ...allEnv };
+  const env = buildTaskContextEnv(allEnv, envAllowlist);
 
   const ctx: TaskContext = {
     env,

package/src/src/transforms/mdx/esm-module-loader/cache/index.ts

@@ -21,6 +21,7 @@ import {
 import { LOG_PREFIX_MDX_LOADER } from "../constants.js";
 import { LRUCache } from "../../../../utils/lru-wrapper.js";
 import { buildMdxEsmPathCacheKey, MDX_ESM_ALL_FILE_URL_PATTERN_SOURCE } from "../cache-format.js";
+import { ensureMdxModuleDependencies } from "../module-fetcher/dependency-recovery.js";
 
 export type CacheLookupResult =
   | { status: "hit"; path: string }
@@ -341,6 +342,7 @@ export async function lookupMdxEsmCache(
   cacheDir: string,
   projectDir?: string,
   _contentHash?: string, // Intentionally unused - kept for API compatibility
+  recoveryOptions?: { projectId: string; contentSourceId: string },
 ): Promise<CacheLookupResult> {
   const cache = await getModulePathCache(cacheDir);
   const cacheKey = toMdxEsmCacheKey(filePath, projectDir);
@@ -408,7 +410,22 @@ export async function lookupMdxEsmCache(
     // CRITICAL: Check that all file:// dependencies actually exist on disk.
     // The distributed cache may contain code referencing file:// paths from other pods
     // that don't exist locally (e.g., HTTP bundles, MDX-ESM modules).
-    const missingDeps = await findMissingFileDependencies(cachedCode);
+    let missingDeps = await findMissingFileDependencies(cachedCode);
+    if (missingDeps.length > 0 && recoveryOptions) {
+      const recovered = await ensureMdxModuleDependencies(cachedCode, {
+        ...recoveryOptions,
+        log: logger,
+      });
+      if (recovered.recovered.length > 0) {
+        logger.debug(`${LOG_PREFIX_MDX_LOADER} Recovered cached MDX-ESM dependencies`, {
+          filePath,
+          cachedPath,
+          recovered: recovered.recovered.slice(0, 5),
+        });
+      }
+      missingDeps = await findMissingFileDependencies(cachedCode);
+    }
+
     if (missingDeps.length > 0) {
       logger.warn(
         `${LOG_PREFIX_MDX_LOADER} Cached module has ${missingDeps.length} missing file dependencies, invalidating`,

package/src/src/transforms/mdx/esm-module-loader/cache-format.ts

@@ -10,10 +10,11 @@ const CACHE_NAMESPACE_SENTINEL = "__vf_cache_namespace__";
 function formatMdxEsmTransformCacheKey(
   namespace: string,
   projectId: string,
+  contentSourceId: string,
   normalizedPath: string,
   contentHash: string,
 ): string {
-  return `${namespace}:${projectId}:${normalizedPath}:${contentHash}:ssr`;
+  return `${namespace}:${projectId}:${contentSourceId}:${normalizedPath}:${contentHash}:ssr`;
 }
 
 function formatMdxEsmPathCacheKey(namespace: string, normalizedPath: string): string {
@@ -24,6 +25,15 @@ function formatMdxEsmModuleFileName(namespace: string, contentHash: string): str
   return `vfmod-${namespace}-${contentHash}.mjs`;
 }
 
+function formatMdxEsmModuleRecoveryCacheKey(
+  namespace: string,
+  projectId: string,
+  contentSourceId: string,
+  fileName: string,
+): string {
+  return `${namespace}:${projectId}:${contentSourceId}:${fileName}:vfmod`;
+}
+
 function formatMdxJsxCacheFileName(namespace: string, filePath: string): string {
   return `jsx-${namespace}-${hashString(filePath)}.mjs`;
 }
@@ -42,11 +52,18 @@ function buildMdxEsmCacheSchemaSample() {
     transformKey: formatMdxEsmTransformCacheKey(
       CACHE_NAMESPACE_SENTINEL,
       "__vf_project__",
+      "preview-main",
       "_vf_modules/pages/index.js",
       "deadbeef",
     ),
     pathKey: formatMdxEsmPathCacheKey(CACHE_NAMESPACE_SENTINEL, "_vf_modules/pages/index.js"),
     moduleFile: formatMdxEsmModuleFileName(CACHE_NAMESPACE_SENTINEL, "deadbeef"),
+    moduleRecoveryKey: formatMdxEsmModuleRecoveryCacheKey(
+      CACHE_NAMESPACE_SENTINEL,
+      "__vf_project__",
+      "preview-main",
+      formatMdxEsmModuleFileName(CACHE_NAMESPACE_SENTINEL, "deadbeef"),
+    ),
     jsxFile: formatMdxJsxCacheFileName(CACHE_NAMESPACE_SENTINEL, "/tmp/project/Button.tsx"),
     unresolvedVfModulesPattern: UNRESOLVED_VF_MODULES_PATTERN.source,
     allFileUrlPattern: ALL_FILE_URL_PATTERN_SOURCE,
@@ -84,12 +101,14 @@ export const FRAMEWORK_VF_MODULE_CACHE_NAMESPACE = createCacheNamespace(
 
 export function buildMdxEsmTransformCacheKey(
   projectId: string,
+  contentSourceId: string,
   normalizedPath: string,
   contentHash: string,
 ): string {
   return formatMdxEsmTransformCacheKey(
     MDX_ESM_CACHE_NAMESPACE,
     projectId,
+    contentSourceId,
     normalizedPath,
     contentHash,
   );
@@ -103,6 +122,19 @@ export function buildMdxEsmModuleFileName(contentHash: string): string {
   return formatMdxEsmModuleFileName(MDX_ESM_CACHE_NAMESPACE, contentHash);
 }
 
+export function buildMdxEsmModuleRecoveryCacheKey(
+  projectId: string,
+  contentSourceId: string,
+  fileName: string,
+): string {
+  return formatMdxEsmModuleRecoveryCacheKey(
+    MDX_ESM_CACHE_NAMESPACE,
+    projectId,
+    contentSourceId,
+    fileName,
+  );
+}
+
 export function buildMdxJsxCacheFileName(filePath: string): string {
   return formatMdxJsxCacheFileName(MDX_ESM_CACHE_NAMESPACE, filePath);
 }

package/src/src/transforms/mdx/esm-module-loader/loader-helpers.ts

@@ -151,6 +151,7 @@ export async function processVfModuleImports(
     projectDir,
     context.projectId,
     {
+      contentSourceId: context.contentSourceId,
       reactVersion: context.reactVersion,
       projectSlug: context.projectSlug,
       logger: logger.child({

package/src/src/transforms/mdx/esm-module-loader/module-fetcher/cache-keys.ts

@@ -15,10 +15,11 @@ import { buildMdxEsmPathCacheKey, buildMdxEsmTransformCacheKey } from "../cache-
  */
 export function getTransformCacheKey(
   projectId: string,
+  contentSourceId: string,
   normalizedPath: string,
   contentHash: string,
 ): string {
-  return buildMdxEsmTransformCacheKey(projectId, normalizedPath, contentHash);
+  return buildMdxEsmTransformCacheKey(projectId, contentSourceId, normalizedPath, contentHash);
 }
 
 export function getVersionedPathCacheKey(normalizedPath: string): string {