veryfront 0.1.545 → 0.1.546

package/src/src/server/node-handler.ts

@@ -1,42 +0,0 @@
-import { serverLogger } from "../utils/index.js";
-
-export function toNodeHandler(
-  handler: (req: Request) => Promise<Response> | Response,
-): (req: import("node:http").IncomingMessage, res: import("node:http").ServerResponse) => void {
-  return async (req, res) => {
-    try {
-      const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
-      const headers: Record<string, string> = {};
-      for (const [key, value] of Object.entries(req.headers)) {
-        if (typeof value === "string") headers[key] = value;
-        else if (Array.isArray(value)) headers[key] = value[0] ?? "";
-      }
-      const method = req.method ?? "GET";
-      const body = method === "GET" || method === "HEAD" ? null : req;
-      const init: RequestInit & { duplex?: string } = {
-        method,
-        headers,
-        body: body as BodyInit | null,
-      };
-      if (body) init.duplex = "half";
-
-      const response = await handler(new Request(url.toString(), init));
-
-      if (response.status === 101) return;
-      res.writeHead(response.status, Object.fromEntries(response.headers));
-      if (response.body) {
-        const reader = response.body.getReader();
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          res.write(value);
-        }
-      }
-      res.end();
-    } catch (error) {
-      serverLogger.debug("toNodeHandler request failed", { error });
-      res.writeHead(500);
-      res.end("Internal Server Error");
-    }
-  };
-}

package/src/src/server/production-server.ts

@@ -1,466 +0,0 @@
-import { serverLogger as logger } from "../utils/index.js";
-import type { RuntimeAdapter } from "../platform/adapters/base.js";
-import { runtime } from "../platform/adapters/detect.js";
-import { createVeryfrontHandler } from "./runtime-handler/index.js";
-import { requestTracker } from "./runtime-handler/request-tracker.js";
-import { bootstrapProd, type BootstrapResult } from "./bootstrap.js";
-import { cwd, onGlobalError, onSignal } from "../platform/compat/process.js";
-import { isDebugEnabled } from "../utils/constants/env.js";
-import {
-  initializeOTLPWithApis,
-  shutdownOTLP,
-  withSpan,
-} from "../observability/tracing/otlp-setup.js";
-import {
-  getMemorySnapshot,
-  startMemoryMonitoring,
-  stopMemoryMonitoring,
-} from "../utils/memory/index.js";
-import { initializeDistributedCaches } from "../cache/distributed-cache-init.js";
-import { getConfig } from "../config/index.js";
-import { resolveStyleContentVersion } from "../html/styles-builder/content-version.js";
-import {
-  buildPreparedCSSArtifactFromFiles,
-  collectLocalProjectSourceFiles,
-  readLocalProjectStylesheet,
-} from "../html/styles-builder/css-pregeneration.js";
-import { createStyleScopeProfile } from "../html/styles-builder/style-scope-profile.js";
-import { setServerInitialized } from "./handlers/monitoring/health.handler.js";
-import {
-  enableSSRClientOnlyFetching,
-  enableSSRFetchInterception,
-  setSSRServerPort,
-} from "../rendering/ssr-globals.js";
-import type { FileSystemAdapter } from "../platform/adapters/base.js";
-
-const serverLog = logger.component("server");
-const globalLog = logger.component("global");
-
-/** Default interval for periodic memory usage snapshots */
-const DEFAULT_MEMORY_MONITORING_INTERVAL_MS = 30_000;
-
-/** Default time to wait for in-flight requests to drain during shutdown.
- *  K8s default terminationGracePeriodSeconds is 30s, so 25s leaves headroom. */
-const DEFAULT_SHUTDOWN_DRAIN_TIMEOUT_MS = 25_000;
-
-/** Default port when PORT / VERYFRONT_PORT env vars are not set */
-const DEFAULT_SERVER_PORT = 3_000;
-
-async function prewarmLocalProductionCSSArtifacts(
-  adapter: RuntimeAdapter,
-  options: Pick<
-    StartProductionServerOptions,
-    | "projectDir"
-    | "defaultProjectSlug"
-    | "defaultProjectId"
-    | "defaultEnvironment"
-    | "localProjects"
-  >,
-): Promise<void> {
-  if (options.defaultEnvironment !== "production") return;
-
-  const projectsToWarm = new Map<string, string>();
-
-  if (options.localProjects) {
-    for (const [projectSlug, projectDir] of Object.entries(options.localProjects)) {
-      projectsToWarm.set(projectSlug, projectDir);
-    }
-  }
-
-  if (options.defaultProjectSlug && options.projectDir) {
-    projectsToWarm.set(options.defaultProjectSlug, options.projectDir);
-  } else if (projectsToWarm.size === 0 && options.defaultProjectId && options.projectDir) {
-    projectsToWarm.set(options.defaultProjectId, options.projectDir);
-  }
-
-  if (projectsToWarm.size === 0) return;
-
-  await Promise.all([...projectsToWarm.entries()].map(async ([projectSlug, projectDir]) => {
-    try {
-      const config = await getConfig(projectDir, adapter, { cacheKey: projectSlug });
-      const styleProfile = createStyleScopeProfile(config);
-      const files = await collectLocalProjectSourceFiles({
-        projectDir,
-        styleProfile,
-      });
-      const stylesheet = await readLocalProjectStylesheet(projectDir, config?.tailwind?.stylesheet);
-
-      const result = await buildPreparedCSSArtifactFromFiles({
-        projectSlug,
-        projectVersion: resolveStyleContentVersion(null),
-        projectDir,
-        files,
-        styleProfile,
-        stylesheet,
-        stylesheetPath: config?.tailwind?.stylesheet,
-        minify: true,
-        environment: "preview",
-        buildMode: "production",
-      });
-
-      serverLog.debug("Prewarmed local production CSS artifact", {
-        projectSlug,
-        projectDir,
-        fileCount: files.length,
-        fromCache: result.fromCache,
-      });
-    } catch (error) {
-      serverLog.debug("Skipping local production CSS prewarm", {
-        projectSlug,
-        projectDir,
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-  }));
-}
-
-/** Configuration for AI primitives discovery during server startup */
-export interface DiscoveryOptions {
-  baseDir: string;
-  fsAdapter?: FileSystemAdapter;
-  /** For multi-project proxy mode: project slug for context scoping */
-  projectSlug?: string;
-  /** For multi-project proxy mode: API token for context scoping */
-  apiToken?: string;
-  verbose?: boolean;
-}
-
-interface ServerOptions {
-  projectDir: string;
-  port: number;
-  /** 0.0.0.0 = all interfaces, 127.0.0.1 = localhost only */
-  bindAddress?: string;
-  signal?: AbortSignal;
-  /** Default project slug when not provided via proxy headers (for tests/local mode) */
-  defaultProjectSlug?: string;
-  /** Default project ID when not provided via proxy headers (for tests/local mode) */
-  defaultProjectId?: string;
-  /** Default environment for standalone mode (preview or production). Defaults to preview for safety. */
-  defaultEnvironment?: "preview" | "production";
-  /**
-   * Optional request interceptor for combined mode.
-   * Transforms requests before they're processed by the core request handler.
-   * Used by proxy middleware to inject context headers in combined mode.
-   */
-  requestInterceptor?: (req: Request) => Request | Promise<Request>;
-  /** Discovery configuration for AI primitives. Runs discoverAll() before serving. */
-  discoveryConfig?: DiscoveryOptions;
-  /** Map of project slugs to their filesystem paths (seeds local project discovery). */
-  localProjects?: Record<string, string>;
-}
-
-export interface ServerHandle {
-  ready: Promise<void>;
-  stop: () => Promise<void>;
-}
-
-export interface StartProductionServerOptions extends ServerOptions {
-  debug?: boolean;
-  adapter?: RuntimeAdapter;
-  /** Pre-computed bootstrap result to skip internal bootstrap (avoids double initialization) */
-  bootstrapResult?: BootstrapResult;
-}
-
-export function startProductionServer(
-  options: StartProductionServerOptions,
-): Promise<ServerHandle> {
-  return withSpan(
-    "server.startProductionServer",
-    async () => {
-      const {
-        projectDir,
-        port,
-        bindAddress = "0.0.0.0",
-        signal,
-        debug,
-        defaultProjectSlug,
-        defaultProjectId,
-        defaultEnvironment,
-        requestInterceptor,
-        bootstrapResult,
-        discoveryConfig,
-        localProjects,
-      } = options;
-
-      const baseAdapter = options.adapter ?? (await runtime.get());
-
-      // Use pre-computed bootstrap result if provided, otherwise bootstrap here
-      const bootstrap = bootstrapResult ?? await bootstrapProd(projectDir, baseAdapter);
-      const adapter = bootstrap.adapter;
-
-      if (bootstrap.usingFSAdapter) {
-        logger.debug("FSAdapter initialized", { type: bootstrap.fsAdapterType });
-      }
-
-      await prewarmLocalProductionCSSArtifacts(bootstrap.adapter, {
-        projectDir,
-        defaultProjectSlug,
-        defaultProjectId,
-        defaultEnvironment,
-        localProjects,
-      });
-
-      // Enable SSR fetch interception to handle relative URLs during SSR
-      setSSRServerPort(port);
-      enableSSRFetchInterception();
-
-      // Enable client-only fetching for /api/* routes in production.
-      // This returns empty mock responses during SSR (instead of failing with
-      // "Invalid URL" or "Connection refused"). React Query will refetch
-      // the actual data client-side after hydration.
-      enableSSRClientOnlyFetching();
-
-      // Run primitive discovery before serving (registries must be populated before first request)
-      if (discoveryConfig) {
-        try {
-          const { discoverAll } = await import("../discovery/index.js");
-          const { isExtendedFSAdapter } = await import(
-            "../platform/adapters/fs/wrapper.js"
-          );
-
-          if (
-            discoveryConfig.projectSlug && discoveryConfig.apiToken &&
-            discoveryConfig.fsAdapter && isExtendedFSAdapter(discoveryConfig.fsAdapter) &&
-            discoveryConfig.fsAdapter.isMultiProjectMode()
-          ) {
-            // Multi-project proxy: scope discovery to specific project
-            await discoveryConfig.fsAdapter.runWithContext(
-              discoveryConfig.projectSlug,
-              discoveryConfig.apiToken,
-              () =>
-                discoverAll({
-                  baseDir: discoveryConfig.baseDir,
-                  fsAdapter: discoveryConfig.fsAdapter,
-                  verbose: discoveryConfig.verbose ?? false,
-                }),
-            );
-          } else {
-            await discoverAll({
-              baseDir: discoveryConfig.baseDir,
-              fsAdapter: discoveryConfig.fsAdapter,
-              verbose: discoveryConfig.verbose ?? false,
-            });
-          }
-        } catch (error) {
-          serverLog.error("Primitive discovery failed", {
-            error: error instanceof Error ? error.message : String(error),
-          });
-        }
-      }
-
-      logger.info("Starting production server", { projectDir, port, bindAddress });
-
-      const baseHandler = createVeryfrontHandler(projectDir, adapter, {
-        projectDir,
-        debug,
-        config: bootstrap.config,
-        defaultProjectSlug,
-        defaultProjectId,
-        defaultEnvironment,
-        localProjects,
-      });
-
-      // Wrap handler with interceptor if provided (for combined mode)
-      // WebSocket upgrade requests MUST NOT be intercepted because the interceptor
-      // creates a new Request object, which breaks Deno.upgradeWebSocket()
-      const handler = requestInterceptor
-        ? Object.assign(
-          async (req: Request) => {
-            const isWebSocketUpgrade = req.headers.get("upgrade")?.toLowerCase() === "websocket";
-            if (isWebSocketUpgrade) return baseHandler(req);
-            return baseHandler(await requestInterceptor(req));
-          },
-          { ready: baseHandler.ready },
-        )
-        : baseHandler;
-
-      let resolveListenReady: (() => void) | undefined;
-      const listenReady = new Promise<void>((resolve) => {
-        resolveListenReady = resolve;
-      });
-
-      const ready = (async () => {
-        await Promise.all([listenReady, handler.ready ?? Promise.resolve()]);
-        // Mark server as initialized when ready resolves
-        setServerInitialized(true);
-      })();
-
-      const server = await adapter.serve(handler, {
-        port,
-        hostname: bindAddress, // Deno uses "hostname" for bind address
-        signal,
-        onListen: (params) => {
-          resolveListenReady?.();
-          logger.info("Production server listening", params);
-        },
-      });
-
-      async function stop(): Promise<void> {
-        setServerInitialized(false);
-
-        try {
-          await server.stop();
-        } catch (error) {
-          logger.debug("Server stop failed", { error });
-        }
-      }
-
-      return { ready, stop };
-    },
-    { "server.port": options.port, "server.bindAddress": options.bindAddress ?? "0.0.0.0" },
-  );
-}
-
-if (import.meta.main) {
-  // Register global error handlers FIRST to prevent process crashes from application errors
-  // This ensures the renderer stays up even if user code throws unhandled exceptions
-  onGlobalError((error, type) => {
-    // Fatal errors that indicate corrupted process state — let the process crash
-    // so the orchestrator (k8s) can restart it cleanly
-    const isFatal = (error.name === "RangeError" && error.message.includes("Maximum call stack")) ||
-      error.message.includes("out of memory") ||
-      error.message.includes("allocation failed");
-
-    globalLog.error(`${type}: Application error caught`, {
-      message: error.message,
-      stack: error.stack,
-      type,
-      fatal: isFatal,
-    });
-
-    if (isFatal) {
-      globalLog.error("Fatal error detected, allowing process exit for clean restart");
-      return false;
-    }
-
-    // Non-fatal: prevent process exit — individual requests may fail but service stays up
-    return true;
-  });
-
-  try {
-    // Initialize OpenTelemetry tracing and distributed caches in parallel
-    // Both can fail independently without blocking the other
-    // Backend: API (production) > Redis (local dev) > Memory (fallback)
-    const [otlpResult, cacheResult] = await Promise.allSettled([
-      initializeOTLPWithApis(),
-      initializeDistributedCaches(),
-    ]);
-
-    if (otlpResult.status === "rejected") {
-      logger.warn("OTLP initialization failed, continuing without tracing", {
-        error: otlpResult.reason,
-      });
-    }
-
-    if (cacheResult.status === "rejected") {
-      logger.warn("Distributed cache initialization failed, using memory fallback", {
-        error: cacheResult.reason,
-      });
-    }
-
-    const adapter = await runtime.get();
-
-    // Start memory monitoring if enabled
-    const enableMemoryMonitoring = adapter.env.get("ENABLE_MEMORY_MONITORING") === "true";
-    const monitoringIntervalMs = parseInt(
-      adapter.env.get("MEMORY_MONITORING_INTERVAL_MS") ??
-        String(DEFAULT_MEMORY_MONITORING_INTERVAL_MS),
-      10,
-    );
-
-    if (enableMemoryMonitoring) {
-      startMemoryMonitoring(monitoringIntervalMs);
-      logger.debug("Memory monitoring enabled", { intervalMs: monitoringIntervalMs });
-
-      // Log initial memory state
-      const initialSnapshot = getMemorySnapshot();
-      logger.debug("Initial memory state", {
-        heapUsedMB: initialSnapshot.heap.usedHeapSizeMB,
-        heapLimitMB: initialSnapshot.heap.heapSizeLimitMB,
-        cacheCount: initialSnapshot.caches.length,
-      });
-    }
-
-    const shutdownController = new AbortController();
-    const projectDir = cwd();
-    const port = Number(
-      adapter.env.get("PORT") ?? adapter.env.get("VERYFRONT_PORT") ?? DEFAULT_SERVER_PORT,
-    );
-    // BIND_ADDRESS: 0.0.0.0 = all interfaces, 127.0.0.1 = localhost only
-    // Note: Don't use HOSTNAME - K8s sets it to pod name which resolves to pod IP
-    const bindAddress = adapter.env.get("BIND_ADDRESS") ?? "0.0.0.0";
-
-    const bootstrap = await bootstrapProd(projectDir, adapter);
-
-    const server = await startProductionServer({
-      projectDir,
-      port,
-      bindAddress,
-      debug: isDebugEnabled(adapter.env),
-      adapter, // Pass adapter to avoid re-detection
-      bootstrapResult: bootstrap,
-      signal: shutdownController.signal,
-    });
-
-    // Wait for server to be fully ready before accepting traffic
-    // This prevents K8s readiness probe from passing too early
-    // Note: setServerInitialized(true) is called inside ready promise
-    await server.ready;
-    logger.info("Server fully initialized, ready to accept traffic");
-
-    // Graceful shutdown for direct CLI execution (e.g., deno run)
-    // Default drain timeout: 25 seconds (K8s default terminationGracePeriodSeconds is 30)
-    const drainTimeoutMs = parseInt(
-      adapter.env.get("SHUTDOWN_DRAIN_TIMEOUT_MS") ?? String(DEFAULT_SHUTDOWN_DRAIN_TIMEOUT_MS),
-      10,
-    );
-
-    let shuttingDown = false;
-    const shutdown = async (signal: "SIGINT" | "SIGTERM"): Promise<void> => {
-      if (shuttingDown) return;
-      shuttingDown = true;
-
-      logger.info(`Received ${signal}, initiating graceful shutdown...`, {
-        inFlightRequests: requestTracker.getInFlightCount(),
-        drainTimeoutMs,
-      });
-
-      // Phase 1: Mark server as not ready to stop K8s from routing new requests
-      setServerInitialized(false);
-      logger.info("Server marked as not ready, waiting for in-flight requests to drain...");
-
-      try {
-        // Phase 2: Wait for in-flight requests to complete (graceful drain)
-        const drained = await requestTracker.waitForDrain(drainTimeoutMs);
-        if (!drained) {
-          logger.warn("Drain timeout exceeded, forcing shutdown", {
-            remainingRequests: requestTracker.getInFlightCount(),
-          });
-        }
-
-        // Phase 3: Stop accepting new connections and clean up
-        stopMemoryMonitoring();
-        requestTracker.shutdown();
-        await bootstrap.dispose?.();
-        shutdownController.abort();
-        await server.stop();
-        await shutdownOTLP();
-
-        logger.info("Graceful shutdown complete");
-      } catch (error) {
-        logger.warn("Error while shutting down production server:", error);
-      }
-    };
-
-    const handleSignal = (signal: "SIGINT" | "SIGTERM"): void => {
-      void shutdown(signal).catch((error) => {
-        logger.warn("Unhandled error while shutting down production server", { signal, error });
-      });
-    };
-
-    onSignal("SIGINT", () => handleSignal("SIGINT"));
-    onSignal("SIGTERM", () => handleSignal("SIGTERM"));
-  } catch (e) {
-    logger.error("Failed to start production server:", e);
-  }
-}

package/src/src/server/project-env/cache.ts

@@ -1,101 +0,0 @@
-/**
- * In-memory cache for project environment variables with TTL and request deduplication.
- *
- * @module server/project-env/cache
- */
-
-interface CacheEntry {
-  vars: Record<string, string>;
-  fetchedAt: number;
-}
-
-type Fetcher = (
-  environmentId: string,
-  token: string,
-  projectSlug: string,
-) => Promise<Record<string, string>>;
-
-/** Max number of environments to cache. Evicts oldest entry when exceeded. */
-const DEFAULT_MAX_ENTRIES = 100;
-
-export class EnvironmentVariableCache {
-  private cache = new Map<string, CacheEntry>();
-  private inflight = new Map<string, Promise<Record<string, string>>>();
-  private fetcher: Fetcher;
-  private ttlMs: number;
-  private maxEntries: number;
-
-  constructor(fetcher: Fetcher, ttlMs = 60_000, maxEntries = DEFAULT_MAX_ENTRIES) {
-    this.fetcher = fetcher;
-    this.ttlMs = ttlMs;
-    this.maxEntries = maxEntries;
-  }
-
-  async get(
-    environmentId: string,
-    token: string,
-    projectSlug: string,
-  ): Promise<Record<string, string>> {
-    const cached = this.cache.get(environmentId);
-    const now = Date.now();
-
-    if (cached && now - cached.fetchedAt < this.ttlMs) {
-      return cached.vars;
-    }
-
-    // Deduplicate concurrent fetches for the same environment
-    const existing = this.inflight.get(environmentId);
-    if (existing) return existing;
-
-    const promise = this.fetch(environmentId, token, projectSlug, cached);
-    this.inflight.set(environmentId, promise);
-
-    try {
-      return await promise;
-    } finally {
-      this.inflight.delete(environmentId);
-    }
-  }
-
-  invalidate(environmentId?: string): void {
-    if (environmentId) {
-      this.cache.delete(environmentId);
-    } else {
-      this.cache.clear();
-    }
-  }
-
-  private async fetch(
-    environmentId: string,
-    token: string,
-    projectSlug: string,
-    stale: CacheEntry | undefined,
-  ): Promise<Record<string, string>> {
-    try {
-      const vars = await this.fetcher(environmentId, token, projectSlug);
-      // Delete before set to move refreshed entries to the end of Map iteration order,
-      // ensuring eviction targets the least-recently-fetched entry (LRU behavior).
-      this.cache.delete(environmentId);
-      this.cache.set(environmentId, { vars, fetchedAt: Date.now() });
-      this.evictIfNeeded();
-      return vars;
-    } catch (_) {
-      /* expected: stale-on-error fallback when fetch fails */
-      if (stale) return stale.vars;
-      return {};
-    }
-  }
-
-  /** Evict oldest entries when cache exceeds maxEntries. */
-  private evictIfNeeded(): void {
-    if (this.cache.size <= this.maxEntries) return;
-    // Map iterates in insertion order; delete the first (oldest) entries
-    const excess = this.cache.size - this.maxEntries;
-    let removed = 0;
-    for (const key of this.cache.keys()) {
-      if (removed >= excess) break;
-      this.cache.delete(key);
-      removed++;
-    }
-  }
-}

package/src/src/server/project-env/fetcher.ts

@@ -1,80 +0,0 @@
-/**
- * Fetches project environment variables from the Veryfront API.
- *
- * @module server/project-env/fetcher
- */
-
-import { getBaseLogger } from "../../utils/logger/logger.js";
-import { NETWORK_ERROR } from "../../errors/index.js";
-
-const baseLogger = getBaseLogger("PROJECT-ENV");
-
-const logger = baseLogger.component("project-env");
-
-/** Max env vars per request. API enforces a hard cap of 100. */
-const ENV_VARS_FETCH_LIMIT = 100;
-
-/**
- * Fetch environment variables for a project from the Veryfront API.
- *
- * Calls: GET {apiBaseUrl}/projects/{projectSlug}/env-vars?environment_id={environmentId}&limit=100
- * Response: { data: [{ key: string, value: string }] }
- */
-export async function fetchProjectEnvVars(
-  apiBaseUrl: string,
-  projectSlug: string,
-  environmentId: string,
-  token: string,
-): Promise<Record<string, string>> {
-  const url = `${apiBaseUrl}/projects/${encodeURIComponent(projectSlug)}/env-vars?environment_id=${
-    encodeURIComponent(environmentId)
-  }&limit=${ENV_VARS_FETCH_LIMIT}`;
-
-  try {
-    const response = await fetch(url, {
-      headers: {
-        Authorization: `Bearer ${token}`,
-        Accept: "application/json",
-      },
-    });
-
-    if (!response.ok) {
-      await response.body?.cancel();
-      logger.warn("Failed to fetch env vars", {
-        projectSlug,
-        environmentId,
-        status: response.status,
-      });
-      throw NETWORK_ERROR.create({ detail: `Failed to fetch env vars: ${response.status}` });
-    }
-
-    const body = await response.json() as {
-      data?: Array<{ key: string; value: string }>;
-    };
-
-    const result: Record<string, string> = {};
-    if (body.data) {
-      for (const entry of body.data) {
-        result[entry.key] = entry.value;
-      }
-    }
-
-    logger.debug("Fetched env vars", {
-      projectSlug,
-      environmentId,
-      count: Object.keys(result).length,
-    });
-
-    return result;
-  } catch (error) {
-    if (error instanceof Error && error.message.startsWith("Failed to fetch env vars")) {
-      throw error;
-    }
-    logger.error("Env var fetch error", {
-      projectSlug,
-      environmentId,
-      error: error instanceof Error ? error.message : String(error),
-    });
-    throw error;
-  }
-}

package/src/src/server/project-env/index.ts

@@ -1,9 +0,0 @@
-/**
- * Server Project Env
- *
- * @module server/project-env
- */
-
-export { getProjectEnv, isProjectEnvActive, runWithProjectEnv } from "./storage.js";
-export { EnvironmentVariableCache } from "./cache.js";
-export { fetchProjectEnvVars } from "./fetcher.js";