veryfront 0.0.84 → 0.0.88

package/README.md

@@ -7,54 +7,28 @@ npx veryfront
 ```
 
 ```
-  ○ ○ ○ ○ ○ ○ ○
-  ○ ● ● ● ○ ○ ○   Veryfront Code is running
-  ○ ● ● ● ○ ○ ○
-  ○ ● ● ○ ● ● ○   Url  http://veryfront.me:3000
-  ○ ○ ○ ● ● ● ○   Mcp  http://veryfront.me:3002/mcp
-  ○ ○ ○ ● ● ● ○
-  ○ ○ ○ ○ ○ ○ ○
-
-  ✓ Server ready
-  ✓ MCP ready
+╭──────────────────────────────────────────────────────────╮
+│                                                          │
+│  ○ ○ ○ ○ ○ ○ ○                                           │
+│  ○ ● ● ● ○ ○ ○   Veryfront Code is now running           │
+│  ○ ● ● ● ○ ○ ○                                           │
+│  ○ ● ● ○ ● ● ○   Url http://veryfront.me:8080            │
+│  ○ ○ ○ ● ● ● ○   Mcp http://veryfront.me:9999/mcp        │
+│  ○ ○ ○ ● ● ● ○                                           │
+│  ○ ○ ○ ○ ○ ○ ○                                           │
+│                                                          │
+╰──────────────────────────────────────────────────────────╯
 ```
 
 One command. Zero config. Just build.
 
-## Project Structure
+[Docs](https://veryfront.com/docs/framework) · [Discord](https://discord.gg/veryfront) · [X](https://x.com/veryfrontdev) · MIT
 
-```
-my-app/
-├── app/                     # App Router (pages & APIs)
-│   ├── chat/page.tsx
-│   └── api/chat/route.ts
-├── agents/                  # AI agents
-├── tools/                   # MCP tools
-├── workflows/               # Durable workflows
-├── prompts/                 # Prompt templates
-└── resources/               # MCP resources
-```
-
-All directories are auto-discovered.
-
-## Documentation
-
-- [Getting Started](https://veryfront.com/docs/framework)
-- [Agents](https://veryfront.com/docs/framework/agents)
-- [Tools](https://veryfront.com/docs/framework/tools)
-- [Workflows](https://veryfront.com/docs/framework/workflows)
-- [MCP Server](https://veryfront.com/docs/framework/mcp)
-
-## Community
-
-- [Discord](https://discord.gg/veryfront)
-- [X](https://x.com/veryfrontdev)
-- [GitHub Discussions](https://github.com/veryfront/veryfront/discussions)
-
-## Contributing
-
-See [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.
+## Releasing
 
-## License
+Create a new release with `gh release create vX.X.X`. The publish workflow runs automatically and takes ~4-5 minutes:
 
-MIT
+1. Builds native binaries for 5 platforms (macOS arm64/x64, Linux x64/arm64, Windows x64)
+2. Publishes to npm with provenance
+3. Creates GitHub releases in both repos
+4. Updates Homebrew formula

package/esm/deno.d.ts

@@ -247,7 +247,6 @@ declare namespace _default {
     let tasks: {
         setup: string;
         start: string;
-        "start:clean": string;
         "start:headless": string;
         proxy: string;
         renderer: string;

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "veryfront",
-    "version": "0.0.84",
+    "version": "0.0.88",
     "nodeModulesDir": "auto",
     "exclude": [
         "npm/",
@@ -195,12 +195,12 @@ export 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": "npm:react@19.1.1",
-        "react-dom": "npm:react-dom@19.1.1",
-        "react-dom/server": "npm:react-dom@19.1.1/server",
-        "react-dom/client": "npm:react-dom@19.1.1/client",
-        "react/jsx-runtime": "npm:react@19.1.1/jsx-runtime",
-        "react/jsx-dev-runtime": "npm:react@19.1.1/jsx-dev-runtime",
+        "react": "https://esm.sh/react@19.1.1?target=es2022&deps=csstype@3.2.3",
+        "react-dom": "https://esm.sh/react-dom@19.1.1?external=react&target=es2022&deps=csstype@3.2.3",
+        "react-dom/server": "https://esm.sh/react-dom@19.1.1/server?external=react&target=es2022&deps=csstype@3.2.3",
+        "react-dom/client": "https://esm.sh/react-dom@19.1.1/client?external=react&target=es2022&deps=csstype@3.2.3",
+        "react/jsx-runtime": "https://esm.sh/react@19.1.1/jsx-runtime?external=react&target=es2022&deps=csstype@3.2.3",
+        "react/jsx-dev-runtime": "https://esm.sh/react@19.1.1/jsx-dev-runtime?external=react&target=es2022&deps=csstype@3.2.3",
         "@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",
@@ -264,8 +264,7 @@ export default {
     },
     "tasks": {
         "setup": "deno run --allow-all scripts/setup.ts",
-        "start": "deno run --allow-all scripts/server.ts",
-        "start:clean": "rm -rf .cache/ && deno run --allow-all scripts/server.ts",
+        "start": "rm -rf .cache/ && deno run --allow-all scripts/server.ts",
         "start:headless": "deno run --allow-all scripts/server.ts --headless",
         "proxy": "deno run --allow-net --allow-env --allow-read proxy/main.ts",
         "renderer": "deno run --allow-all --unstable-net --unstable-worker-options src/cli/main.ts dev",

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=client.d.ts.map

package/esm/deps/esm.sh/react-dom@19.1.1/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/deps/esm.sh/react-dom@19.1.1/client.js"],"names":[],"mappings":""}

package/esm/deps/esm.sh/react-dom@19.1.1/client.js

@@ -0,0 +1,5 @@
+/* esm.sh - react-dom@19.1.1/client */
+import "react-dom/X-ZGNzc3R5cGVAMy4yLjMKZXJlYWN0/es2022/react-dom.mjs";
+import "../scheduler@^0.26.0.js";
+export * from "react-dom/X-ZGNzc3R5cGVAMy4yLjMKZXJlYWN0/es2022/client.mjs";
+export { default } from "react-dom/X-ZGNzc3R5cGVAMy4yLjMKZXJlYWN0/es2022/client.mjs";

package/esm/deps/esm.sh/react-dom@19.1.1/server.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=server.d.ts.map

package/esm/deps/esm.sh/react-dom@19.1.1/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../src/deps/esm.sh/react-dom@19.1.1/server.js"],"names":[],"mappings":""}

package/esm/deps/esm.sh/react-dom@19.1.1/server.js

@@ -0,0 +1,5 @@
+/* esm.sh - react-dom@19.1.1/server */
+import "react-dom/X-ZGNzc3R5cGVAMy4yLjMKZXJlYWN0/es2022/cjs/react-dom-server-legacy.browser.production.mjs";
+import "react-dom/X-ZGNzc3R5cGVAMy4yLjMKZXJlYWN0/es2022/cjs/react-dom-server.browser.production.mjs";
+export * from "react-dom/X-ZGNzc3R5cGVAMy4yLjMKZXJlYWN0/es2022/server.mjs";
+export { default } from "react-dom/X-ZGNzc3R5cGVAMy4yLjMKZXJlYWN0/es2022/server.mjs";

package/esm/deps/esm.sh/react@19.1.1/jsx-runtime.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=jsx-runtime.d.ts.map

package/esm/deps/esm.sh/react@19.1.1/jsx-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-runtime.d.ts","sourceRoot":"","sources":["../../../../src/deps/esm.sh/react@19.1.1/jsx-runtime.js"],"names":[],"mappings":""}

package/esm/deps/esm.sh/react@19.1.1/jsx-runtime.js

@@ -0,0 +1,3 @@
+/* esm.sh - react@19.1.1/jsx-runtime */
+export * from "react/X-ZGNzc3R5cGVAMy4yLjMKZXJlYWN0/es2022/jsx-runtime.mjs";
+export { default } from "react/X-ZGNzc3R5cGVAMy4yLjMKZXJlYWN0/es2022/jsx-runtime.mjs";

package/esm/deps/esm.sh/react@19.1.1.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=react@19.1.1.d.ts.map

package/esm/deps/esm.sh/react@19.1.1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react@19.1.1.d.ts","sourceRoot":"","sources":["../../../src/deps/esm.sh/react@19.1.1.js"],"names":[],"mappings":""}

package/esm/deps/esm.sh/react@19.1.1.js

@@ -0,0 +1,3 @@
+/* esm.sh - react@19.1.1 */
+export * from "react/X-ZGNzc3R5cGVAMy4yLjM/es2022/react.mjs";
+export { default } from "react/X-ZGNzc3R5cGVAMy4yLjM/es2022/react.mjs";

package/esm/deps/esm.sh/scheduler@^0.26.0.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=scheduler@%5E0.26.0.d.ts.map

package/esm/deps/esm.sh/scheduler@^0.26.0.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler@^0.26.0.d.ts","sourceRoot":"","sources":["../../../src/deps/esm.sh/scheduler@^0.26.0.js"],"names":[],"mappings":""}

package/esm/deps/esm.sh/scheduler@^0.26.0.js

@@ -0,0 +1,3 @@
+/* esm.sh - scheduler@0.26.0 */
+export * from "scheduler/es2022/scheduler.mjs";
+export { default } from "scheduler/es2022/scheduler.mjs";

package/esm/proxy/main.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=main.d.ts.map

package/esm/proxy/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/proxy/main.ts"],"names":[],"mappings":""}

package/esm/proxy/main.js

@@ -0,0 +1,400 @@
+/**
+ * Veryfront Proxy Server (Split Mode)
+ *
+ * Standalone proxy server that forwards requests to a separate renderer process.
+ * Used in production for security isolation of OAuth credentials.
+ *
+ * For combined mode (single process), use the renderer with --proxy flag instead.
+ *
+ * Environment Variables:
+ * - API_CLIENT_ID_VERYFRONT_RENDERER_PROXY: OAuth client ID (from 1Password)
+ * - API_CLIENT_SECRET_VERYFRONT_RENDERER_PROXY: OAuth client secret (from 1Password)
+ * - RENDERER_URL: URL of the renderer service
+ * - LOCAL_PROJECTS: JSON map of slug → filesystem path (for dev)
+ * - CACHE_TYPE: "memory" (default) or "redis"
+ * - REDIS_URL: Redis connection URL (required if CACHE_TYPE=redis)
+ */
+import * as dntShim from "../_dnt.shims.js";
+import { createProxyHandler } from "./handler.js";
+import { createCacheFromEnv } from "./cache/index.js";
+import { endSpan, extractContext, initializeOTLPWithApis, injectContext, ProxySpanNames, shutdownOTLP, startServerSpan, withContext, withSpan, } from "./tracing.js";
+import { proxyLogger } from "./logger.js";
+import { parseProjectDomain } from "../src/server/utils/domain-parser.js";
+import { exit, getEnv, onSignal } from "../src/platform/compat/process.js";
+import { createHttpServer, upgradeWebSocket } from "../src/platform/compat/http/index.js";
+// Configuration from environment variables
+const config = {
+    apiBaseUrl: getEnv("VERYFRONT_API_BASE_URL") ||
+        "http://api.lvh.me:4000",
+    clientId: getEnv("API_CLIENT_ID_VERYFRONT_RENDERER_PROXY") || "",
+    clientSecret: getEnv("API_CLIENT_SECRET_VERYFRONT_RENDERER_PROXY") || "",
+    // Preview uses same service account (scopes determine access)
+    previewClientId: getEnv("API_CLIENT_ID_VERYFRONT_RENDERER_PROXY") || "",
+    previewClientSecret: getEnv("API_CLIENT_SECRET_VERYFRONT_RENDERER_PROXY") || "",
+    localProjects: getEnv("LOCAL_PROJECTS") ? JSON.parse(getEnv("LOCAL_PROJECTS")) : {},
+};
+const RENDERER_URL = getEnv("RENDERER_URL") || "http://localhost:3001";
+const PORT = parseInt(getEnv("PORT") || "8080");
+const HOST = getEnv("HOST") || "0.0.0.0"; // Default to 0.0.0.0 for Kubernetes
+const WS_CONNECT_TIMEOUT_MS = 30000;
+// Timeout for forwarding requests to renderer (SSR can take time on cold start)
+const RENDERER_REQUEST_TIMEOUT_MS = parseInt(getEnv("RENDERER_REQUEST_TIMEOUT_MS") || "90000");
+// Initialize cache and proxy handler
+const cache = await createCacheFromEnv();
+const proxyHandler = createProxyHandler({
+    config,
+    cache,
+    logger: {
+        debug: (msg, extra) => proxyLogger.debug(msg, extra),
+        info: (msg, extra) => proxyLogger.info(msg, extra),
+        warn: (msg, extra) => proxyLogger.warn(msg, extra),
+        error: (msg, error, extra) => proxyLogger.error(msg, extra ?? {}, error),
+    },
+});
+// Validate configuration on startup
+const missingCredentials = proxyHandler.validateConfig();
+if (missingCredentials.length > 0) {
+    proxyLogger.warn("Missing OAuth credentials", { missingCredentials });
+    proxyLogger.warn("Proxy will forward requests without authentication");
+}
+// Log local projects if configured
+if (Object.keys(proxyHandler.localProjects).length > 0) {
+    proxyLogger.info("Local projects configured", {
+        projects: Object.keys(proxyHandler.localProjects),
+    });
+}
+/**
+ * Handle WebSocket upgrade requests.
+ * Bridges browser WebSocket to renderer's HMR WebSocket endpoint.
+ */
+function handleWebSocketUpgrade(req) {
+    const url = new URL(req.url);
+    const host = req.headers.get("host") || "";
+    // Parse domain to extract project slug and environment
+    const parsed = parseProjectDomain(host);
+    const scope = parsed.environment === "preview" ? "preview" : "production";
+    const projectSlug = parsed.slug || undefined;
+    // Build renderer WebSocket URL
+    const rendererWsUrl = RENDERER_URL.replace(/^http/, "ws");
+    const targetUrl = new URL(`${rendererWsUrl}${url.pathname}${url.search}`);
+    targetUrl.searchParams.set("x-project-slug", projectSlug || "");
+    targetUrl.searchParams.set("x-environment", scope);
+    proxyLogger.info("[WebSocket] Upgrade request received", {
+        host,
+        path: url.pathname,
+        projectSlug,
+        environment: scope,
+        parsedEnvironment: parsed.environment,
+        targetUrl: targetUrl.toString(),
+    });
+    const { socket: clientSocket, response } = upgradeWebSocket(req);
+    let rendererSocket = null;
+    let connectTimeoutId = null;
+    let timedOut = false;
+    const clearConnectTimeout = () => {
+        if (connectTimeoutId) {
+            clearTimeout(connectTimeoutId);
+            connectTimeoutId = null;
+        }
+    };
+    clientSocket.onopen = () => {
+        proxyLogger.info("[WebSocket] Client connected, bridging to renderer", {
+            targetUrl: targetUrl.toString(),
+        });
+        try {
+            rendererSocket = new WebSocket(targetUrl.toString());
+        }
+        catch (error) {
+            proxyLogger.error("[WebSocket] Failed to create renderer WebSocket", {
+                error: error instanceof Error ? error.message : String(error),
+                targetUrl: targetUrl.toString(),
+            });
+            clientSocket.close(1011, "Failed to connect to renderer");
+            return;
+        }
+        connectTimeoutId = dntShim.setTimeout(() => {
+            timedOut = true;
+            proxyLogger.error("[WebSocket] Renderer connection timeout", {
+                targetUrl: targetUrl.toString(),
+                timeoutMs: WS_CONNECT_TIMEOUT_MS,
+            });
+            rendererSocket?.close();
+            if (clientSocket.readyState === WebSocket.OPEN) {
+                clientSocket.close(1001, "Renderer connection timeout");
+            }
+        }, WS_CONNECT_TIMEOUT_MS);
+        rendererSocket.onopen = () => {
+            clearConnectTimeout();
+            if (timedOut) {
+                rendererSocket?.close();
+                return;
+            }
+            proxyLogger.info("[WebSocket] Renderer connected, bridge established", {
+                projectSlug,
+                environment: scope,
+            });
+        };
+        rendererSocket.onmessage = (event) => {
+            if (clientSocket.readyState === WebSocket.OPEN) {
+                clientSocket.send(event.data);
+            }
+        };
+        rendererSocket.onerror = (event) => {
+            clearConnectTimeout();
+            proxyLogger.error("[WebSocket] Renderer connection error", {
+                projectSlug,
+                environment: scope,
+                targetUrl: targetUrl.toString(),
+                error: event instanceof ErrorEvent ? event.message : "Unknown error",
+            });
+        };
+        rendererSocket.onclose = (event) => {
+            clearConnectTimeout();
+            proxyLogger.info("[WebSocket] Renderer connection closed", {
+                code: event.code,
+                reason: event.reason,
+                wasClean: event.wasClean,
+            });
+            if (clientSocket.readyState === WebSocket.OPEN) {
+                clientSocket.close(event.code, event.reason);
+            }
+        };
+    };
+    clientSocket.onmessage = (event) => {
+        if (rendererSocket?.readyState === WebSocket.OPEN) {
+            rendererSocket.send(event.data);
+        }
+    };
+    clientSocket.onerror = (event) => {
+        clearConnectTimeout();
+        proxyLogger.error("[WebSocket] Client connection error", {
+            error: event instanceof ErrorEvent ? event.message : "Unknown error",
+        });
+    };
+    clientSocket.onclose = (event) => {
+        clearConnectTimeout();
+        proxyLogger.info("[WebSocket] Client connection closed", {
+            code: event.code,
+            reason: event.reason,
+            wasClean: event.wasClean,
+        });
+        if (rendererSocket?.readyState === WebSocket.OPEN) {
+            rendererSocket.close();
+        }
+    };
+    return response;
+}
+function jsonErrorResponse(status, body) {
+    return new dntShim.Response(JSON.stringify(body), {
+        status,
+        headers: { "Content-Type": "application/json" },
+    });
+}
+function forwardToRenderer(req) {
+    const startTime = performance.now();
+    const url = new URL(req.url);
+    const parentContext = extractContext(req.headers);
+    const spanInfo = startServerSpan(req.method, url.pathname, parentContext);
+    const execute = async () => {
+        try {
+            const ctx = await proxyHandler.processRequest(req);
+            if (ctx.error) {
+                const ms = Math.round(performance.now() - startTime);
+                proxyLogger.error(`${ctx.error.status} ${req.method} ${url.pathname}`, {
+                    ms,
+                    domain: ctx.host,
+                });
+                endSpan(spanInfo?.span, ctx.error.status);
+                // Handle redirect for protected environments
+                if (ctx.error.redirectUrl) {
+                    return new dntShim.Response(null, {
+                        status: 302,
+                        headers: { Location: ctx.error.redirectUrl },
+                    });
+                }
+                return jsonErrorResponse(ctx.error.status, {
+                    error: ctx.error.message,
+                    status: ctx.error.status,
+                });
+            }
+            const reqLogger = proxyLogger.child({
+                ...(ctx.projectSlug && { project: ctx.projectSlug }),
+                env: ctx.environment,
+            });
+            const newHeaders = new dntShim.Headers(req.headers);
+            if (ctx.token)
+                newHeaders.set("x-token", ctx.token);
+            newHeaders.set("x-project-slug", ctx.projectSlug || "");
+            newHeaders.set("x-environment", ctx.environment);
+            newHeaders.set("x-forwarded-host", ctx.host);
+            if (ctx.localPath)
+                newHeaders.set("x-project-path", ctx.localPath);
+            // Forward project/release context for cache keying
+            if (ctx.projectId)
+                newHeaders.set("x-project-id", ctx.projectId);
+            if (ctx.releaseId)
+                newHeaders.set("x-release-id", ctx.releaseId);
+            if (ctx.branchId)
+                newHeaders.set("x-branch-id", ctx.branchId);
+            if (ctx.branchName)
+                newHeaders.set("x-branch-name", ctx.branchName);
+            newHeaders.delete("host");
+            injectContext(newHeaders);
+            const rendererUrl = new URL(url.pathname + url.search, RENDERER_URL);
+            // Create abort controller for timeout
+            const abortController = new AbortController();
+            const timeoutId = dntShim.setTimeout(() => {
+                abortController.abort();
+            }, RENDERER_REQUEST_TIMEOUT_MS);
+            let response;
+            try {
+                response = await withSpan(ProxySpanNames.HTTP_CLIENT_FETCH, () => dntShim.fetch(rendererUrl.toString(), {
+                    method: req.method,
+                    headers: newHeaders,
+                    body: req.body,
+                    redirect: "manual",
+                    signal: abortController.signal,
+                }), {
+                    "http.method": req.method,
+                    "http.url": rendererUrl.toString(),
+                    "http.host": rendererUrl.host,
+                    "proxy.target": "renderer",
+                    "proxy.project_slug": ctx.projectSlug || "",
+                    "proxy.timeout_ms": RENDERER_REQUEST_TIMEOUT_MS,
+                });
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+            const ms = Math.round(performance.now() - startTime);
+            reqLogger.info(`${response.status} ${req.method} ${url.pathname}`, { ms });
+            endSpan(spanInfo?.span, response.status);
+            return new dntShim.Response(response.body, {
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+            });
+        }
+        catch (error) {
+            const ms = Math.round(performance.now() - startTime);
+            // Handle timeout specifically
+            if (error instanceof Error && error.name === "AbortError") {
+                proxyLogger.error(`504 ${req.method} ${url.pathname}`, {
+                    ms,
+                    timeoutMs: RENDERER_REQUEST_TIMEOUT_MS,
+                });
+                endSpan(spanInfo?.span, 504, error);
+                return jsonErrorResponse(504, {
+                    error: "Gateway Timeout",
+                    message: `Renderer request timed out after ${RENDERER_REQUEST_TIMEOUT_MS}ms`,
+                });
+            }
+            proxyLogger.error(`502 ${req.method} ${url.pathname}`, { ms }, error);
+            endSpan(spanInfo?.span, 502, error);
+            return jsonErrorResponse(502, {
+                error: "Proxy Error",
+                message: error instanceof Error ? error.message : "Unknown error",
+            });
+        }
+    };
+    return spanInfo?.context ? withContext(spanInfo.context, execute) : execute();
+}
+/**
+ * Handle stats endpoint for monitoring.
+ */
+async function handleStats() {
+    const stats = await proxyHandler.getStats();
+    return new dntShim.Response(JSON.stringify(stats, null, 2), {
+        headers: { "Content-Type": "application/json" },
+    });
+}
+/**
+ * Proxy API requests directly to Veryfront API (BFF pattern).
+ * Routes: /_vf/api/* -> api.veryfront.com/*
+ */
+async function handleApiProxy(req) {
+    const url = new URL(req.url);
+    const token = await proxyHandler.getTokenForApi(req);
+    if (!token) {
+        return jsonErrorResponse(401, { error: "No authentication token" });
+    }
+    // Strip /_vf/api prefix and forward to API
+    const apiPath = url.pathname.replace(/^\/_vf\/api/, "");
+    const apiUrl = `${config.apiBaseUrl}${apiPath}${url.search}`;
+    const apiUrlObj = new URL(apiUrl);
+    try {
+        const response = await withSpan(ProxySpanNames.HTTP_CLIENT_FETCH, () => dntShim.fetch(apiUrl, {
+            method: req.method,
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: "application/json",
+                "Content-Type": req.headers.get("Content-Type") || "application/json",
+            },
+            body: req.method !== "GET" && req.method !== "HEAD" ? req.body : undefined,
+        }), {
+            "http.method": req.method,
+            "http.url": apiUrl,
+            "http.host": apiUrlObj.host,
+            "proxy.target": "api",
+            "proxy.api_path": apiPath,
+        });
+        return new dntShim.Response(response.body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: {
+                "Content-Type": response.headers.get("Content-Type") ||
+                    "application/json",
+                "Cache-Control": "no-cache",
+            },
+        });
+    }
+    catch (error) {
+        proxyLogger.error("API proxy error", error);
+        return jsonErrorResponse(502, {
+            error: error instanceof Error ? error.message : "API request failed",
+        });
+    }
+}
+/**
+ * Main router.
+ */
+function router(req) {
+    const url = new URL(req.url);
+    // WebSocket upgrade
+    if (req.headers.get("upgrade")?.toLowerCase() === "websocket") {
+        return Promise.resolve(handleWebSocketUpgrade(req));
+    }
+    // Proxy endpoints
+    if (url.pathname === "/_proxy/stats") {
+        return handleStats();
+    }
+    if (url.pathname === "/_proxy/health") {
+        return Promise.resolve(new dntShim.Response("OK", { status: 200 }));
+    }
+    // BFF: Proxy API requests directly to Veryfront API
+    if (url.pathname.startsWith("/_vf/api/")) {
+        return handleApiProxy(req);
+    }
+    // Forward all other requests to renderer
+    return forwardToRenderer(req);
+}
+// Graceful shutdown
+async function shutdown() {
+    proxyLogger.info("Shutting down");
+    await proxyHandler.close();
+    await shutdownOTLP();
+    proxyLogger.info("Closed connections");
+    exit(0);
+}
+onSignal("SIGINT", shutdown);
+onSignal("SIGTERM", shutdown);
+// Initialize tracing and start server
+await initializeOTLPWithApis();
+proxyLogger.debug("Starting proxy server (split mode)", {
+    port: PORT,
+    rendererUrl: RENDERER_URL,
+    apiBaseUrl: config.apiBaseUrl,
+});
+// Create and start the HTTP server
+const server = createHttpServer();
+await server.serve(router, { port: PORT, hostname: HOST });

package/esm/src/agent/react/use-agent.js

@@ -1,5 +1,5 @@
 import * as dntShim from "../../../_dnt.shims.js";
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useRef, useState } from "../../../deps/esm.sh/react@19.1.1.js";
 import { createError, ensureError, toError } from "../../errors/veryfront-error.js";
 export function useAgent(options) {
     const [messages, setMessages] = useState([]);

package/esm/src/agent/react/use-chat/use-chat.js

@@ -8,7 +8,7 @@
  * for battle-tested implementation. This is a simplified reference implementation.
  */
 import * as dntShim from "../../../../_dnt.shims.js";
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useRef, useState } from "../../../../deps/esm.sh/react@19.1.1.js";
 import { createError, ensureError, toError } from "../../../errors/veryfront-error.js";
 import { handleStreamingResponse } from "./streaming/index.js";
 import { generateClientId } from "./utils.js";

package/esm/src/agent/react/use-completion.js

@@ -4,7 +4,7 @@
  * Single text completion with streaming support.
  */
 import * as dntShim from "../../../_dnt.shims.js";
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useRef, useState } from "../../../deps/esm.sh/react@19.1.1.js";
 import { createError, toError } from "../../errors/veryfront-error.js";
 /**
  * useCompletion hook for single text generation

package/esm/src/agent/react/use-streaming.js

@@ -1,5 +1,5 @@
 import * as dntShim from "../../../_dnt.shims.js";
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useRef, useState } from "../../../deps/esm.sh/react@19.1.1.js";
 import { createError, toError } from "../../errors/veryfront-error.js";
 export function useStreaming(options) {
     const [data, setData] = useState("");

package/esm/src/agent/react/use-voice-input.js

@@ -1,5 +1,5 @@
 import * as dntShim from "../../../_dnt.shims.js";
-import * as React from "react";
+import * as React from "../../../deps/esm.sh/react@19.1.1.js";
 export function useVoiceInput(options = {}) {
     const { language, continuous = false, interimResults = true, onTranscript, onError, onStart, onEnd, } = options;
     const [isListening, setIsListening] = React.useState(false);

package/esm/src/cli/app/components/list-select.js

@@ -123,9 +123,9 @@ export function renderList(state, options = {}) {
         }
     }
     if (start > 0)
-        lines.unshift(`  ${dim("↑ more above")}`);
+        lines.unshift(`   ${dim("↑")}  ${dim("more above")}`);
     if (end < state.items.length)
-        lines.push(`  ${dim("↓ more below")}`);
+        lines.push(`   ${dim("↓")}  ${dim("more below")}`);
     return lines.join("\n");
 }
 /**