veryfront 0.1.131 → 0.1.136

package/src/src/internal-agents/ag-ui-sse.ts

@@ -20,6 +20,7 @@ export interface RunFinishedMetadata {
 export interface StreamTransformState {
   messageId: string | null;
   textOpen: boolean;
+  sawVisibleOutput: boolean;
   sawTerminalError: boolean;
   metadata: RunFinishedMetadata;
 }
@@ -28,6 +29,7 @@ export function createStreamTransformState(): StreamTransformState {
   return {
     messageId: null,
     textOpen: false,
+    sawVisibleOutput: false,
     sawTerminalError: false,
     metadata: {},
   };
@@ -181,6 +183,7 @@ export function mapRuntimeEventToAgUi(
       if (state.textOpen) return [];
       const messageId = getMessageId(state, event);
       state.textOpen = true;
+      state.sawVisibleOutput = true;
       return [{
         event: "TextMessageStart",
         payload: { messageId, role: "assistant" },
@@ -189,6 +192,7 @@ export function mapRuntimeEventToAgUi(
 
     case "text-delta": {
       const messageId = getMessageId(state, event);
+      state.sawVisibleOutput = true;
       if (!state.textOpen) {
         state.textOpen = true;
         return [
@@ -216,6 +220,7 @@ export function mapRuntimeEventToAgUi(
     }
 
     case "tool-input-start":
+      state.sawVisibleOutput = true;
       return [{
         event: "ToolCallStart",
         payload: {
@@ -225,6 +230,7 @@ export function mapRuntimeEventToAgUi(
       }];
 
     case "tool-input-delta":
+      state.sawVisibleOutput = true;
       return [{
         event: "ToolCallArgs",
         payload: {
@@ -234,12 +240,14 @@ export function mapRuntimeEventToAgUi(
       }];
 
     case "tool-input-available":
+      state.sawVisibleOutput = true;
       return [{
         event: "ToolCallEnd",
         payload: { toolCallId: event.toolCallId },
       }];
 
     case "tool-output-available":
+      state.sawVisibleOutput = true;
       return [{
         event: "ToolCallResult",
         payload: {
@@ -249,6 +257,7 @@ export function mapRuntimeEventToAgUi(
       }];
 
     case "tool-output-error":
+      state.sawVisibleOutput = true;
       return [{
         event: "ToolCallResult",
         payload: {
@@ -292,6 +301,17 @@ export function finalizeRunEvents(
     return [];
   }
 
+  if (!state.sawVisibleOutput) {
+    state.sawTerminalError = true;
+    return [{
+      event: "RunError",
+      payload: {
+        code: "EMPTY_ASSISTANT_OUTPUT",
+        message: "Agent run produced no assistant-visible output",
+      },
+    }];
+  }
+
   const events: Array<{ event: string; payload: Record<string, unknown> }> = [];
   if (state.textOpen) {
     state.textOpen = false;

package/src/src/internal-agents/run-stream.ts

@@ -20,6 +20,12 @@ import type { RuntimeRunAgentInput } from "./schema.js";
 
 const anyObjectSchema = z.record(z.string(), z.unknown());
 
+type RuntimeFilteredAgent = Agent & {
+  config: Agent["config"] & {
+    __vfAllowedRemoteTools?: string[];
+  };
+};
+
 export interface RuntimeAgentStreamExecutionDeps {
   sessionManager: AgentRunSessionManager;
   createRuntime?: (
@@ -203,6 +209,22 @@ function normalizeRuntimeMessages(messages: RuntimeRunAgentInput["messages"]): M
   }));
 }
 
+function getAllowedRemoteToolNames(
+  forwardedProps: RuntimeRunAgentInput["forwardedProps"],
+): string[] | undefined {
+  const runtimeOverrides = isRecord(forwardedProps?.runtimeOverrides)
+    ? forwardedProps.runtimeOverrides
+    : null;
+  if (!runtimeOverrides || !Object.hasOwn(runtimeOverrides, "allowedTools")) {
+    return undefined;
+  }
+  const allowedTools = runtimeOverrides.allowedTools;
+  if (!Array.isArray(allowedTools)) {
+    return [];
+  }
+  return allowedTools.every((toolName) => typeof toolName === "string") ? allowedTools : [];
+}
+
 export async function createRuntimeAgentStreamResponse(
   input: RuntimeRunAgentInput,
   agent: Agent,
@@ -214,10 +236,19 @@ export async function createRuntimeAgentStreamResponse(
   });
 
   const mergedTools = buildMergedTools(agent, input, deps.sessionManager);
-  const runtime = deps.createRuntime?.(agent, mergedTools) ?? new AgentRuntime(agent.id, {
-    ...agent.config,
-    tools: mergedTools,
-  });
+  const allowedRemoteToolNames = getAllowedRemoteToolNames(input.forwardedProps);
+  const runtimeAgent: RuntimeFilteredAgent = {
+    ...agent,
+    config: {
+      ...agent.config,
+      tools: mergedTools,
+      ...(allowedRemoteToolNames !== undefined
+        ? { __vfAllowedRemoteTools: allowedRemoteToolNames }
+        : {}),
+    },
+  };
+  const runtime = deps.createRuntime?.(runtimeAgent, mergedTools) ??
+    new AgentRuntime(runtimeAgent.id, runtimeAgent.config);
 
   let completedResponse: AgentResponse | null = null;
   const runtimeMessages = normalizeRuntimeMessages(input.messages);

package/src/src/platform/adapters/fs/veryfront/proxy-manager.ts

@@ -398,9 +398,11 @@ export class ProxyFSAdapterManager {
         projectId,
         apiToken: effectiveToken,
       },
-      invalidationCallbacks: createDefaultInvalidationCallbacks(
-        this.baseConfig.invalidationCallbacks,
-      ),
+      invalidationCallbacks: createDefaultInvalidationCallbacks({
+        ...this.baseConfig.invalidationCallbacks,
+        evictCurrentAdapter: () =>
+          this.evictAdapter(projectSlug, productionMode, releaseId, branch),
+      }),
     };
 
     const adapter = new VeryfrontFSAdapter(config);
@@ -557,6 +559,30 @@ export class ProxyFSAdapterManager {
     return this.adapters.has(cacheKey);
   }
 
+  evictAdapter(
+    projectSlug: string,
+    productionMode?: boolean,
+    releaseId?: string | null,
+    branch?: string | null,
+  ): void {
+    const cacheKey = buildProxyManagerCacheKey(
+      projectSlug,
+      productionMode ?? false,
+      releaseId ?? null,
+      branch ?? null,
+    );
+
+    const adapter = this.adapters.get(cacheKey);
+    if (!adapter) {
+      logger.debug("No adapter to evict", { cacheKey });
+      return;
+    }
+
+    logger.debug("Evicting adapter", { cacheKey });
+    adapter.adapter.dispose();
+    this.adapters.delete(cacheKey);
+  }
+
   getStats(): { adapters: number; stats: Record<string, CacheStats> } {
     const stats: Record<string, CacheStats> = {};
 

package/src/src/platform/adapters/fs/veryfront/types.ts

@@ -137,4 +137,6 @@ export interface InvalidationCallbacks {
   clearProjectCSSCache?: (projectSlug: string) => void;
   /** Clear domain lookup cache to refresh release IDs after publishing */
   clearDomainCache?: () => void;
+  /** Evict the current shared proxy adapter after successful invalidation */
+  evictCurrentAdapter?: () => void;
 }

package/src/src/platform/adapters/fs/veryfront/websocket-manager.ts

@@ -693,6 +693,7 @@ export class WebSocketManager {
           previewInvalidationPrefixes,
           previewInvalidationVersion,
         );
+        this.deps.invalidationCallbacks.evictCurrentAdapter?.();
       }
     }
   }
@@ -837,6 +838,7 @@ export class WebSocketManager {
           previewInvalidationPrefixes,
           previewInvalidationVersion,
         );
+        this.deps.invalidationCallbacks.evictCurrentAdapter?.();
       }
     }
   }

package/src/src/proxy/handler.ts

@@ -410,6 +410,24 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
     );
   }
 
+  function makeProjectNotFoundContext(
+    base: {
+      scope: TokenScope;
+      host: string;
+      parsedDomain: ParsedDomain;
+    },
+    token?: string,
+  ): ProxyContext {
+    return makeErrorContext(
+      base,
+      404,
+      "Project not found",
+      token,
+      undefined,
+      "project-not-found",
+    );
+  }
+
   async function resolveRequestToken(
     req: dntShim.Request,
     scope: TokenScope,
@@ -607,20 +625,30 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
         },
       ));
 
-      if (projectSlug && scope === "preview" && !token) {
+      if (projectSlug && !token) {
         const status = parseStatusFromError(tokenFetchError);
         if (status === 404) {
-          logger?.info("Preview project not found", { projectSlug, host });
-          return makePreviewProjectNotFoundContext(base);
+          if (scope === "preview") {
+            logger?.info("Preview project not found", { projectSlug, host });
+            return makePreviewProjectNotFoundContext(base);
+          }
+
+          logger?.info("Project not found", { projectSlug, host, scope });
+          return makeProjectNotFoundContext(base);
         }
 
-        logger?.warn("Preview request has no usable token", {
+        const message = scope === "preview"
+          ? "Failed to authenticate preview request"
+          : "Failed to authenticate project request";
+
+        logger?.warn("Project request has no usable token", {
           projectSlug,
           host,
+          scope,
           hadUserToken: !!userToken,
           hadTokenFetchError: !!tokenFetchError,
         });
-        return makeErrorContext(base, 502, "Failed to authenticate preview request");
+        return makeErrorContext(base, 502, message);
       }
 
       if (isCustomDomain && !projectSlug) {
@@ -692,6 +720,16 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
           );
         }
 
+        if (!resolved.projectId) {
+          logger?.info("Project not found after lookup", {
+            projectSlug,
+            host,
+            scope,
+            targetEnvName: parsedDomain.environment,
+          });
+          return makeProjectNotFoundContext(base, token);
+        }
+
         projectId = resolved.projectId;
         releaseId = resolved.releaseId;
         environmentId = resolved.environmentId;

package/src/src/react/components/Head.tsx

@@ -1,2 +1,12 @@
+/**
+ * React head exports for document metadata rendering.
+ *
+ * @module
+ * @example
+ * ```tsx
+ * import { Head } from "veryfront/head";
+ * ```
+ */
 import "../../../_dnt.polyfills.js";
+
 export { Head } from "../runtime/core.js";

package/src/src/react/context/index.tsx

@@ -1,3 +1,13 @@
+/**
+ * React page-context exports for MDX and route-aware rendering.
+ *
+ * @module
+ * @example
+ * ```tsx
+ * import { PageContextProvider, usePageContext } from "veryfront/context";
+ * ```
+ */
 import "../../../_dnt.polyfills.js";
+
 export { PageContextProvider, usePageContext } from "../runtime/core.js";
 export type { MdxHeading, PageContextProviderProps, PageContextValue } from "../runtime/core.js";

package/src/src/react/router/index.tsx

@@ -1,3 +1,13 @@
+/**
+ * React router exports for client navigation and route context.
+ *
+ * @module
+ * @example
+ * ```tsx
+ * import { Link, RouterProvider, useRouter } from "veryfront/router";
+ * ```
+ */
 import "../../../_dnt.polyfills.js";
+
 export { Link, Router, RouterProvider, useRouter } from "../runtime/core.js";
 export type { LinkProps, RouterProviderProps, RouterValue } from "../runtime/core.js";

package/src/src/rendering/orchestrator/html.ts

@@ -19,7 +19,7 @@ import type {
   PageBundle,
 } from "../../types/index.js";
 import { DEFAULT_DASHBOARD_PORT, rendererLogger } from "../../utils/index.js";
-import { escapeHtml } from "../../utils/html-escape.js";
+import { addNonceToHtmlTags } from "../../html/nonce-injection.js";
 import type { RenderOptions } from "./types.js";
 import { injectElementSelectors } from "../../studio/element-selector-injector.js";
 import { computeSourceHash } from "../../studio/hash-utils.js";
@@ -41,106 +41,60 @@ import type { ResolvedContentContext } from "../../platform/adapters/fs/veryfron
 const logger = rendererLogger.component("html-generator");
 type ProjectCSSResult = Awaited<ReturnType<typeof getProjectCSS>> | null;
 
-function findTagEnd(html: string, start: number): number {
-  let activeQuote: '"' | "'" | null = null;
+function applyExplicitThemeToDocument(
+  html: string,
+  colorScheme: "light" | "dark" | undefined,
+  enabled: boolean | undefined,
+): string {
+  if (!enabled || !colorScheme) return html;
 
-  for (let index = start + 1; index < html.length; index++) {
-    const char = html[index];
+  return html.replace(/<html\b([^>]*)>/i, (_match, attrs: string) => {
+    let nextAttrs = attrs;
 
-    if (activeQuote) {
-      if (char === activeQuote) activeQuote = null;
-      continue;
+    if (/\sdata-theme\s*=/i.test(nextAttrs)) {
+      nextAttrs = nextAttrs.replace(/\sdata-theme\s*=\s*(["']).*?\1/i, "");
     }
-
-    if (char === '"' || char === "'") {
-      activeQuote = char;
-      continue;
-    }
-
-    if (char === ">") return index;
-  }
-
-  return -1;
-}
-
-function getOpeningTagName(tag: string): "script" | "style" | undefined {
-  const match = /^<\s*([a-zA-Z][\w:-]*)/u.exec(tag);
-  const tagName = match?.[1]?.toLowerCase();
-  if (tagName === "script" || tagName === "style") return tagName;
-  return undefined;
-}
-
-function injectNonceIntoOpeningTag(tag: string, escapedNonce: string): string {
-  if (/\bnonce\s*=/iu.test(tag)) return tag;
-
-  const closeIndex = tag.lastIndexOf(">");
-  if (closeIndex === -1) return tag;
-
-  const insertAt = /\/\s*>$/u.test(tag) ? closeIndex - 1 : closeIndex;
-  return `${tag.slice(0, insertAt)} nonce="${escapedNonce}"${tag.slice(insertAt)}`;
-}
-
-function addNonceToRenderedTags(html: string, nonce?: string): string {
-  if (!nonce) return html;
-
-  const escapedNonce = escapeHtml(nonce);
-  const lowerHtml = html.toLowerCase();
-  let result = "";
-  let index = 0;
-  let rawTextTag: "script" | "style" | null = null;
-
-  while (index < html.length) {
-    if (rawTextTag) {
-      const closingIndex = lowerHtml.indexOf(`</${rawTextTag}`, index);
-      if (closingIndex === -1) {
-        result += html.slice(index);
-        break;
+    nextAttrs += ` data-theme="${colorScheme}"`;
+
+    const styleMatch = nextAttrs.match(/\sstyle\s*=\s*(["'])(.*?)\1/i);
+    if (styleMatch) {
+      let styleValue = (styleMatch[2] ?? "").trim();
+
+      if (/color-scheme\s*:/i.test(styleValue)) {
+        styleValue = styleValue.replace(
+          /color-scheme\s*:\s*[^;]+/i,
+          `color-scheme: ${colorScheme}`,
+        );
+      } else {
+        styleValue = styleValue
+          ? `${styleValue.replace(/;?\s*$/, ";")} color-scheme: ${colorScheme};`
+          : `color-scheme: ${colorScheme};`;
       }
 
-      result += html.slice(index, closingIndex);
-      index = closingIndex;
-      rawTextTag = null;
-      continue;
+      nextAttrs = nextAttrs.replace(styleMatch[0], ` style="${styleValue}"`);
+    } else {
+      nextAttrs += ` style="color-scheme: ${colorScheme};"`;
     }
 
-    if (html.startsWith("<!--", index)) {
-      const commentEnd = html.indexOf("-->", index + 4);
-      const endIndex = commentEnd === -1 ? html.length : commentEnd + 3;
-      result += html.slice(index, endIndex);
-      index = endIndex;
-      continue;
-    }
-
-    if (html[index] !== "<") {
-      result += html[index];
-      index++;
-      continue;
-    }
-
-    const tagEnd = findTagEnd(html, index);
-    if (tagEnd === -1) {
-      result += html.slice(index);
-      break;
-    }
-
-    const tag = html.slice(index, tagEnd + 1);
-    const tagName = getOpeningTagName(tag);
-
-    if (!tagName) {
-      result += tag;
-      index = tagEnd + 1;
-      continue;
-    }
-
-    result += injectNonceIntoOpeningTag(tag, escapedNonce);
-    index = tagEnd + 1;
-
-    if (!/\/\s*>$/u.test(tag)) {
-      rawTextTag = tagName;
-    }
-  }
+    return `<html${nextAttrs}>`;
+  });
+}
 
-  return result;
+function injectThemePersistenceScript(
+  html: string,
+  colorScheme: "light" | "dark" | undefined,
+  enabled: boolean | undefined,
+  nonce?: string,
+): string {
+  if (!enabled || !colorScheme || !/<\/head>/i.test(html)) return html;
+  if (html.includes(`localStorage.setItem('theme','${colorScheme}')`)) return html;
+
+  const nonceAttr = nonce ? ` nonce="${nonce}"` : "";
+  const script = `<script${nonceAttr}>
+(function(){try{localStorage.setItem('theme','${colorScheme}')}catch(e){/* SILENT: localStorage may be unavailable */}})();
+</script>`;
+
+  return html.replace(/<\/head>/i, `${script}\n</head>`);
 }
 
 export interface HTMLGeneratorConfig {
@@ -173,16 +127,29 @@ export class HTMLGenerator {
   }
 
   async generateFullHTML(context: HTMLGenerationContext): Promise<string> {
-    const html = isFullHTMLDocument(context.html)
-      ? await this.handleFullHTMLDocument(context)
-      : await this.wrapHTMLFragment(context);
+    let html: string;
+    if (isFullHTMLDocument(context.html)) {
+      let projectCSSPromise: Promise<ProjectCSSResult> | undefined;
+      if (this.config.mode === "production" && context.options?.environment === "production") {
+        const mergedFrontmatter = this.mergeFrontmatter(context);
+        const htmlOptions = await profilePhase(
+          "html.build_options",
+          () => this.buildHTMLOptions(context, mergedFrontmatter),
+        );
+        projectCSSPromise = this.startProjectCSSPreparation(context, htmlOptions);
+      }
+
+      html = await this.handleFullHTMLDocument(context, projectCSSPromise);
+    } else {
+      html = await this.wrapHTMLFragment(context);
+    }
     const finalHtml = context.options?.studioEmbed ? injectElementSelectors(html) : html;
 
     if (context.options?.studioEmbed) {
       logger.debug("Injected element selectors for Studio");
     }
 
-    return addNonceToRenderedTags(finalHtml, context.options?.nonce);
+    return addNonceToHtmlTags(finalHtml, context.options?.nonce);
   }
 
   async generateHTMLStream(
@@ -210,6 +177,27 @@ export class HTMLGenerator {
       reactContent = error.partialContent.trim();
     }
 
+    if (isFullHTMLDocument(reactContent)) {
+      const encoder = new TextEncoder();
+      const fullHtml = addNonceToHtmlTags(
+        await this.handleFullHTMLDocument(
+          {
+            ...fullContext,
+            html: reactContent,
+          },
+          projectCSSPromise,
+        ),
+        context.options?.nonce,
+      );
+
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue(encoder.encode(fullHtml));
+          controller.close();
+        },
+      });
+    }
+
     const { start, end } = await profilePhase(
       "html.generate_shell_parts",
       () =>
@@ -223,7 +211,7 @@ export class HTMLGenerator {
     );
 
     const encoder = new TextEncoder();
-    const fullHtml = addNonceToRenderedTags(
+    const fullHtml = addNonceToHtmlTags(
       `${start}${reactContent}${end}`,
       context.options?.nonce,
     );
@@ -236,7 +224,10 @@ export class HTMLGenerator {
     });
   }
 
-  private async handleFullHTMLDocument(context: HTMLGenerationContext): Promise<string> {
+  private async handleFullHTMLDocument(
+    context: HTMLGenerationContext,
+    projectCSSPromise?: Promise<ProjectCSSResult>,
+  ): Promise<string> {
     const metadata = extractHTMLMetadata(
       (context.pageInfo.entity.frontmatter || {}) as MDXFrontmatter,
       (context.layoutBundle?.frontmatter || {}) as MDXFrontmatter,
@@ -251,7 +242,23 @@ export class HTMLGenerator {
       }),
     ]);
 
-    const injectedHtml = injectHTMLContent(context.html, "", metadata, {
+    const themedHtml = injectThemePersistenceScript(
+      applyExplicitThemeToDocument(
+        context.html,
+        context.options?.colorScheme,
+        context.options?.colorSchemeFromParam,
+      ),
+      context.options?.colorScheme,
+      context.options?.colorSchemeFromParam,
+      context.options?.nonce,
+    );
+
+    const projectStylesheetHref = await this.resolveProjectStylesheetHref(
+      context,
+      projectCSSPromise,
+    );
+
+    const injectedHtml = injectHTMLContent(themedHtml, "", metadata, {
       mode: this.config.mode,
       slug: context.slug,
       devPort: this.config.config?.dev?.port || DEFAULT_DASHBOARD_PORT,
@@ -262,6 +269,7 @@ export class HTMLGenerator {
       isLocalProject: this.config.mode === "development",
       nonce: context.options?.nonce,
       importMapJson,
+      projectStylesheetHref,
     });
 
     if (injectedHtml.trimStart().toLowerCase().startsWith("<!doctype")) return injectedHtml;
@@ -269,6 +277,23 @@ export class HTMLGenerator {
     return `<!DOCTYPE html>\n${injectedHtml}`;
   }
 
+  private async resolveProjectStylesheetHref(
+    context: HTMLGenerationContext,
+    projectCSSPromise?: Promise<ProjectCSSResult>,
+  ): Promise<string | undefined> {
+    if (!projectCSSPromise) return undefined;
+
+    const projectCSS = await profilePhase("html.project_css", () => projectCSSPromise);
+    const cssHash = projectCSS?.hash ?? "";
+    if (cssHash) return `/_vf/css/${cssHash}.css`;
+
+    logger.error("Project CSS hash is empty for full-document HTML", {
+      slug: context.slug,
+      environment: context.options?.environment,
+    });
+    return undefined;
+  }
+
   private async detectUseClientDirective(pagePath: string): Promise<boolean> {
     try {
       const pageContent = await this.config.adapter.fs.readFile(pagePath);

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

@@ -239,6 +239,7 @@ async function generateFullHtml(
       mode: options.mode,
       slug,
       devPort: options.config?.dev?.port ?? DEFAULT_DASHBOARD_PORT,
+      nonce: options.nonce,
     });
   }