veryfront 0.1.47 → 0.1.49

package/src/src/server/handlers/dev/styles-candidate-scanner.ts

@@ -13,203 +13,15 @@ import { serverLogger } from "../../../utils/index.js";
 import { createFileSystem } from "../../../platform/compat/fs.js";
 import { join } from "../../../platform/compat/path/index.js";
 import type { HandlerContext } from "../types.js";
+import { FRAMEWORK_CANDIDATES } from "./framework-candidates.generated.js";
 
 const logger = serverLogger.component("styles-candidate-scanner");
 
 const SOURCE_EXTENSIONS = [".tsx", ".jsx", ".mdx", ".ts", ".js"];
 const SKIP_DIRS = new Set(["node_modules", ".cache", ".git", "dist", "build", ".vscode"]);
 
-/**
- * Tailwind classes used by framework React components (chat, agent-card, etc.).
- * These live inside the compiled binary and aren't in the user's project directory,
- * so the local file scanner can't discover them. Must be kept in sync with the
- * component source files in src/react/components/ai/ and src/react/primitives/.
- */
-const FRAMEWORK_SAFELIST = [
-  // ChatContainer / Chat layout (theme.ts defaultChatTheme + chat/index.tsx)
-  "flex",
-  "flex-col",
-  "flex-1",
-  "h-full",
-  "h-screen",
-  "min-h-0",
-  "overflow-hidden",
-  "overflow-y-auto",
-  "relative",
-  "bg-white",
-  "dark:bg-neutral-900",
-  "flex-shrink-0",
-  "border-t",
-  "border-neutral-200",
-  "dark:border-neutral-800",
-  "max-w-2xl",
-  "mx-auto",
-  "px-4",
-  "py-3",
-  "py-4",
-  "gap-2",
-  "items-center",
-  "justify-center",
-  "justify-end",
-  "justify-start",
-  "justify-between",
-  "space-y-2",
-  "text-center",
-  // Message bubbles (theme.ts)
-  "bg-blue-500",
-  "text-white",
-  "rounded-[20px]",
-  "rounded-br-[4px]",
-  "rounded-bl-[4px]",
-  "px-4",
-  "py-2.5",
-  "max-w-[75%]",
-  "bg-neutral-100",
-  "dark:bg-neutral-800",
-  "text-neutral-900",
-  "dark:text-neutral-100",
-  "text-neutral-500",
-  "dark:text-neutral-400",
-  "rounded-2xl",
-  "text-sm",
-  "bg-neutral-50",
-  "text-neutral-600",
-  "dark:text-neutral-300",
-  "rounded-xl",
-  "px-3",
-  "py-2",
-  "font-mono",
-  "border",
-  "border-neutral-200",
-  "dark:border-neutral-700",
-  // Input (theme.ts)
-  "bg-neutral-100",
-  "border-0",
-  "rounded-full",
-  "focus:outline-none",
-  "focus:ring-2",
-  "focus:ring-blue-500/30",
-  "dark:text-neutral-100",
-  "placeholder-neutral-400",
-  "dark:placeholder-neutral-500",
-  "text-[15px]",
-  // Button (theme.ts)
-  "w-9",
-  "h-9",
-  "bg-blue-500",
-  "hover:bg-blue-600",
-  "active:scale-95",
-  "rounded-full",
-  "transition-all",
-  "disabled:opacity-30",
-  "disabled:cursor-not-allowed",
-  "disabled:hover:bg-blue-500",
-  "disabled:active:scale-100",
-  // Loading dots (theme.ts)
-  "w-1.5",
-  "h-1.5",
-  "bg-neutral-400",
-  "animate-bounce",
-  // Empty state
-  "text-3xl",
-  "font-semibold",
-  "mb-4",
-  "mt-2",
-  "max-w-md",
-  "text-base",
-  "text-muted-foreground",
-  "text-foreground",
-  // Icons
-  "size-3",
-  "size-3.5",
-  "size-4",
-  "size-10",
-  "w-4",
-  "h-4",
-  "shrink-0",
-  // Chat messages
-  "whitespace-pre-wrap",
-  "leading-relaxed",
-  "my-3",
-  // Loading animation
-  "gap-1.5",
-  "bg-neutral-100",
-  // Error state
-  "pb-2",
-  "bg-red-50",
-  "dark:bg-red-900/20",
-  "text-red-600",
-  "dark:text-red-400",
-  "gap-3",
-  "inline-flex",
-  "px-3",
-  "py-1.5",
-  "text-xs",
-  "font-medium",
-  "bg-red-100",
-  "dark:bg-red-900/40",
-  "hover:bg-red-200",
-  "dark:hover:bg-red-900/60",
-  "transition-colors",
-  // Tool UI
-  "not-prose",
-  "w-full",
-  "rounded-md",
-  "border-border",
-  "bg-card",
-  "p-3",
-  "hover:bg-muted/50",
-  "font-medium",
-  "bg-muted/50",
-  "text-secondary-foreground",
-  "bg-secondary",
-  "border-l-2",
-  "border-muted",
-  "pl-4",
-  "ml-2",
-  "uppercase",
-  "tracking-wide",
-  "overflow-x-auto",
-  "bg-destructive/10",
-  "text-destructive",
-  // Suggestions
-  "mt-6",
-  "mb-8",
-  "line-clamp-2",
-  // Scroll button, reasoning, model selector
-  "rotate-180",
-  "transition-transform",
-  "animate-pulse",
-  "min-w-full",
-  "text-left",
-  "font-semibold",
-  "text-neutral-700",
-  "dark:text-neutral-300",
-  // Agent card (theme.ts defaultAgentTheme)
-  "p-6",
-  "space-y-4",
-  "bg-amber-50",
-  "dark:bg-amber-900/20",
-  "italic",
-  "border-amber-200",
-  "dark:border-amber-800",
-  "bg-blue-50",
-  "dark:bg-blue-900/20",
-  "border-blue-200",
-  "dark:border-blue-800",
-  "mt-2",
-  "overflow-x-auto",
-  // MessageActions
-  "gap-1",
-  "mt-2",
-  "hover:text-foreground",
-  "hover:bg-muted",
-  // Markdown
-  "group",
-] as const;
-
-/** De-duplicated set of framework candidates, computed once. */
-const frameworkCandidates = new Set<string>(FRAMEWORK_SAFELIST);
+/** De-duplicated set of framework candidates, computed once at import time. */
+const frameworkCandidates = new Set<string>(FRAMEWORK_CANDIDATES);
 
 /**
  * Extract Tailwind CSS candidate class names from all project source files.

package/src/src/server/handlers/request/module/module-server-handler.ts

@@ -35,6 +35,7 @@ export function handleModuleServer(
           releaseId: ctx.releaseId ?? null,
           allowedImportDirs: ctx.config?.security?.allowedImportDirs,
           reactVersion,
+          mode: ctx.requestContext?.mode,
         });
 
         const response = createResponseBuilder(ctx)

package/src/src/server/runtime-handler/index.ts

@@ -324,10 +324,24 @@ export function createVeryfrontHandler(
         // proceeding would cause cryptic 500s deep in the rendering pipeline.
         if (isProxyMode && !isLightweightPath(url.pathname) && !isWebSocketPath(url.pathname)) {
           const token = req.headers.get("x-token");
-          if (!headers.projectSlug) {
-            logger.error("Missing required x-project-slug header in proxy mode", {
+
+          const missingHeader = !headers.projectSlug
+            ? {
+              error: "Missing project context",
+              detail: "x-project-slug header is required in proxy mode",
+            }
+            : !token
+            ? {
+              error: "Missing authentication context",
+              detail: "x-token header is required in proxy mode",
+            }
+            : null;
+
+          if (missingHeader) {
+            logger.error(missingHeader.detail, {
               pathname: url.pathname,
               domain,
+              projectSlug: headers.projectSlug,
               host: req.headers.get("host"),
               forwardedHost: req.headers.get("x-forwarded-host"),
             });
@@ -340,32 +354,7 @@ export function createVeryfrontHandler(
             completeIsolatedRequest(headers.projectSlug, lifecycle.shouldCheckIsolation, false);
             endRequestTracing(spanInfo.span, 502);
             return new dntShim.Response(
-              JSON.stringify({
-                error: "Missing project context",
-                detail: "x-project-slug header is required in proxy mode",
-              }),
-              { status: 502, headers: { "Content-Type": "application/json" } },
-            );
-          }
-          if (!token) {
-            logger.error("Missing required x-token header in proxy mode", {
-              pathname: url.pathname,
-              domain,
-              projectSlug: headers.projectSlug,
-            });
-            endContentMetrics({
-              requestId: lifecycle.requestId,
-              pathname: url.pathname,
-              mode: "proxy",
-            });
-            completeRequestTracking(lifecycle.requestId, 502, false);
-            completeIsolatedRequest(headers.projectSlug, lifecycle.shouldCheckIsolation, false);
-            endRequestTracing(spanInfo.span, 502);
-            return new dntShim.Response(
-              JSON.stringify({
-                error: "Missing authentication context",
-                detail: "x-token header is required in proxy mode",
-              }),
+              JSON.stringify(missingHeader),
               { status: 502, headers: { "Content-Type": "application/json" } },
             );
           }

package/src/src/server/shared/renderer/memory/pressure.ts

@@ -21,7 +21,7 @@ import { getEnvNumber, getEnvString } from "../../../../platform/compat/process.
 const memoryPressureLog = rendererLogger.component("memory-pressure");
 const rendererLog = rendererLogger.component("renderer");
 
-export type MemoryPressureLevel = "normal" | "warning" | "high" | "critical";
+type MemoryPressureLevel = "normal" | "warning" | "high" | "critical";
 
 function parseEnvThreshold(name: string, fallback: number): number {
   const value = getEnvString(name);
@@ -42,7 +42,7 @@ const THRESHOLDS = {
   CRITICAL: parseEnvThreshold("MEMORY_CRITICAL_THRESHOLD", 80),
 };
 
-export function getMemoryPressure(): { level: MemoryPressureLevel; heapUsedPercent: number } {
+function getMemoryPressure(): { level: MemoryPressureLevel; heapUsedPercent: number } {
   const { heapUsedPercent } = getHeapStats();
 
   if (heapUsedPercent >= THRESHOLDS.CRITICAL) return { level: "critical", heapUsedPercent };
@@ -59,16 +59,3 @@ export function shouldRejectDueToMemory(): boolean {
   rendererLog.warn("Rejecting request - memory critical", { heapUsedPercent });
   return true;
 }
-
-export function getCacheTTLMultiplier(): number {
-  const { level } = getMemoryPressure();
-
-  if (level === "warning") return 0.5;
-  if (level === "high" || level === "critical") return 0.25;
-  return 1.0;
-}
-
-export function shouldEvictAggressively(): boolean {
-  const { level } = getMemoryPressure();
-  return level === "high" || level === "critical";
-}

package/src/src/server/utils/domain-lookup.ts

@@ -227,10 +227,6 @@ export function clearDomainCache(): void {
   logger.debug("Cache cleared");
 }
 
-export function getDomainCacheStats(): { size: number; maxSize: number } {
-  return { size: domainCache.size, maxSize: DOMAIN_CACHE_MAX_ENTRIES };
-}
-
 /**
  * Inject a CacheRepository for testing or distributed caching.
  * Call with null to restore default Map-based caching.

package/src/src/skill/allowed-tools.ts

@@ -0,0 +1,107 @@
+/**
+ * Allowed-Tools Enforcement
+ *
+ * Dual-layer enforcement for skill tool access restrictions.
+ * Layer 1: Filter tool definitions before sending to model (planning-time)
+ * Layer 2: Check individual tool calls at execution time
+ *
+ * @module
+ */
+
+import { SKILL_ALLOWED_TOOL_PATTERN_REGEX, SKILL_TOOL_IDS } from "./types.js";
+import { createError, toError } from "../errors/veryfront-error.js";
+
+/**
+ * Check if a tool name matches a single allowed-tools pattern.
+ *
+ * Supports:
+ * - Exact match: "Read" matches "Read"
+ * - Prefix wildcard: "api:*" matches "api:list-users"
+ */
+export function matchesAllowedTool(toolName: string, pattern: string): boolean {
+  // Invalid patterns always fail (fail closed)
+  if (!SKILL_ALLOWED_TOOL_PATTERN_REGEX.test(pattern)) {
+    return false;
+  }
+
+  // Prefix wildcard
+  if (pattern.endsWith(":*")) {
+    const prefix = pattern.slice(0, -1); // keep the colon: "api:"
+    return toolName.startsWith(prefix);
+  }
+
+  // Exact match
+  return toolName === pattern;
+}
+
+/** Minimal tool definition shape for filtering */
+export interface FilterableToolDefinition {
+  name: string;
+  description: string;
+  parameters: unknown;
+}
+
+/**
+ * Layer 1: Filter tool definitions before sending to model.
+ *
+ * Removes tools not in the allowed list. Always-allowed tools
+ * (skill system tools) pass through regardless.
+ *
+ * @param tools - Full list of tool definitions
+ * @param allowedTools - Allowed tool patterns, or undefined for no restrictions
+ * @returns Filtered tool definitions
+ */
+export function filterToolsForSkill<T extends FilterableToolDefinition>(
+  tools: T[],
+  allowedTools: string[] | undefined,
+): T[] {
+  if (allowedTools === undefined) {
+    return tools;
+  }
+
+  return tools.filter((tool) => {
+    if (SKILL_TOOL_IDS.has(tool.name)) return true;
+    return allowedTools.some((pattern) => matchesAllowedTool(tool.name, pattern));
+  });
+}
+
+/**
+ * Layer 2: Check if a specific tool call is allowed at execution time.
+ *
+ * @param toolName - Name of the tool being called
+ * @param allowedTools - Allowed tool patterns, or undefined for no restrictions
+ * @returns true if the tool call is allowed
+ */
+export function isToolAllowedBySkill(
+  toolName: string,
+  allowedTools: string[] | undefined,
+): boolean {
+  if (allowedTools === undefined) return true;
+  if (SKILL_TOOL_IDS.has(toolName)) return true;
+  return allowedTools.some((pattern) => matchesAllowedTool(toolName, pattern));
+}
+
+/**
+ * Validate allowed-tool patterns at parse time.
+ *
+ * Ensures each pattern matches the expected format.
+ * Rejects unsupported patterns with a descriptive error (fail closed).
+ *
+ * @param patterns - Array of tool patterns to validate
+ * @returns Validated patterns (same array if all valid)
+ * @throws If any pattern is invalid
+ */
+export function validateAllowedToolPatterns(patterns: string[]): string[] {
+  for (const pattern of patterns) {
+    if (!SKILL_ALLOWED_TOOL_PATTERN_REGEX.test(pattern)) {
+      throw toError(
+        createError({
+          type: "agent",
+          message: `Invalid allowed-tools pattern "${pattern}". ` +
+            `Only exact tool IDs (e.g. "Read") and prefix wildcards (e.g. "api:*") are supported.`,
+        }),
+      );
+    }
+  }
+  return patterns;
+}

package/src/src/skill/executor.ts

@@ -0,0 +1,215 @@
+/**
+ * Skill Script Executor
+ *
+ * Executes skill scripts using cross-runtime subprocess execution.
+ *
+ * @module
+ */
+import * as dntShim from "../../_dnt.shims.js";
+
+
+import { getEnv, runCommand } from "../platform/compat/process.js";
+import { isDeno } from "../platform/compat/runtime.js";
+import { extname } from "../platform/compat/path/index.js";
+import { readTextFile } from "../platform/compat/fs.js";
+import { createError, toError } from "../errors/veryfront-error.js";
+import type { SkillScriptExecutor, SkillScriptExecutorInput, SkillScriptResult } from "./types.js";
+
+const DEFAULT_SCRIPT_TIMEOUT_MS = 60_000;
+const MAX_SCRIPT_TIMEOUT_MS = 300_000;
+const TIMEOUT_EXIT_CODE = 124;
+const ENV_KEY_REGEX = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const TIMEOUT_SENTINEL = Symbol("skill-script-timeout");
+
+function resolveTimeoutMs(timeoutMs?: number): number {
+  if (timeoutMs === undefined || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return DEFAULT_SCRIPT_TIMEOUT_MS;
+  }
+  return Math.min(Math.floor(timeoutMs), MAX_SCRIPT_TIMEOUT_MS);
+}
+
+async function withTimeout<T>(
+  promise: Promise<T>,
+  timeoutMs: number,
+): Promise<T | typeof TIMEOUT_SENTINEL> {
+  let timeoutId: ReturnType<typeof dntShim.setTimeout> | undefined;
+  const timeoutPromise = new Promise<typeof TIMEOUT_SENTINEL>((resolve) => {
+    timeoutId = dntShim.setTimeout(() => resolve(TIMEOUT_SENTINEL), timeoutMs);
+  });
+
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
+  }
+}
+
+function timeoutResult(timeoutMs: number): SkillScriptResult {
+  return {
+    stdout: "",
+    stderr: `Script execution timed out after ${timeoutMs}ms`,
+    exitCode: TIMEOUT_EXIT_CODE,
+  };
+}
+
+function shellEscapeArg(value: string): string {
+  return `'${value.replaceAll("'", "'\"'\"'")}'`;
+}
+
+function buildShellCommand(parts: string[]): string {
+  return parts.map(shellEscapeArg).join(" ");
+}
+
+function formatEnvAssignments(env?: Record<string, string>): string[] {
+  if (!env) return [];
+  return Object.entries(env).map(([key, value]) => {
+    if (!ENV_KEY_REGEX.test(key)) {
+      throw toError(
+        createError({
+          type: "agent",
+          message: `Invalid environment variable name: "${key}"`,
+        }),
+      );
+    }
+    return `${key}=${value}`;
+  });
+}
+
+function createSandboxScriptPath(scriptPath: string): string {
+  const ext = extname(scriptPath) || ".sh";
+  const suffix = Math.random().toString(36).slice(2, 10);
+  return `/tmp/veryfront-skill-script-${Date.now()}-${suffix}${ext}`;
+}
+
+/**
+ * Detect the runtime command for a script based on file extension.
+ */
+export function detectRuntime(scriptPath: string): { command: string; args: string[] } {
+  const ext = extname(scriptPath).toLowerCase();
+
+  switch (ext) {
+    case ".py":
+      return { command: "python3", args: [scriptPath] };
+    case ".sh":
+      return { command: "bash", args: [scriptPath] };
+    case ".js":
+      return { command: "node", args: [scriptPath] };
+    case ".ts":
+      if (isDeno) {
+        return {
+          command: "deno",
+          args: ["run", "--allow-read", "--allow-env", "--allow-net", "--allow-write", scriptPath],
+        };
+      }
+      return { command: "npx", args: ["tsx", scriptPath] };
+    default:
+      return { command: scriptPath, args: [] };
+  }
+}
+
+/**
+ * Local script executor using runCommand() from the compat layer.
+ */
+export class LocalScriptExecutor implements SkillScriptExecutor {
+  async execute(input: SkillScriptExecutorInput): Promise<SkillScriptResult> {
+    const timeoutMs = resolveTimeoutMs(input.timeoutMs);
+    const { command, args: runtimeArgs } = detectRuntime(input.scriptPath);
+    const allArgs = [...runtimeArgs, ...(input.args ?? [])];
+
+    // Remove the script path from args if it's already the command
+    const finalArgs = command === input.scriptPath ? (input.args ?? []) : allArgs;
+
+    const result = await runCommand(command, {
+      args: finalArgs,
+      cwd: input.cwd,
+      env: input.env,
+      capture: true,
+      timeoutMs,
+    });
+
+    return {
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? "",
+      exitCode: result.code,
+    };
+  }
+}
+
+/**
+ * Cloud script executor using sandbox.
+ * Requires SANDBOX_AUTH_TOKEN environment variable.
+ */
+export class CloudScriptExecutor implements SkillScriptExecutor {
+  async execute(input: SkillScriptExecutorInput): Promise<SkillScriptResult> {
+    const timeoutMs = resolveTimeoutMs(input.timeoutMs);
+    // NOTE: In SSR contexts, getEnv() reads through the project-env overlay
+    // (AsyncLocalStorage-backed). If the token is set at host level only,
+    // the overlay may not surface it. Ensure SANDBOX_AUTH_TOKEN is available
+    // in the request-scoped environment when running under SSR.
+    const authToken = getEnv("SANDBOX_AUTH_TOKEN");
+    if (!authToken) {
+      throw toError(
+        createError({
+          type: "agent",
+          message: "Cloud script execution requires SANDBOX_AUTH_TOKEN environment variable",
+        }),
+      );
+    }
+
+    // Lazy import to avoid bundling sandbox in non-cloud environments
+    const { Sandbox } = await import("../sandbox/index.js");
+    const sandbox = await Sandbox.create({ authToken });
+    try {
+      const sandboxScriptPath = createSandboxScriptPath(input.scriptPath);
+      const scriptContent = input.scriptContent ?? await readTextFile(input.scriptPath);
+
+      await sandbox.writeFiles([{ path: sandboxScriptPath, content: scriptContent }]);
+      await sandbox.executeCommand(buildShellCommand(["chmod", "+x", sandboxScriptPath]));
+
+      const { command, args: runtimeArgs } = detectRuntime(sandboxScriptPath);
+      const allArgs = [...runtimeArgs, ...(input.args ?? [])];
+      const finalArgs = command === sandboxScriptPath ? (input.args ?? []) : allArgs;
+
+      const envAssignments = formatEnvAssignments(input.env);
+      const commandParts = envAssignments.length > 0
+        ? ["env", ...envAssignments, command, ...finalArgs]
+        : [command, ...finalArgs];
+
+      const cmdString = buildShellCommand(commandParts);
+      const commandPromise = sandbox.executeCommand(cmdString);
+      const result = await withTimeout(commandPromise, timeoutMs);
+
+      if (result === TIMEOUT_SENTINEL) {
+        // Kill any running processes before returning — withTimeout only
+        // races the timer, it doesn't terminate the sandbox command.
+        try {
+          await sandbox.executeCommand("kill -9 -1 2>/dev/null || true");
+        } catch {
+          // Best-effort kill; sandbox.close() in finally will clean up.
+        }
+        return timeoutResult(timeoutMs);
+      }
+
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode,
+      };
+    } finally {
+      try {
+        await sandbox.close();
+      } catch {
+        // Best-effort cleanup.
+      }
+    }
+  }
+}
+
+/**
+ * Get the appropriate script executor.
+ * Checks SANDBOX_AUTH_TOKEN on every call so request-scoped env overlays
+ * (e.g. project-env AsyncLocalStorage) are respected.
+ */
+export function getSkillScriptExecutor(): SkillScriptExecutor {
+  return getEnv("SANDBOX_AUTH_TOKEN") ? new CloudScriptExecutor() : new LocalScriptExecutor();
+}