veryfront 0.1.324 → 0.1.327

package/src/src/modules/module-resolver.ts

@@ -0,0 +1,145 @@
+import { serverLogger as logger } from "../utils/index.js";
+import { dirname, isAbsolute, join, normalize, relative } from "../platform/compat/path/index.js";
+import type { RuntimeAdapter } from "../platform/adapters/base.js";
+import { buildModuleResolveCacheKey } from "../cache/keys.js";
+import { withSpan } from "../observability/tracing/otlp-setup.js";
+import { LRUCache } from "../utils/lru-wrapper.js";
+import { registerLRUCache } from "../cache/index.js";
+import { CACHE_MAX_ENTRIES_LARGE } from "../utils/constants/limits.js";
+
+export interface ResolvedModule {
+  path: string;
+  type: "file" | "virtual" | "external" | "npm";
+  content?: string;
+  transformed?: boolean;
+}
+
+export interface ModuleResolverOptions {
+  projectDir: string;
+  importMap?: Record<string, string>;
+  virtualModules?: Map<string, string>;
+  adapter: RuntimeAdapter;
+  cacheSize?: number;
+}
+
+const MODULE_EXTENSIONS = ["", ".ts", ".tsx", ".js", ".jsx", ".mjs"];
+
+export class ModuleResolver {
+  private importMap: Record<string, string>;
+  private virtualModules: Map<string, string>;
+  private cache: LRUCache<string, ResolvedModule>;
+  private adapter: RuntimeAdapter;
+
+  constructor(private options: ModuleResolverOptions) {
+    this.adapter = options.adapter;
+    this.importMap = options.importMap ?? {};
+    this.virtualModules = options.virtualModules ?? new Map();
+    this.cache = new LRUCache<string, ResolvedModule>({
+      maxEntries: options.cacheSize ?? CACHE_MAX_ENTRIES_LARGE,
+    });
+
+    // Register cache for monitoring
+    registerLRUCache(`module-resolver:${options.projectDir}`, this.cache);
+  }
+
+  private cacheAndReturn(cacheKey: string, resolved: ResolvedModule): ResolvedModule {
+    this.cache.set(cacheKey, resolved);
+    return resolved;
+  }
+
+  resolve(specifier: string, referrer?: string): Promise<ResolvedModule | null> {
+    return withSpan(
+      "modules.resolver.resolve",
+      async () => {
+        const cacheKey = buildModuleResolveCacheKey(specifier, referrer);
+        const cached = this.cache.get(cacheKey);
+        if (cached) return cached;
+
+        logger.debug(`Resolving module: ${specifier} from ${referrer ?? "root"}`);
+
+        const virtualContent = this.virtualModules.get(specifier);
+        if (virtualContent !== undefined) {
+          return this.cacheAndReturn(cacheKey, {
+            path: specifier,
+            type: "virtual",
+            content: virtualContent,
+            transformed: true,
+          });
+        }
+
+        const mapped = this.importMap[specifier];
+        if (mapped) {
+          if (mapped.startsWith("http://") || mapped.startsWith("https://")) {
+            return this.cacheAndReturn(cacheKey, { path: mapped, type: "external" });
+          }
+          specifier = mapped;
+        }
+
+        if (specifier.startsWith("./") || specifier.startsWith("../")) {
+          const refPath = referrer
+            ? isAbsolute(referrer) ? referrer : join(this.options.projectDir, referrer)
+            : undefined;
+
+          const basePath = refPath ? dirname(refPath) : this.options.projectDir;
+          const fullPath = normalize(join(basePath, specifier));
+
+          for (const ext of MODULE_EXTENSIONS) {
+            const pathWithExt = fullPath + ext;
+            if (await this.adapter.fs.exists(pathWithExt)) {
+              return this.cacheAndReturn(cacheKey, { path: pathWithExt, type: "file" });
+            }
+          }
+
+          return null;
+        }
+
+        if (specifier.startsWith("/")) {
+          const fullPath = join(this.options.projectDir, specifier);
+          const relativePath = relative(this.options.projectDir, fullPath);
+
+          if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
+            logger.warn(`Path traversal attempt blocked: ${specifier}`);
+            return null;
+          }
+
+          if (await this.adapter.fs.exists(fullPath)) {
+            return this.cacheAndReturn(cacheKey, { path: fullPath, type: "file" });
+          }
+
+          return null;
+        }
+
+        if (!specifier.startsWith(".")) {
+          return this.cacheAndReturn(cacheKey, {
+            path: `https://esm.sh/${specifier}`,
+            type: "npm",
+          });
+        }
+
+        return null;
+      },
+      { "resolver.specifier": specifier, "resolver.referrer": referrer ?? "root" },
+    );
+  }
+
+  clearCache(pattern?: string): void {
+    if (!pattern) {
+      this.cache.clear();
+      return;
+    }
+
+    for (const key of [...this.cache.keys()]) {
+      if (key.includes(pattern)) this.cache.delete(key);
+    }
+  }
+
+  addVirtualModule(path: string, content: string): void {
+    this.virtualModules.set(path, content);
+    this.clearCache(path);
+  }
+
+  removeVirtualModule(path: string): void {
+    this.virtualModules.delete(path);
+    this.clearCache(path);
+  }
+}

package/src/src/rendering/cleanup.ts

@@ -0,0 +1,27 @@
+/**
+ * Cleanup bundler and related caches
+ *
+ * Clears renderer caches and handlers for test and runtime cleanup.
+ */
+export async function cleanupBundler(): Promise<void> {
+  const { clearMDXRendererCache } = await import("../transforms/mdx/index.js");
+  clearMDXRendererCache();
+
+  const { clearMDXModuleCache } = await import("./ssr/index.js");
+  clearMDXModuleCache();
+
+  const { clearSSRModuleCache } = await import("../modules/index.js");
+  clearSSRModuleCache();
+
+  const { destroyRendererAdapter } = await import("../server/shared/index.js");
+  await destroyRendererAdapter();
+
+  try {
+    const { __destroyRSCHandlerForTests } = await import(
+      "../server/services/rsc/endpoints/handler-registry.js"
+    );
+    __destroyRSCHandlerForTests();
+  } catch (_) {
+    /* expected: RSC handler registry might not be loaded */
+  }
+}

package/src/src/rendering/ssr/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Rendering Ssr
+ *
+ * @module rendering/ssr
+ */
+
+export type { MDXModule, MDXRenderOptions } from "./types.js";
+export { clearMDXModuleCache, loadMDXModule } from "./mdx-module-loader.js";
+export { renderMDXToReactAsync } from "./mdx-renderer.js";
+export { ComponentRegistry } from "./component-registry.js";

package/src/src/rendering/ssr/mdx-module-loader.ts

@@ -0,0 +1,185 @@
+import * as dntShim from "../../../_dnt.shims.js";
+import { getCacheNamespace } from "../../utils/cache/keys/namespace.js";
+import { COMPILATION_ERROR, wrapWithContext } from "../../errors/index.js";
+// Direct import from registry.ts to avoid circular dependency through barrel
+import { getLocalAdapter, runtime } from "../../platform/adapters/registry.js";
+import { rendererLogger } from "../../utils/index.js";
+import { LRUCache } from "../../utils/lru-wrapper.js";
+import { registerCache } from "../../utils/memory/index.js";
+import { MDX_RENDERER_MAX_ENTRIES, MDX_RENDERER_TTL_MS } from "../../utils/constants/cache.js";
+import { isBrowserEnvironment } from "../../platform/compat/runtime.js";
+import type { MDXModule } from "./types.js";
+
+const logger = rendererLogger.component("mdx");
+
+const MDX_CACHE_CLEANUP_INTERVAL_MS = 60_000;
+
+const mdxModuleCache = new LRUCache<string, MDXModule>({
+  maxEntries: MDX_RENDERER_MAX_ENTRIES,
+  ttlMs: MDX_RENDERER_TTL_MS,
+  cleanupIntervalMs: MDX_CACHE_CLEANUP_INTERVAL_MS,
+});
+
+registerCache("mdx-module-cache", () => ({
+  name: "mdx-module-cache",
+  entries: mdxModuleCache.size,
+  maxEntries: MDX_RENDERER_MAX_ENTRIES,
+}));
+
+export function clearMDXModuleCache(): void {
+  mdxModuleCache.clear();
+}
+
+function validateMDXModule(module: MDXModule, context: Record<string, unknown>): void {
+  const MDXContent = module.default || module.MDXContent;
+  if (MDXContent) return;
+  throw COMPILATION_ERROR.create({
+    detail: "No default export found in MDX module",
+    context,
+  });
+}
+
+function getNamespacedKey(suffix: string): string {
+  return `${getCacheNamespace() ?? "default"}:${suffix}`;
+}
+
+export async function loadMDXModule(modulePath: string): Promise<MDXModule> {
+  try {
+    const key = getNamespacedKey(modulePath);
+    const cached = mdxModuleCache.get(key);
+    if (cached) return cached;
+
+    const module = (await import(modulePath)) as MDXModule;
+    validateMDXModule(module, { modulePath });
+    mdxModuleCache.set(key, module);
+
+    return module;
+  } catch (error) {
+    throw wrapWithContext(error, `Failed to load MDX module: ${modulePath}`, { modulePath });
+  }
+}
+
+export async function loadCompiledMDXModule(
+  compiledCode: string,
+  cacheKey: string,
+): Promise<MDXModule> {
+  try {
+    const key = getNamespacedKey(`compiled:${cacheKey}`);
+    const cached = mdxModuleCache.get(key);
+    if (cached) return cached;
+
+    if (isBrowserEnvironment()) {
+      return await loadViaBlobURL(compiledCode, cacheKey, key);
+    }
+
+    return await loadViaTempFile(compiledCode, cacheKey, key);
+  } catch (error) {
+    throw wrapWithContext(error, "Failed to load compiled MDX module", { cacheKey });
+  }
+}
+
+async function loadAndCacheModule(
+  modulePath: string,
+  key: string,
+  context: Record<string, unknown>,
+): Promise<MDXModule> {
+  const module = (await import(modulePath)) as MDXModule;
+  validateMDXModule(module, context);
+  mdxModuleCache.set(key, module);
+  return module;
+}
+
+async function loadViaTempFile(
+  compiledCode: string,
+  cacheKey: string,
+  key: string,
+): Promise<MDXModule> {
+  const tempModulePath = await writeTempMDXModule(compiledCode, cacheKey);
+
+  try {
+    return await loadAndCacheModule(tempModulePath, key, {
+      cacheKey,
+      codePreview: compiledCode.substring(0, 200),
+    });
+  } finally {
+    cleanupTempModule(tempModulePath).catch((error) =>
+      logger.debug("Failed to cleanup temp module:", error)
+    );
+  }
+}
+
+async function loadViaBlobURL(
+  compiledCode: string,
+  cacheKey: string,
+  key: string,
+): Promise<MDXModule> {
+  const moduleCode = wrapAsESMModule(compiledCode);
+  const blob = new Blob([moduleCode], { type: "application/javascript" });
+  const blobURL = URL.createObjectURL(blob);
+
+  try {
+    return await loadAndCacheModule(blobURL, key, {
+      cacheKey,
+      codePreview: compiledCode.substring(0, 200),
+    });
+  } finally {
+    URL.revokeObjectURL(blobURL);
+  }
+}
+
+async function writeTempMDXModule(compiledCode: string, cacheKey: string): Promise<string> {
+  const tempDir = await ensureTempDir();
+
+  const safeKey = cacheKey.replace(/[^a-zA-Z0-9-_]/g, "_").substring(0, 50);
+  const uniqueId = dntShim.crypto.randomUUID().slice(0, 8);
+  const filename = `mdx-${safeKey}-${uniqueId}.mjs`;
+  const modulePath = `${tempDir}/${filename}`;
+  const moduleCode = wrapAsESMModule(compiledCode);
+
+  const localAdapter = await getLocalAdapter();
+  await localAdapter.fs.writeFile(modulePath, moduleCode);
+
+  return modulePath;
+}
+
+function wrapAsESMModule(compiledCode: string): string {
+  const imports = `
+import * as React from 'react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+const _jsx = jsx;
+const _jsxs = jsxs;
+const _jsxDEV = jsx;
+const _Fragment = Fragment;
+`.trim();
+
+  return `${imports}\n\n${compiledCode}`;
+}
+
+async function ensureTempDir(): Promise<string> {
+  const adapter = await runtime.get();
+  const { cwd } = await import("../../platform/compat/process.js");
+  const tempDir = `${cwd()}/.veryfront/temp/mdx-modules`;
+
+  try {
+    if (await adapter.fs.exists(tempDir)) return tempDir;
+    await adapter.fs.mkdir(tempDir, { recursive: true });
+    return tempDir;
+  } catch (error) {
+    logger.warn("Failed to create temp directory, using system temp:", error);
+    const os = await import("node:os");
+    const path = await import("node:path");
+    const systemTempDir = path.join(os.tmpdir(), `veryfront-mdx-${Date.now()}`);
+    await adapter.fs.mkdir(systemTempDir, { recursive: true });
+    return systemTempDir;
+  }
+}
+
+async function cleanupTempModule(modulePath: string): Promise<void> {
+  try {
+    const adapter = await runtime.get();
+    await adapter.fs.remove(modulePath);
+  } catch (_) {
+    /* expected: best-effort cleanup of temp module */
+  }
+}

package/src/src/rendering/ssr/mdx-renderer.ts

@@ -0,0 +1,66 @@
+import { COMPILATION_ERROR } from "../../errors/index.js";
+import { withSpan } from "../../observability/tracing/otlp-setup.js";
+import { computeHash, rendererLogger } from "../../utils/index.js";
+import * as React from "react";
+import { loadCompiledMDXModule } from "./mdx-module-loader.js";
+import type { MDXRenderOptions } from "./types.js";
+
+const logger = rendererLogger.component("mdx");
+
+export function renderMDXToReactAsync(
+  compiledCode: string,
+  options: MDXRenderOptions = {},
+): Promise<React.ReactElement> {
+  return withSpan(
+    "mdx.renderToReact",
+    async (): Promise<React.ReactElement> => {
+      try {
+        const cacheKey = (await computeHash(compiledCode)).slice(0, 16);
+        const module = await loadCompiledMDXModule(compiledCode, cacheKey);
+
+        const MDXContent = module.default ?? module.MDXContent;
+        if (!MDXContent) {
+          throw COMPILATION_ERROR.create({ detail: "No MDXContent found in compiled module" });
+        }
+
+        if (React.isValidElement(MDXContent)) {
+          return MDXContent;
+        }
+
+        const mergedProps: Record<string, unknown> = {
+          ...options,
+          frontmatter: {
+            ...(module.frontmatter ?? {}),
+            ...(options.frontmatter ?? {}),
+          },
+        };
+
+        return React.createElement(
+          MDXContent as React.ComponentType<Record<string, unknown>>,
+          mergedProps,
+        );
+      } catch (error) {
+        logger.error("Render error:", error);
+        return createErrorElement(error);
+      }
+    },
+    {},
+  );
+}
+
+function createErrorElement(error: unknown): React.ReactElement {
+  return React.createElement(
+    "div",
+    {
+      style: {
+        padding: "1rem",
+        backgroundColor: "#fef2f2",
+        border: "1px solid #fecaca",
+        borderRadius: "0.375rem",
+        color: "#dc2626",
+      },
+    },
+    React.createElement("strong", {}, "MDX Render Error: "),
+    error instanceof Error ? error.message : String(error),
+  );
+}

package/src/src/rendering/ssr/types.ts

@@ -0,0 +1,14 @@
+import type * as React from "react";
+
+export interface MDXRenderOptions {
+  frontmatter?: Record<string, unknown>;
+  components?: Record<string, React.ComponentType<unknown>>;
+  globals?: Record<string, unknown>;
+  pageConfig?: Record<string, unknown>;
+}
+
+export interface MDXModule {
+  default?: React.ComponentType<unknown>;
+  MDXContent?: React.ComponentType<unknown>;
+  frontmatter?: Record<string, unknown>;
+}

package/src/src/sandbox/index.ts

@@ -39,3 +39,12 @@ export {
   type LazySandboxOptions,
   resolveDefaultSandboxRuntimeEndpoint,
 } from "./lazy-sandbox.js";
+export {
+  type BashToolSandboxLike,
+  type CreateSandboxBashTool,
+  createSandboxShellTools,
+  normalizeBashToolSet,
+  renameSandboxFileTools,
+  type SandboxShellToolDefinition,
+  type SandboxShellToolSet,
+} from "./shell-tools.js";