veryfront 0.0.73 → 0.0.74

package/dist/config.js

@@ -6,6 +6,7 @@ var __esm = (fn, res) => function __init() {
 // src/_shims/deno-env.ts
 var init_deno_env = __esm({
   "src/_shims/deno-env.ts"() {
+    "use strict";
     globalThis.Deno = globalThis.Deno || {
       env: {
         get(key) {
@@ -65,6 +66,9 @@ var veryfrontConfigSchema = z.object({
   }).partial().optional(),
   router: z.enum(["app", "pages"]).optional(),
   defaultLayout: z.string().optional(),
+  layout: z.string().optional(),
+  provider: z.string().optional(),
+  app: z.string().optional(),
   theme: z.object({ colors: z.record(z.string()).optional() }).partial().optional(),
   build: z.object({
     outDir: z.string().optional(),
@@ -160,6 +164,8 @@ var veryfrontConfigSchema = z.object({
       apiBaseUrl: z.string().url(),
       apiToken: z.string(),
       projectSlug: z.string(),
+      proxyMode: z.boolean().optional(),
+      productionMode: z.boolean().optional(),
       cache: z.object({
         enabled: z.boolean().optional(),
         ttl: z.number().int().positive().optional(),
@@ -221,6 +227,9 @@ function findUnknownTopLevelKeys(input) {
     "experimental",
     "router",
     "defaultLayout",
+    "layout",
+    "provider",
+    "app",
     "theme",
     "build",
     "cache",
@@ -238,7 +247,7 @@ function findUnknownTopLevelKeys(input) {
 }
 
 // src/core/config/loader.ts
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 
 // src/core/utils/logger/logger.ts
 init_deno_env();
@@ -271,56 +280,158 @@ function getEnvironmentVariable(name) {
   }
   return void 0;
 }
+function isProductionEnvironment() {
+  return getEnvironmentVariable("NODE_ENV") === "production";
+}
 
 // src/core/utils/logger/logger.ts
 var cachedLogLevel;
+var cachedLogFormat;
 function resolveLogLevel(force = false) {
   if (force || cachedLogLevel === void 0) {
     cachedLogLevel = getDefaultLevel();
   }
   return cachedLogLevel;
 }
-var ConsoleLogger = class {
-  constructor(prefix, level = resolveLogLevel()) {
+function resolveLogFormat(force = false) {
+  if (force || cachedLogFormat === void 0) {
+    cachedLogFormat = getDefaultFormat();
+  }
+  return cachedLogFormat;
+}
+function getDefaultFormat() {
+  const envFormat = getEnvironmentVariable("LOG_FORMAT");
+  if (envFormat === "json" || envFormat === "text") {
+    return envFormat;
+  }
+  return isProductionEnvironment() ? "json" : "text";
+}
+function serializeError(err) {
+  if (err instanceof Error) {
+    return {
+      name: err.name,
+      message: err.message,
+      stack: err.stack
+    };
+  }
+  if (err !== void 0 && err !== null) {
+    return {
+      name: "UnknownError",
+      message: String(err)
+    };
+  }
+  return void 0;
+}
+function extractContext(args) {
+  let context;
+  let error;
+  for (const arg of args) {
+    if (arg instanceof Error) {
+      error = serializeError(arg);
+    } else if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
+      context = { ...context, ...arg };
+    }
+  }
+  return { context, error };
+}
+var ConsoleLogger = class _ConsoleLogger {
+  constructor(prefix, level = resolveLogLevel(), format = resolveLogFormat(), boundContext) {
     this.prefix = prefix;
     this.level = level;
+    this.format = format;
+    if (boundContext) {
+      this.boundContext = boundContext;
+    }
   }
+  boundContext = {};
   setLevel(level) {
     this.level = level;
   }
   getLevel() {
     return this.level;
   }
-  debug(message, ...args) {
-    if (this.level <= 0 /* DEBUG */) {
-      console.debug(`[${this.prefix}] DEBUG: ${message}`, ...args);
+  setFormat(format) {
+    this.format = format;
+  }
+  getFormat() {
+    return this.format;
+  }
+  /**
+   * Create a child logger with additional bound context.
+   */
+  child(context) {
+    return new _ConsoleLogger(this.prefix, this.level, this.format, {
+      ...this.boundContext,
+      ...context
+    });
+  }
+  formatJson(level, message, args) {
+    const { context, error } = extractContext(args);
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      service: this.prefix.toLowerCase(),
+      message
+    };
+    const mergedContext = { ...this.boundContext, ...context };
+    if (Object.keys(mergedContext).length > 0) {
+      if ("requestId" in mergedContext) {
+        entry.requestId = String(mergedContext.requestId);
+        delete mergedContext.requestId;
+      }
+      if ("traceId" in mergedContext) {
+        entry.traceId = String(mergedContext.traceId);
+        delete mergedContext.traceId;
+      }
+      if ("projectSlug" in mergedContext) {
+        entry.projectSlug = String(mergedContext.projectSlug);
+        delete mergedContext.projectSlug;
+      }
+      if ("durationMs" in mergedContext) {
+        entry.durationMs = Number(mergedContext.durationMs);
+        delete mergedContext.durationMs;
+      }
+      if (Object.keys(mergedContext).length > 0) {
+        entry.context = mergedContext;
+      }
     }
+    if (error) {
+      entry.error = error;
+    }
+    return JSON.stringify(entry);
   }
-  info(message, ...args) {
-    if (this.level <= 1 /* INFO */) {
-      console.log(`[${this.prefix}] ${message}`, ...args);
+  log(level, logLevel, consoleFn, message, args) {
+    if (this.level > logLevel)
+      return;
+    if (this.format === "json") {
+      consoleFn(this.formatJson(level, message, args));
+    } else {
+      const prefix = level === "info" ? "" : ` ${level.toUpperCase()}:`;
+      consoleFn(`[${this.prefix}]${prefix} ${message}`, ...args);
     }
   }
+  debug(message, ...args) {
+    this.log("debug", 0 /* DEBUG */, console.debug, message, args);
+  }
+  info(message, ...args) {
+    this.log("info", 1 /* INFO */, console.log, message, args);
+  }
   warn(message, ...args) {
-    if (this.level <= 2 /* WARN */) {
-      console.warn(`[${this.prefix}] WARN: ${message}`, ...args);
-    }
+    this.log("warn", 2 /* WARN */, console.warn, message, args);
   }
   error(message, ...args) {
-    if (this.level <= 3 /* ERROR */) {
-      console.error(`[${this.prefix}] ERROR: ${message}`, ...args);
-    }
+    this.log("error", 3 /* ERROR */, console.error, message, args);
   }
   async time(label, fn) {
     const start = performance.now();
     try {
       const result = await fn();
-      const end = performance.now();
-      this.debug(`${label} completed in ${(end - start).toFixed(2)}ms`);
+      const durationMs = performance.now() - start;
+      this.debug(`${label} completed`, { durationMs: Math.round(durationMs) });
       return result;
     } catch (error) {
-      const end = performance.now();
-      this.error(`${label} failed after ${(end - start).toFixed(2)}ms`, error);
+      const durationMs = performance.now() - start;
+      this.error(`${label} failed`, { durationMs: Math.round(durationMs) }, error);
       throw error;
     }
   }
@@ -363,6 +474,7 @@ var serverLogger = createLogger("SERVER");
 var rendererLogger = createLogger("RENDERER");
 var bundlerLogger = createLogger("BUNDLER");
 var agentLogger = createLogger("AGENT");
+var proxyLogger = createLogger("PROXY");
 var logger = createLogger("VERYFRONT");
 
 // src/core/utils/constants/cdn.ts
@@ -374,7 +486,7 @@ init_deno_env();
 // deno.json
 var deno_default = {
   name: "veryfront",
-  version: "0.0.73",
+  version: "0.0.74",
   nodeModulesDir: "auto",
   exclude: [
     "npm/",
@@ -459,12 +571,12 @@ var deno_default = {
     csstype: "https://esm.sh/csstype@3.2.3",
     "@types/react": "https://esm.sh/@types/react@18.3.27?deps=csstype@3.2.3",
     "@types/react-dom": "https://esm.sh/@types/react-dom@18.3.7?deps=csstype@3.2.3",
-    react: "https://esm.sh/react@18.3.1",
-    "react-dom": "https://esm.sh/react-dom@18.3.1",
-    "react-dom/server": "https://esm.sh/react-dom@18.3.1/server",
-    "react-dom/client": "https://esm.sh/react-dom@18.3.1/client",
-    "react/jsx-runtime": "https://esm.sh/react@18.3.1/jsx-runtime",
-    "react/jsx-dev-runtime": "https://esm.sh/react@18.3.1/jsx-dev-runtime",
+    react: "npm:react@18.3.1",
+    "react-dom": "npm:react-dom@18.3.1",
+    "react-dom/server": "npm:react-dom@18.3.1/server.node",
+    "react-dom/client": "npm:react-dom@18.3.1/client",
+    "react/jsx-runtime": "npm:react@18.3.1/jsx-runtime",
+    "react/jsx-dev-runtime": "npm:react@18.3.1/jsx-dev-runtime",
     "@mdx-js/mdx": "npm:@mdx-js/mdx@3.0.0",
     "@mdx-js/react": "npm:@mdx-js/react@3.0.0",
     "unist-util-visit": "npm:unist-util-visit@5.0.0",
@@ -474,27 +586,36 @@ var deno_default = {
     "remark-frontmatter": "npm:remark-frontmatter@5.0.0",
     "rehype-highlight": "npm:rehype-highlight@7.0.2",
     "rehype-slug": "npm:rehype-slug@6.0.0",
-    esbuild: "https://deno.land/x/esbuild@v0.20.1/wasm.js",
-    "esbuild/mod.js": "https://deno.land/x/esbuild@v0.20.1/mod.js",
+    esbuild: "npm:esbuild@0.20.2",
+    "esbuild/mod.js": "npm:esbuild@0.20.2",
     "es-module-lexer": "npm:es-module-lexer@1.5.0",
-    zod: "npm:zod@3.23.8",
+    zod: "npm:zod@3.25.76",
     "mime-types": "npm:mime-types@2.1.35",
     mdast: "npm:@types/mdast@4.0.3",
     hast: "npm:@types/hast@3.0.3",
     unist: "npm:@types/unist@3.0.2",
     unified: "npm:unified@11.0.5",
-    ai: "https://esm.sh/ai@5.0.76?deps=react@18.3.1,react-dom@18.3.1",
-    "ai/react": "https://esm.sh/@ai-sdk/react@2.0.1?deps=react@18.3.1,react-dom@18.3.1",
-    "@ai-sdk/react": "https://esm.sh/@ai-sdk/react@2.0.1?deps=react@18.3.1,react-dom@18.3.1",
+    ai: "npm:ai@5.0.76",
+    "ai/react": "npm:@ai-sdk/react@2.0.1",
+    "@ai-sdk/react": "npm:@ai-sdk/react@2.0.1",
     "@ai-sdk/openai": "https://esm.sh/@ai-sdk/openai@2.0.1",
     "@ai-sdk/anthropic": "https://esm.sh/@ai-sdk/anthropic@2.0.1",
     unocss: "https://esm.sh/unocss@0.59.0",
     "@unocss/core": "https://esm.sh/@unocss/core@0.59.0",
     "@unocss/preset-wind": "https://esm.sh/@unocss/preset-wind@0.59.0",
+    "next-themes": "npm:next-themes@0.3.0",
     redis: "npm:redis",
     pg: "npm:pg",
     "@opentelemetry/api": "npm:@opentelemetry/api@1",
-    "@opentelemetry/core": "npm:@opentelemetry/core@1"
+    "@opentelemetry/core": "npm:@opentelemetry/core@1",
+    "@opentelemetry/sdk-trace-base": "npm:@opentelemetry/sdk-trace-base@1",
+    "@opentelemetry/exporter-trace-otlp-http": "npm:@opentelemetry/exporter-trace-otlp-http@0.57",
+    "@opentelemetry/resources": "npm:@opentelemetry/resources@1",
+    "@opentelemetry/semantic-conventions": "npm:@opentelemetry/semantic-conventions@1",
+    "@babel/parser": "npm:@babel/parser@7.26.3",
+    "@babel/traverse": "npm:@babel/traverse@7.26.3",
+    "@babel/generator": "npm:@babel/generator@7.26.3",
+    "@babel/types": "npm:@babel/types@7.26.3"
   },
   compilerOptions: {
     jsx: "react-jsx",
@@ -502,7 +623,7 @@ var deno_default = {
     strict: true,
     noImplicitAny: true,
     noUncheckedIndexedAccess: true,
-    types: [],
+    types: ["npm:@types/react@18"],
     lib: [
       "deno.window",
       "dom",
@@ -517,9 +638,9 @@ var deno_default = {
     build: "deno compile --allow-all --output ../../bin/veryfront src/cli/main.ts",
     "build:npm": "deno run -A scripts/build-npm.ts",
     release: "deno run -A scripts/release.ts",
-    test: "DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --unstable-worker-options --unstable-net",
-    "test:unit": "DENO_JOBS=1 deno test --parallel --allow-all --v8-flags=--max-old-space-size=8192 --ignore=tests --unstable-worker-options --unstable-net",
-    "test:integration": "DENO_JOBS=1 deno test --parallel --fail-fast --allow-all tests --unstable-worker-options --unstable-net",
+    test: "VF_DISABLE_LRU_INTERVAL=1 DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --unstable-worker-options --unstable-net",
+    "test:unit": "VF_DISABLE_LRU_INTERVAL=1 DENO_JOBS=1 deno test --parallel --allow-all --v8-flags=--max-old-space-size=8192 --ignore=tests,src/ai/workflow/__tests__ --unstable-worker-options --unstable-net",
+    "test:integration": "VF_DISABLE_LRU_INTERVAL=1 DENO_JOBS=1 deno test --parallel --fail-fast --allow-all tests --unstable-worker-options --unstable-net",
     "test:coverage": "rm -rf coverage && DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --coverage=coverage --unstable-worker-options --unstable-net || exit 1",
     "test:coverage:unit": "rm -rf coverage && DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --coverage=coverage --ignore=tests --unstable-worker-options --unstable-net || exit 1",
     "test:coverage:integration": "rm -rf coverage && DENO_JOBS=1 deno test --parallel --fail-fast --allow-all --coverage=coverage tests --unstable-worker-options --unstable-net || exit 1",
@@ -604,6 +725,7 @@ function getEnv(key) {
 
 // src/core/utils/version.ts
 var VERSION = getEnv("VERYFRONT_VERSION") || (typeof deno_default.version === "string" ? deno_default.version : "0.0.0");
+var SERVER_START_TIME = Date.now();
 
 // src/core/utils/constants/cdn.ts
 var ESM_CDN_BASE = "https://esm.sh";
@@ -774,6 +896,167 @@ var DEV_SERVER_ENDPOINTS = {
   ERROR_OVERLAY: INTERNAL_ENDPOINTS.ERROR_OVERLAY
 };
 
+// src/platform/compat/fs.ts
+init_deno_env();
+var NodeFileSystem = class {
+  constructor() {
+    this.fs = null;
+    this.os = null;
+    this.path = null;
+    this.initialized = false;
+  }
+  async ensureInitialized() {
+    if (this.initialized)
+      return;
+    if (!isNode) {
+      throw toError(createError({
+        type: "not_supported",
+        message: "Node.js fs modules not available",
+        feature: "Node.js"
+      }));
+    }
+    const [fsModule, osModule, pathModule] = await Promise.all([
+      import("node:fs/promises"),
+      import("node:os"),
+      import("node:path")
+    ]);
+    this.fs = fsModule;
+    this.os = osModule;
+    this.path = pathModule;
+    this.initialized = true;
+  }
+  async readTextFile(path) {
+    await this.ensureInitialized();
+    return await this.fs.readFile(path, { encoding: "utf8" });
+  }
+  async readFile(path) {
+    await this.ensureInitialized();
+    return await this.fs.readFile(path);
+  }
+  async writeTextFile(path, data) {
+    await this.ensureInitialized();
+    await this.fs.writeFile(path, data, { encoding: "utf8" });
+  }
+  async writeFile(path, data) {
+    await this.ensureInitialized();
+    await this.fs.writeFile(path, data);
+  }
+  async exists(path) {
+    await this.ensureInitialized();
+    try {
+      await this.fs.access(path);
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async stat(path) {
+    await this.ensureInitialized();
+    const stat = await this.fs.stat(path);
+    return {
+      isFile: stat.isFile(),
+      isDirectory: stat.isDirectory(),
+      isSymlink: stat.isSymbolicLink(),
+      size: stat.size,
+      mtime: stat.mtime
+    };
+  }
+  async mkdir(path, options) {
+    await this.ensureInitialized();
+    await this.fs.mkdir(path, { recursive: options?.recursive ?? false });
+  }
+  async *readDir(path) {
+    await this.ensureInitialized();
+    const entries = await this.fs.readdir(path, { withFileTypes: true });
+    for (const entry of entries) {
+      yield {
+        name: entry.name,
+        isFile: entry.isFile(),
+        isDirectory: entry.isDirectory()
+      };
+    }
+  }
+  async remove(path, options) {
+    await this.ensureInitialized();
+    await this.fs.rm(path, {
+      recursive: options?.recursive ?? false,
+      force: options?.recursive ?? false
+    });
+  }
+  async makeTempDir(options) {
+    await this.ensureInitialized();
+    const tempDir = this.path.join(
+      this.os.tmpdir(),
+      `${options?.prefix ?? "tmp-"}${Math.random().toString(36).substring(2, 8)}`
+    );
+    await this.fs.mkdir(tempDir, { recursive: true });
+    return tempDir;
+  }
+};
+var DenoFileSystem = class {
+  async readTextFile(path) {
+    return await Deno.readTextFile(path);
+  }
+  async readFile(path) {
+    return await Deno.readFile(path);
+  }
+  async writeTextFile(path, data) {
+    await Deno.writeTextFile(path, data);
+  }
+  async writeFile(path, data) {
+    await Deno.writeFile(path, data);
+  }
+  async exists(path) {
+    try {
+      await Deno.stat(path);
+      return true;
+    } catch (error) {
+      if (error instanceof Deno.errors.NotFound) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async stat(path) {
+    const stat = await Deno.stat(path);
+    return {
+      isFile: stat.isFile,
+      isDirectory: stat.isDirectory,
+      isSymlink: stat.isSymlink,
+      size: stat.size,
+      mtime: stat.mtime
+    };
+  }
+  async mkdir(path, options) {
+    await Deno.mkdir(path, { recursive: options?.recursive ?? false });
+  }
+  async *readDir(path) {
+    for await (const entry of Deno.readDir(path)) {
+      yield {
+        name: entry.name,
+        isFile: entry.isFile,
+        isDirectory: entry.isDirectory
+      };
+    }
+  }
+  async remove(path, options) {
+    await Deno.remove(path, { recursive: options?.recursive ?? false });
+  }
+  async makeTempDir(options) {
+    return await Deno.makeTempDir({ prefix: options?.prefix });
+  }
+};
+function createFileSystem() {
+  if (isDeno) {
+    return new DenoFileSystem();
+  } else {
+    return new NodeFileSystem();
+  }
+}
+
 // src/core/config/loader.ts
 function getDefaultImportMapForConfig() {
   return { imports: getReactImportMap(REACT_DEFAULT_VERSION) };
@@ -910,7 +1193,62 @@ var ConfigValidationError = class extends Error {
     this.name = "ConfigValidationError";
   }
 };
-async function loadAndMergeConfig(configPath, projectDir) {
+function isVirtualFilesystem(adapter) {
+  const wrappedAdapter = adapter?.fs?.fsAdapter;
+  const adapterName = wrappedAdapter?.constructor?.name;
+  return adapterName === "VeryfrontFSAdapter";
+}
+async function loadConfigFromVirtualFS(configPath, projectDir, adapter) {
+  const fs = createFileSystem();
+  const content = await adapter.fs.readFile(configPath);
+  const source = typeof content === "string" ? content : new TextDecoder().decode(content);
+  serverLogger.debug(`[CONFIG] Loading config from virtual FS: ${configPath}`);
+  const isTsx = configPath.endsWith(".tsx");
+  const loader = isTsx ? "tsx" : configPath.endsWith(".ts") ? "ts" : "js";
+  const { build } = await import("esbuild");
+  const result = await build({
+    bundle: false,
+    // Config files shouldn't need bundling
+    write: false,
+    format: "esm",
+    platform: "neutral",
+    target: "es2022",
+    stdin: {
+      contents: source,
+      loader,
+      resolveDir: dirname(configPath),
+      sourcefile: configPath
+    }
+  });
+  if (result.errors && result.errors.length > 0) {
+    const first = result.errors[0]?.text || "unknown error";
+    throw new ConfigValidationError(`Failed to transpile config: ${first}`);
+  }
+  const js = result.outputFiles?.[0]?.text ?? "export default {}";
+  const tempDir = await fs.makeTempDir({ prefix: "vf-config-" });
+  const tempFile = join(tempDir, "config.mjs");
+  try {
+    await fs.writeTextFile(tempFile, js);
+    const configModule = await import(`file://${tempFile}?v=${Date.now()}`);
+    const userConfig = configModule.default || configModule;
+    if (userConfig === null || typeof userConfig !== "object" || Array.isArray(userConfig)) {
+      throw new ConfigValidationError(
+        `Expected object, received ${userConfig === null ? "null" : typeof userConfig}`
+      );
+    }
+    validateCorsConfig(userConfig);
+    validateConfigShape(userConfig);
+    const merged = mergeConfigs(userConfig);
+    configCacheByProject.set(projectDir, { revision: cacheRevision, config: merged });
+    return merged;
+  } finally {
+    await fs.remove(tempDir, { recursive: true });
+  }
+}
+async function loadAndMergeConfig(configPath, projectDir, adapter) {
+  if (isVirtualFilesystem(adapter)) {
+    return loadConfigFromVirtualFS(configPath, projectDir, adapter);
+  }
   try {
     const configUrl = `file://${configPath}?t=${Date.now()}-${crypto.randomUUID()}`;
     const configModule = await import(configUrl);
@@ -946,7 +1284,7 @@ async function getConfig(projectDir, adapter) {
     if (!exists)
       continue;
     try {
-      const merged = await loadAndMergeConfig(configPath, projectDir);
+      const merged = await loadAndMergeConfig(configPath, projectDir, adapter);
       if (merged)
         return merged;
     } catch (error) {