@agent-native/core 0.201.0 → 0.201.1

package/dist/server/entry-server.js

@@ -2,8 +2,49 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import ReactDOMServer from "react-dom/server.browser";
 const { renderToReadableStream } = ReactDOMServer;
 import { isbot } from "isbot";
+import { ROUTE_CHUNK_RECOVERY_BOOTSTRAP_SCRIPT } from "../shared/route-chunk-recovery-bootstrap.js";
 import { wrapWithAnalytics } from "./analytics.js";
 export const streamTimeout = 5_000;
+const HEAD_OPEN_PATTERN = /<head\b[^>]*>/i;
+const CHUNK_RECOVERY_BOOTSTRAP_TAG = `<script data-agent-native-chunk-recovery-bootstrap>${ROUTE_CHUNK_RECOVERY_BOOTSTRAP_SCRIPT}</script>`;
+function installEarlyChunkRecoveryBootstrap(body) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let pending = "";
+    let injected = false;
+    return body.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            pending += decoder.decode(chunk, { stream: true });
+            if (!injected) {
+                const headOpenMatch = HEAD_OPEN_PATTERN.exec(pending);
+                if (!headOpenMatch || headOpenMatch.index === undefined)
+                    return;
+                const headEnd = headOpenMatch.index + headOpenMatch[0].length;
+                controller.enqueue(encoder.encode(pending.slice(0, headEnd) + CHUNK_RECOVERY_BOOTSTRAP_TAG));
+                pending = pending.slice(headEnd);
+                injected = true;
+            }
+            if (pending) {
+                controller.enqueue(encoder.encode(pending));
+                pending = "";
+            }
+        },
+        flush(controller) {
+            pending += decoder.decode();
+            if (!injected) {
+                const headOpenMatch = HEAD_OPEN_PATTERN.exec(pending);
+                if (headOpenMatch && headOpenMatch.index !== undefined) {
+                    const headEnd = headOpenMatch.index + headOpenMatch[0].length;
+                    controller.enqueue(encoder.encode(pending.slice(0, headEnd) + CHUNK_RECOVERY_BOOTSTRAP_TAG));
+                    pending = pending.slice(headEnd);
+                    injected = true;
+                }
+            }
+            if (pending)
+                controller.enqueue(encoder.encode(pending));
+        },
+    }));
+}
 export function createDocumentRequestHandler(ServerRouter) {
     return async function handleDocumentRequest(request, responseStatusCode, responseHeaders, routerContext, _loadContext) {
         if (request.method.toUpperCase() === "HEAD") {
@@ -33,8 +74,8 @@ export function createDocumentRequestHandler(ServerRouter) {
             if (waitForAll) {
                 await body.allReady;
             }
-            responseHeaders.set("Content-Type", "text/html");
-            return new Response(wrapWithAnalytics(body), {
+            responseHeaders.set("Content-Type", "text/html; charset=utf-8");
+            return new Response(wrapWithAnalytics(installEarlyChunkRecoveryBootstrap(body)), {
                 headers: responseHeaders,
                 status: responseStatusCode,
             });

package/dist/server/sentry.js

@@ -258,8 +258,10 @@ export function setSentryRequestContext(ctx) {
 export function captureAuthError(error, context) {
     if (getRequestContext()?.isSyntheticTraffic)
         return undefined;
-    if (!_initSucceeded || !Sentry)
+    if (!_initSucceeded || !Sentry) {
+        logSignupErrorWhenSentryUnavailable(context.route);
         return undefined;
+    }
     const sentry = Sentry;
     try {
         return sentry.withScope((scope) => {
@@ -274,9 +276,15 @@ export function captureAuthError(error, context) {
         });
     }
     catch {
+        logSignupErrorWhenSentryUnavailable(context.route);
         return undefined;
     }
 }
+function logSignupErrorWhenSentryUnavailable(route) {
+    if (route !== "signup")
+        return;
+    console.error("[agent-native][auth] signup error (Sentry unavailable)");
+}
 export function captureRouteError(error, context = {}) {
     if (getRequestContext()?.isSyntheticTraffic)
         return undefined;

package/dist/server/ssr-handler.d.ts

@@ -1,2 +1,2 @@
-export { DEFAULT_SSR_CACHE_HEADERS, DEFAULT_SPECULATION_RULES_HEADER, DEFAULT_SSR_CACHE_CONTROL, DISABLED_SSR_CACHE_HEADERS, isSsrCacheEnabled, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, SSR_CACHE_ENV_VAR, } from "../shared/cache-control.js";
+export { DEFAULT_SSR_CACHE_HEADERS, DEFAULT_SPECULATION_RULES_HEADER, DEFAULT_SSR_CACHE_CONTROL, DISABLED_SSR_CACHE_HEADERS, isSsrCacheEnabled, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, resolveSsrNetlifyQueryVary, SSR_CACHE_ENV_VAR, } from "../shared/cache-control.js";
 export declare function createH3SSRHandler(getBuild: () => unknown): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<Response>>;

package/dist/server/ssr-handler.js

@@ -13,7 +13,7 @@ import { getFrameworkRoutePrefix } from "./framework-route-prefix.js";
 import { getPostHogClientConfigScript } from "./posthog-config.js";
 import { runWithRequestContext } from "./request-context.js";
 import { getRealtimeClientConfigScript, getSentryClientConfigScript, } from "./sentry-config.js";
-export { DEFAULT_SSR_CACHE_HEADERS, DEFAULT_SPECULATION_RULES_HEADER, DEFAULT_SSR_CACHE_CONTROL, DISABLED_SSR_CACHE_HEADERS, isSsrCacheEnabled, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, SSR_CACHE_ENV_VAR, } from "../shared/cache-control.js";
+export { DEFAULT_SSR_CACHE_HEADERS, DEFAULT_SPECULATION_RULES_HEADER, DEFAULT_SSR_CACHE_CONTROL, DISABLED_SSR_CACHE_HEADERS, isSsrCacheEnabled, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, resolveSsrNetlifyQueryVary, SSR_CACHE_ENV_VAR, } from "../shared/cache-control.js";
 function getAppBasePath() {
     return getAppBasePathFromViteEnv();
 }
@@ -215,12 +215,8 @@ function applyDefaultSsrCacheHeader(headers, status, pathname) {
     for (const [name, value] of Object.entries(resolveSsrCacheHeaders())) {
         headers.set(name, value);
     }
-    const cacheKeyHeaders = resolveSsrCacheKeyHeaders();
-    const netlifyVary = varyByQuery
-        ? cacheKeyHeaders["netlify-vary"]
-            ? "query"
-            : undefined
-        : cacheKeyHeaders["netlify-vary"];
+    const cacheKeyHeaders = resolveSsrCacheKeyHeaders(undefined, { varyByQuery });
+    const netlifyVary = cacheKeyHeaders["netlify-vary"];
     if (netlifyVary)
         headers.set("netlify-vary", netlifyVary);
     else

package/dist/shared/cache-control.d.ts

@@ -32,7 +32,10 @@ export type SsrCacheHeaders = Record<"cache-control" | "cdn-cache-control" | "ne
 export declare function parseSsrCacheSetting(raw: string | undefined | null): SsrCachePolicy;
 export declare function ssrCacheHeadersForPolicy(policy: SsrCachePolicy): SsrCacheHeaders;
 export declare function resolveSsrCacheHeaders(env?: Record<string, string | undefined>): Readonly<SsrCacheHeaders>;
-export declare function resolveSsrCacheKeyHeaders(env?: Record<string, string | undefined>): Readonly<Record<string, string>>;
+export declare function resolveSsrNetlifyQueryVary(varyByQuery?: boolean): string;
+export declare function resolveSsrCacheKeyHeaders(env?: Record<string, string | undefined>, options?: {
+    varyByQuery?: boolean;
+}): Readonly<Record<string, string>>;
 export declare function isSsrCacheEnabled(env?: Record<string, string | undefined>): boolean;
 export declare const DEFAULT_SPECULATION_RULES_PATH = "/_agent-native/speculation-rules.json";
 export declare const DEFAULT_SPECULATION_RULES_HEADER = "\"/_agent-native/speculation-rules.json\"";

package/dist/shared/cache-control.js

@@ -1,3 +1,4 @@
+import { CHUNK_RECOVERY_QUERY_PARAM } from "./route-chunk-recovery-bootstrap.js";
 export const DEFAULT_PUBLIC_CACHE_CONTROL = "public, max-age=600, stale-while-revalidate=604800, stale-if-error=3600";
 export const DEFAULT_SSR_CACHE_CONTROL = DEFAULT_PUBLIC_CACHE_CONTROL;
 export const DEFAULT_SSR_CDN_CACHE_CONTROL = DEFAULT_SSR_CACHE_CONTROL;
@@ -83,19 +84,23 @@ export function resolveSsrCacheHeaders(env = typeof process === "undefined"
     memoizedHeaders = Object.freeze(ssrCacheHeadersForPolicy(parseSsrCacheSetting(raw)));
     return memoizedHeaders;
 }
+export function resolveSsrNetlifyQueryVary(varyByQuery = false) {
+    if (varyByQuery)
+        return "query";
+    return `query=_routes|index|${CHUNK_RECOVERY_QUERY_PARAM}`;
+}
 export function resolveSsrCacheKeyHeaders(env = typeof process === "undefined"
     ? {}
-    : process.env) {
+    : process.env, options = {}) {
     const explicitlyNotNetlify = env.NETLIFY_LOCAL === "true" || env.NETLIFY === "false";
     const onNetlify = !explicitlyNotNetlify && (Boolean(env.NETLIFY) || Boolean(env.SITE_ID)); // guard:allow-env-credential -- Netlify's public runtime host marker, not a credential.
     const none = Object.freeze({});
     if (!onNetlify)
         return none;
-    // This NARROWS the cache key rather than splitting it per user: it removes
-    // utm/fbclid/gclid so one entry serves everyone. The shapes the guard exists
-    // to stop are `private`, `no-store` and `Vary: Cookie`, none of which this is.
-    // guard:allow-ssr-shell-exception — narrows the shared key, never splits it
-    return Object.freeze({ "netlify-vary": "query=_routes|index" });
+    return Object.freeze({
+        // guard:allow-ssr-shell-exception — one fixed, public recovery cache-key variant
+        "netlify-vary": resolveSsrNetlifyQueryVary(options.varyByQuery),
+    });
 }
 export function isSsrCacheEnabled(env = typeof process === "undefined"
     ? {}

package/dist/shared/route-chunk-recovery-bootstrap.d.ts

@@ -0,0 +1,7 @@
+export declare const STALE_CHUNK_RELOAD_AT_KEY = "__agentNativeStaleChunkReloadAt";
+export declare const STALE_CHUNK_RELOAD_COOLDOWN_MS = 10000;
+export declare const CHUNK_RECOVERY_QUERY_PARAM = "__agentNativeChunkRecovery";
+export declare const CHUNK_RECOVERY_QUERY_VALUE = "1";
+export declare const CHUNK_RECOVERY_CACHE_BUSTER_PARAM = "__agentNativeChunkRecoveryRequest";
+export declare const ROUTE_WARMUP_PRELOAD_ATTRIBUTE = "data-agent-native-route-warmup";
+export declare const ROUTE_CHUNK_RECOVERY_BOOTSTRAP_SCRIPT: string;

package/dist/shared/route-chunk-recovery-bootstrap.js

@@ -0,0 +1,38 @@
+export const STALE_CHUNK_RELOAD_AT_KEY = "__agentNativeStaleChunkReloadAt";
+export const STALE_CHUNK_RELOAD_COOLDOWN_MS = 10_000;
+export const CHUNK_RECOVERY_QUERY_PARAM = "__agentNativeChunkRecovery";
+export const CHUNK_RECOVERY_QUERY_VALUE = "1";
+export const CHUNK_RECOVERY_CACHE_BUSTER_PARAM = "__agentNativeChunkRecoveryRequest";
+export const ROUTE_WARMUP_PRELOAD_ATTRIBUTE = "data-agent-native-route-warmup";
+export const ROUTE_CHUNK_RECOVERY_BOOTSTRAP_SCRIPT = `(()=>{
+const queryParam=${JSON.stringify(CHUNK_RECOVERY_QUERY_PARAM)};
+const queryValue=${JSON.stringify(CHUNK_RECOVERY_QUERY_VALUE)};
+const cacheBusterParam=${JSON.stringify(CHUNK_RECOVERY_CACHE_BUSTER_PARAM)};
+const reloadKey=${JSON.stringify(STALE_CHUNK_RELOAD_AT_KEY)};
+const warmupAttr=${JSON.stringify(ROUTE_WARMUP_PRELOAD_ATTRIBUTE)};
+document.addEventListener("error",event=>{
+const target=event.target;
+const tag=target?.tagName?.toUpperCase();
+const failedModuleScript=tag==="SCRIPT"&&target.type?.toLowerCase()==="module";
+const failedModulePreload=tag==="LINK"&&/(?:^|\\s)modulepreload(?:\\s|$)/i.test(target.getAttribute?.("rel")||target.rel||"")&&!target.hasAttribute?.(warmupAttr);
+if(!failedModuleScript&&!failedModulePreload||/AgentNativeDesktop/i.test(navigator.userAgent))return;
+if(/^(localhost|127\\.0\\.0\\.1|\\[::1\\])$/.test(location.hostname))return;
+const url=new URL(location.href);
+if(url.searchParams.get(queryParam)===queryValue)return;
+const now=Date.now();
+let last=Number(window[reloadKey])||0;
+try{
+last=Math.max(last,Number(sessionStorage.getItem(reloadKey))||0);
+if(last>0&&now-last<=${STALE_CHUNK_RELOAD_COOLDOWN_MS})return;
+sessionStorage.setItem(reloadKey,String(now));
+}catch{
+last=Number(window[reloadKey])||0;
+if(last>0&&now-last<=${STALE_CHUNK_RELOAD_COOLDOWN_MS})return;
+}
+window[reloadKey]=now;
+url.searchParams.set(queryParam,queryValue);
+url.searchParams.set(cacheBusterParam,Date.now().toString(36)+"-"+Math.random().toString(36).slice(2));
+location.assign(url.href);
+event.stopImmediatePropagation();
+},true);
+})();`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.201.0",
+  "version": "0.201.1",
   "description": "The agentic application framework for building autonomous agents with intuitive UIs",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -458,6 +458,7 @@
     "./triggers": "./dist/triggers/index.js",
     "./terminal": "./dist/client/terminal/index.js",
     "./terminal/server": "./dist/terminal/index.js",
+    "./terminal/pty-server": "./dist/terminal/pty-server.js",
     "./tailwind": "./dist/tailwind.preset.js",
     "./agent/engine": "./dist/agent/engine/index.js",
     "./agent/engine/error-detail": "./dist/agent/engine/error-detail.js",
@@ -578,6 +579,7 @@
     "./shared/app-status": "./dist/shared/app-status.js",
     "./shared/auth-page-types": "./dist/shared/auth-page-types.js",
     "./shared/builder-referrals": "./dist/shared/builder-referrals.js",
+    "./shared/chat-first-app-creation": "./dist/shared/chat-first-app-creation.js",
     "./shared/context-xray": "./dist/shared/context-xray.js",
     "./shared/docs-url": "./dist/shared/docs-url.js",
     "./shared/document-title": "./dist/shared/document-title.js",
@@ -669,8 +671,8 @@
     "yaml": "^2.9.0",
     "yjs": "^13.6.33",
     "zod": "^4.3.6",
-    "@agent-native/agentkit": "^0.201.0",
-    "@agent-native/recap-cli": "^0.5.61"
+    "@agent-native/agentkit": "^0.201.1",
+    "@agent-native/recap-cli": "^0.5.62"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.71",