veryfront 0.1.403 → 0.1.405

package/src/deps/esm.sh/react-dom@19.2.4/client.d.ts

@@ -4,7 +4,7 @@
 
 // See https://github.com/facebook/react/blob/main/packages/react-dom/client.js to see how the exports are declared,
 
-import React = require("https://esm.sh/@types/react@19.2.3/index.d.ts");
+import React = require("https://esm.sh/@types/react@19.2.14/index.d.ts");
 
 export {};
 

package/src/src/agent/hosted-child-status.ts

@@ -30,6 +30,33 @@ export function isHostedChildTerminalErrorCode(
   );
 }
 
+export interface HostedChildSameTurnRetryBlockSignal {
+  terminalErrorCode?: string | null;
+  terminalErrorMessage?: string | null;
+}
+
+function getOptionalStringProperty(value: object, property: string): string | null {
+  const descriptor = Object.getOwnPropertyDescriptor(value, property);
+  return typeof descriptor?.value === "string" ? descriptor.value : null;
+}
+
+export function shouldBlockHostedChildSameTurnRetry(
+  result: unknown,
+): result is HostedChildSameTurnRetryBlockSignal {
+  if (typeof result !== "object" || result === null) {
+    return false;
+  }
+
+  const terminalErrorCode = getOptionalStringProperty(result, "terminalErrorCode");
+  const terminalErrorMessage = getOptionalStringProperty(result, "terminalErrorMessage");
+
+  return (
+    terminalErrorCode === "CANCELLED" ||
+    terminalErrorCode === hostedChildTerminalErrorCodes.cancelled ||
+    terminalErrorMessage === "Child run cancelled"
+  );
+}
+
 export type HostedChildTerminalStatus = Extract<
   HostedConversationRunStatus,
   "completed" | "failed" | "cancelled"

package/src/src/agent/index.ts

@@ -871,6 +871,7 @@ export {
 } from "./hosted-child-fork-runtime-start.js";
 export {
   type HostedChildRunIdentifiers,
+  type HostedChildSameTurnRetryBlockSignal,
   type HostedChildTerminalErrorCode,
   hostedChildTerminalErrorCodes,
   HostedChildTerminalStateError,
@@ -879,6 +880,7 @@ export {
   monitorHostedChildRunStatus,
   type MonitorHostedChildRunStatusInput,
   resolveHostedChildTerminalErrorCode,
+  shouldBlockHostedChildSameTurnRetry,
 } from "./hosted-child-status.js";
 export {
   type HostedLifecycleAdapter,

package/src/src/config/schemas/config.schema.ts

@@ -261,6 +261,22 @@ export const veryfrontConfigSchema = z
           })
           .partial()
           .optional(),
+        logging: z
+          .object({
+            file: z
+              .object({
+                enabled: z.boolean().optional(),
+                path: z.string().optional(),
+                maxSize: z.union([z.number().int().positive(), z.string()]).optional(),
+                maxFiles: z.number().int().positive().optional(),
+                level: z.enum(["debug", "info", "warn", "error"]).optional(),
+                format: z.enum(["json", "text"]).optional(),
+              })
+              .partial()
+              .optional(),
+          })
+          .partial()
+          .optional(),
       })
       .partial()
       .optional(),

package/src/src/observability/file-log-subscriber.ts

@@ -0,0 +1,187 @@
+import * as dntShim from "../../_dnt.shims.js";
+import type { LogEntry, LogLevel, LogSubscriber } from "./log-buffer.js";
+
+export interface FileLogConfig {
+  enabled: boolean;
+  path: string;
+  maxSize: number | string;
+  maxFiles: number;
+  level: LogLevel;
+  format: "json" | "text";
+}
+
+const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+const SIZE_UNITS: Record<string, number> = {
+  b: 1,
+  kb: 1024,
+  mb: 1024 * 1024,
+  gb: 1024 * 1024 * 1024,
+};
+
+export function parseMaxSize(value: number | string): number {
+  if (typeof value === "number") return value;
+
+  const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/);
+  if (!match?.[1]) {
+    throw new Error(`Invalid maxSize value: "${value}". Expected a number or string like "10mb".`);
+  }
+
+  const num = parseFloat(match[1]);
+  const unit = match[2] ?? "b";
+  return Math.floor(num * (SIZE_UNITS[unit] ?? 1));
+}
+
+function formatEntryText(entry: LogEntry): string {
+  const time = new Date(entry.timestamp).toISOString();
+  const level = entry.level.toUpperCase().padEnd(5);
+  const data = entry.data ? ` ${JSON.stringify(entry.data)}` : "";
+  return `${time} ${level} [${entry.source}] ${entry.message}${data}`;
+}
+
+function formatEntryJson(entry: LogEntry): string {
+  return JSON.stringify(entry);
+}
+
+export class FileLogSubscriber {
+  private file: dntShim.Deno.FsFile | null = null;
+  private currentSize = 0;
+  private writeQueue: Promise<void> = Promise.resolve();
+  private maxSizeBytes: number;
+  private minLevel: number;
+  private formatter: (entry: LogEntry) => string;
+  private closed = false;
+  private permissionFailed = false;
+  private config: FileLogConfig;
+
+  constructor(config: FileLogConfig) {
+    this.config = config;
+    this.maxSizeBytes = parseMaxSize(config.maxSize);
+    this.minLevel = LOG_LEVEL_PRIORITY[config.level];
+    this.formatter = config.format === "json" ? formatEntryJson : formatEntryText;
+  }
+
+  getSubscriber(): LogSubscriber {
+    return (entry: LogEntry) => {
+      if (this.closed || this.permissionFailed) return;
+      if (LOG_LEVEL_PRIORITY[entry.level] < this.minLevel) return;
+      this.enqueue(entry);
+    };
+  }
+
+  private enqueue(entry: LogEntry): void {
+    this.writeQueue = this.writeQueue.then(() => this.writeEntry(entry)).catch(() => {});
+  }
+
+  private async writeEntry(entry: LogEntry): Promise<void> {
+    try {
+      if (!this.file) await this.openFile();
+
+      const line = this.formatter(entry) + "\n";
+      const bytes = new TextEncoder().encode(line);
+
+      if (this.currentSize + bytes.length > this.maxSizeBytes) {
+        await this.rotate();
+      }
+
+      await this.file!.write(bytes);
+      this.currentSize += bytes.length;
+    } catch (err) {
+      if (err instanceof dntShim.Deno.errors.PermissionDenied) {
+        this.permissionFailed = true;
+        console.error(
+          `[FileLogSubscriber] Permission denied writing to ${this.config.path}. File logging disabled.`,
+        );
+        return;
+      }
+      throw err;
+    }
+  }
+
+  private async openFile(): Promise<void> {
+    await this.ensureDir();
+    this.file = await dntShim.Deno.open(this.config.path, {
+      write: true,
+      create: true,
+      append: true,
+    });
+    try {
+      const stat = await this.file.stat();
+      this.currentSize = stat.size;
+    } catch {
+      this.currentSize = 0;
+    }
+  }
+
+  private async ensureDir(): Promise<void> {
+    const dir = this.config.path.substring(0, this.config.path.lastIndexOf("/"));
+    if (dir) {
+      await dntShim.Deno.mkdir(dir, { recursive: true });
+    }
+  }
+
+  private async rotate(): Promise<void> {
+    if (this.file) {
+      this.file.close();
+      this.file = null;
+    }
+
+    for (let i = this.config.maxFiles - 1; i >= 1; i--) {
+      const from = i === 1 ? this.config.path : `${this.config.path}.${i - 1}`;
+      const to = `${this.config.path}.${i}`;
+      try {
+        await dntShim.Deno.rename(from, to);
+      } catch (err) {
+        if (!(err instanceof dntShim.Deno.errors.NotFound)) throw err;
+      }
+    }
+
+    if (this.config.maxFiles <= 1) {
+      try {
+        await dntShim.Deno.remove(this.config.path);
+      } catch (err) {
+        if (!(err instanceof dntShim.Deno.errors.NotFound)) throw err;
+      }
+    }
+
+    this.file = await dntShim.Deno.open(this.config.path, {
+      write: true,
+      create: true,
+      truncate: true,
+    });
+    this.currentSize = 0;
+  }
+
+  async flush(): Promise<void> {
+    await this.writeQueue;
+    if (this.file) {
+      try {
+        await this.file.sync();
+      } catch {
+        // file may already be closed
+      }
+    }
+  }
+
+  async close(): Promise<void> {
+    this.closed = true;
+    await this.flush();
+    if (this.file) {
+      try {
+        this.file.close();
+      } catch {
+        // already closed
+      }
+      this.file = null;
+    }
+  }
+}
+
+export function createFileLogSubscriber(config: FileLogConfig): FileLogSubscriber {
+  return new FileLogSubscriber(config);
+}

package/src/src/observability/index.ts

@@ -92,3 +92,10 @@ export {
   type LogSubscriber,
   resetLogBuffer,
 } from "./log-buffer.js";
+
+export {
+  createFileLogSubscriber,
+  type FileLogConfig,
+  FileLogSubscriber,
+  parseMaxSize,
+} from "./file-log-subscriber.js";

package/src/src/server/bootstrap.ts

@@ -33,6 +33,12 @@ import {
   markEnvLoaded,
   supportsEnvFiles,
 } from "../utils/env-loader.js";
+import { getLogBuffer } from "../observability/log-buffer.js";
+import {
+  createFileLogSubscriber,
+  type FileLogConfig,
+  type FileLogSubscriber,
+} from "../observability/file-log-subscriber.js";
 import { ReloadNotifier } from "./reload-notifier.js";
 import { clearDomainCache } from "./utils/domain-lookup.js";
 
@@ -119,15 +125,60 @@ function wireTracingShim(): void {
   }
 }
 
+const DEFAULT_FILE_LOG_PATH = ".veryfront/logs/server.log";
+const DEFAULT_FILE_LOG_MAX_SIZE = "10mb";
+const DEFAULT_FILE_LOG_MAX_FILES = 5;
+const DEFAULT_FILE_LOG_LEVEL = "warn" as const;
+const DEFAULT_FILE_LOG_FORMAT = "json" as const;
+
+interface FileLogHandle {
+  subscriber: FileLogSubscriber;
+  unsubscribe: () => void;
+}
+
+function maybeAttachFileLogSubscriber(config: VeryfrontConfig): FileLogHandle | null {
+  const fileConfig = config.observability?.logging?.file;
+  if (!fileConfig?.enabled) return null;
+
+  const resolved: FileLogConfig = {
+    enabled: true,
+    path: fileConfig.path ?? DEFAULT_FILE_LOG_PATH,
+    maxSize: fileConfig.maxSize ?? DEFAULT_FILE_LOG_MAX_SIZE,
+    maxFiles: fileConfig.maxFiles ?? DEFAULT_FILE_LOG_MAX_FILES,
+    level: fileConfig.level ?? DEFAULT_FILE_LOG_LEVEL,
+    format: fileConfig.format ?? DEFAULT_FILE_LOG_FORMAT,
+  };
+
+  const subscriber = createFileLogSubscriber(resolved);
+  const unsubscribe = getLogBuffer().subscribe(subscriber.getSubscriber());
+  bootstrapLog.debug("[bootstrap] File log subscriber attached", {
+    path: resolved.path,
+    level: resolved.level,
+    format: resolved.format,
+  });
+  return { subscriber, unsubscribe };
+}
+
+async function teardownFileLog(handle: FileLogHandle | null): Promise<void> {
+  if (!handle) return;
+  handle.unsubscribe();
+  await handle.subscriber.close();
+}
+
 function combineDispose(
   extensionLoader: ExtensionLoader,
   fsDispose?: () => void,
+  fileLogHandle?: FileLogHandle | null,
 ): () => Promise<void> {
   return async () => {
     try {
       await extensionLoader.teardownAll();
     } finally {
-      if (fsDispose) fsDispose();
+      try {
+        await teardownFileLog(fileLogHandle ?? null);
+      } finally {
+        if (fsDispose) fsDispose();
+      }
     }
   };
 }
@@ -218,141 +269,155 @@ export async function bootstrap(
   bootstrapLog.debug("Loading config with base adapter");
   let config = await getConfig(projectDir, adapter);
 
-  const fsType = config.fs?.type;
-  const needsFSAdapter = fsType != null && fsType !== "local";
+  let fileLog = maybeAttachFileLogSubscriber(config);
 
-  if (!needsFSAdapter) {
-    bootstrapLog.debug("Using local filesystem (no FSAdapter needed)");
-    const extensionLoader = await orchestrateExtensions({
-      projectDir,
-      config,
-      logger: bootstrapLog,
-      primeContracts: { [AIProviderRegistryName]: createAIProviderRegistry() },
-      builtinExtensions: createBuiltinExtensions(),
-    });
-    wireTracingShim();
-    assertRequiredContracts();
-    return {
-      adapter,
-      config,
-      usingFSAdapter: false,
-      extensionLoader,
-      dispose: combineDispose(extensionLoader),
+  try {
+    const fsType = config.fs?.type;
+    const needsFSAdapter = fsType != null && fsType !== "local";
+
+    if (!needsFSAdapter) {
+      bootstrapLog.debug("Using local filesystem (no FSAdapter needed)");
+      const extensionLoader = await orchestrateExtensions({
+        projectDir,
+        config,
+        logger: bootstrapLog,
+        primeContracts: { [AIProviderRegistryName]: createAIProviderRegistry() },
+        builtinExtensions: createBuiltinExtensions(),
+      });
+      wireTracingShim();
+      assertRequiredContracts();
+      return {
+        adapter,
+        config,
+        usingFSAdapter: false,
+        extensionLoader,
+        dispose: combineDispose(extensionLoader, undefined, fileLog),
+      };
+    }
+
+    bootstrapLog.debug("Initializing FSAdapter", { type: fsType });
+
+    // Inject server-layer callbacks into FS config so the platform layer
+    // doesn't need to import from the server layer
+    const fsWithCallbacks = {
+      ...config.fs,
+      invalidationCallbacks: {
+        triggerReload: (changedPaths?: string[], project?: InvalidationProjectContext) =>
+          ReloadNotifier.triggerReload(changedPaths, project),
+        clearDomainCache,
+      },
     };
-  }
 
-  bootstrapLog.debug("Initializing FSAdapter", { type: fsType });
-
-  // Inject server-layer callbacks into FS config so the platform layer
-  // doesn't need to import from the server layer
-  const fsWithCallbacks = {
-    ...config.fs,
-    invalidationCallbacks: {
-      triggerReload: (changedPaths?: string[], project?: InvalidationProjectContext) =>
-        ReloadNotifier.triggerReload(changedPaths, project),
-      clearDomainCache,
-    },
-  };
+    const enhancedAdapter = await enhanceAdapterWithFS(
+      adapter,
+      { ...config, fs: fsWithCallbacks },
+      projectDir,
+    );
 
-  const enhancedAdapter = await enhanceAdapterWithFS(
-    adapter,
-    { ...config, fs: fsWithCallbacks },
-    projectDir,
-  );
+    if (enhancedAdapter === adapter) {
+      bootstrapLog.debug("Framework initialized successfully", {
+        projectDir,
+        runtime: adapter.id,
+        fsAdapter: "local",
+      });
+
+      const extensionLoader = await orchestrateExtensions({
+        projectDir,
+        config,
+        logger: bootstrapLog,
+        primeContracts: { [AIProviderRegistryName]: createAIProviderRegistry() },
+        builtinExtensions: createBuiltinExtensions(),
+      });
+      wireTracingShim();
+      assertRequiredContracts();
+      return {
+        adapter,
+        config,
+        usingFSAdapter: false,
+        extensionLoader,
+        dispose: combineDispose(extensionLoader, undefined, fileLog),
+      };
+    }
+
+    const isProxyMode = config.fs?.veryfront?.proxyMode === true;
+    const isProductionMode = config.fs?.veryfront?.productionMode === true;
+
+    if (isProxyMode) {
+      bootstrapLog.debug("Skipping config reload in proxy mode (using local config)");
+    } else if (isProductionMode) {
+      bootstrapLog.debug("Skipping config reload in production mode (using local config)");
+    } else {
+      bootstrapLog.debug("Reloading config with FSAdapter");
+      clearConfigCache();
+
+      const originalConfig = config;
+      const reloadedConfig = await getConfig(projectDir, enhancedAdapter);
+
+      const usesDefaultDevConfig = reloadedConfig.dev?.port === 3000 &&
+        reloadedConfig.dev?.host === "localhost" &&
+        !reloadedConfig.dev?.hmr;
+
+      if (usesDefaultDevConfig && originalConfig.dev) {
+        bootstrapLog.debug("Keeping original config (FSAdapter returned defaults)");
+        config = originalConfig;
+      } else {
+        config = reloadedConfig;
+      }
+
+      // Re-attach file log subscriber if config was reloaded with different settings
+      const newFileLog = maybeAttachFileLogSubscriber(config);
+      if (newFileLog) {
+        await teardownFileLog(fileLog);
+        fileLog = newFileLog;
+      }
+    }
 
-  if (enhancedAdapter === adapter) {
     bootstrapLog.debug("Framework initialized successfully", {
       projectDir,
       runtime: adapter.id,
-      fsAdapter: "local",
+      fsAdapter: fsType,
     });
 
-    const extensionLoader = await orchestrateExtensions({
-      projectDir,
-      config,
-      logger: bootstrapLog,
-      primeContracts: { [AIProviderRegistryName]: createAIProviderRegistry() },
-      builtinExtensions: createBuiltinExtensions(),
-    });
+    let fsDispose: (() => void) | undefined;
+    if (isExtendedFSAdapter(enhancedAdapter.fs)) {
+      const underlying = enhancedAdapter.fs.getUnderlyingAdapter();
+      if (
+        "dispose" in underlying &&
+        typeof (underlying as { dispose?: () => void }).dispose === "function"
+      ) {
+        fsDispose = () => (underlying as { dispose: () => void }).dispose();
+      }
+    }
+
+    // If extension orchestration fails after the FS adapter has been wired up,
+    // release the FS resources (WebSocket connections, caches) before
+    // propagating the error — otherwise the adapter would leak.
+    const extensionLoader = await orchestrateOrDisposeFS(
+      () =>
+        orchestrateExtensions({
+          projectDir,
+          config,
+          logger: bootstrapLog,
+          primeContracts: { [AIProviderRegistryName]: createAIProviderRegistry() },
+          builtinExtensions: createBuiltinExtensions(),
+        }),
+      fsDispose,
+    );
     wireTracingShim();
     assertRequiredContracts();
+
     return {
-      adapter,
+      adapter: enhancedAdapter,
       config,
-      usingFSAdapter: false,
+      usingFSAdapter: true,
+      fsAdapterType: fsType,
       extensionLoader,
-      dispose: combineDispose(extensionLoader),
+      dispose: combineDispose(extensionLoader, fsDispose, fileLog),
     };
+  } catch (err) {
+    await teardownFileLog(fileLog);
+    throw err;
   }
-
-  const isProxyMode = config.fs?.veryfront?.proxyMode === true;
-  const isProductionMode = config.fs?.veryfront?.productionMode === true;
-
-  if (isProxyMode) {
-    bootstrapLog.debug("Skipping config reload in proxy mode (using local config)");
-  } else if (isProductionMode) {
-    bootstrapLog.debug("Skipping config reload in production mode (using local config)");
-  } else {
-    bootstrapLog.debug("Reloading config with FSAdapter");
-    clearConfigCache();
-
-    const originalConfig = config;
-    const reloadedConfig = await getConfig(projectDir, enhancedAdapter);
-
-    const usesDefaultDevConfig = reloadedConfig.dev?.port === 3000 &&
-      reloadedConfig.dev?.host === "localhost" &&
-      !reloadedConfig.dev?.hmr;
-
-    if (usesDefaultDevConfig && originalConfig.dev) {
-      bootstrapLog.debug("Keeping original config (FSAdapter returned defaults)");
-      config = originalConfig;
-    } else {
-      config = reloadedConfig;
-    }
-  }
-
-  bootstrapLog.debug("Framework initialized successfully", {
-    projectDir,
-    runtime: adapter.id,
-    fsAdapter: fsType,
-  });
-
-  let fsDispose: (() => void) | undefined;
-  if (isExtendedFSAdapter(enhancedAdapter.fs)) {
-    const underlying = enhancedAdapter.fs.getUnderlyingAdapter();
-    if (
-      "dispose" in underlying &&
-      typeof (underlying as { dispose?: () => void }).dispose === "function"
-    ) {
-      fsDispose = () => (underlying as { dispose: () => void }).dispose();
-    }
-  }
-
-  // If extension orchestration fails after the FS adapter has been wired up,
-  // release the FS resources (WebSocket connections, caches) before
-  // propagating the error — otherwise the adapter would leak.
-  const extensionLoader = await orchestrateOrDisposeFS(
-    () =>
-      orchestrateExtensions({
-        projectDir,
-        config,
-        logger: bootstrapLog,
-        primeContracts: { [AIProviderRegistryName]: createAIProviderRegistry() },
-        builtinExtensions: createBuiltinExtensions(),
-      }),
-    fsDispose,
-  );
-  wireTracingShim();
-  assertRequiredContracts();
-
-  return {
-    adapter: enhancedAdapter,
-    config,
-    usingFSAdapter: true,
-    fsAdapterType: fsType,
-    extensionLoader,
-    dispose: combineDispose(extensionLoader, fsDispose),
-  };
 }
 
 export async function bootstrapDev(

package/src/src/utils/version-constant.ts

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.403";
+export const VERSION = "0.1.405";