@agent-native/core 0.90.2 → 0.90.4

package/corpus/core/src/agent/engine/registry.ts

@@ -12,6 +12,7 @@ import { createRequire } from "node:module";
 
 import {
   canUseDeployCredentialFallbackForRequest,
+  getProviderCredentialAuthFailure,
   readDeployCredentialEnv,
   resolveBuilderCredentials,
   resolveSecret,
@@ -155,6 +156,10 @@ function assertAgentEnginePackageInstalled(entry: AgentEngineEntry): void {
  * on the first pass, so an explicit provider key (ANTHROPIC_API_KEY etc.)
  * is picked instead. Builder is still used as the fallback when no other
  * provider key is set.
+ *
+ * This sync helper is for CLI/status callers that cannot await settings. Prefer
+ * {@link detectEngineFromEnvForRequest} at request time so sticky auth-failure
+ * markers can skip rejected deploy keys.
  */
 export function detectEngineFromEnv(): AgentEngineEntry | null {
   const preferByo = /^(1|true)$/i.test(
@@ -195,6 +200,59 @@ export function detectEngineFromEnv(): AgentEngineEntry | null {
   return null;
 }
 
+async function envKeyUsableForEntry(
+  entry: AgentEngineEntry,
+  key: string,
+): Promise<boolean> {
+  if (
+    !(
+      canUseDeployCredentialFallbackForRequest(key) &&
+      !!readDeployCredentialEnv(key)
+    )
+  ) {
+    return false;
+  }
+  if (entry.name === "builder") {
+    return true;
+  }
+  const value = readDeployCredentialEnv(key);
+  if (!value) return false;
+  return !(await getProviderCredentialAuthFailure({ key, value }));
+}
+
+async function hasUsableEnvKeys(entry: AgentEngineEntry): Promise<boolean> {
+  if (!isAgentEnginePackageInstalled(entry)) return false;
+  if (entry.requiredEnvVars.length === 0) return false;
+  for (const key of entry.requiredEnvVars) {
+    if (!(await envKeyUsableForEntry(entry, key))) return false;
+  }
+  return true;
+}
+
+/**
+ * Request-aware env auto-detect. Same priority as {@link detectEngineFromEnv},
+ * but skips provider keys that currently have an auth-failure marker so a
+ * rejected deploy key does not permanently win selection and leave chat stuck
+ * on `missing_credentials`.
+ */
+export async function detectEngineFromEnvForRequest(): Promise<AgentEngineEntry | null> {
+  const preferByo = /^(1|true)$/i.test(
+    process.env.AGENT_ENGINE_PREFER_BYO_KEY ?? "",
+  );
+
+  if (preferByo) {
+    for (const entry of _registry.values()) {
+      if (entry.name === "builder") continue;
+      if (await hasUsableEnvKeys(entry)) return entry;
+    }
+  }
+
+  for (const entry of _registry.values()) {
+    if (await hasUsableEnvKeys(entry)) return entry;
+  }
+  return null;
+}
+
 function shouldTraceEngineDetection(): boolean {
   return /^(1|true)$/i.test(
     process.env.AGENT_NATIVE_DEBUG_AGENT_ENGINE_DETECT ??
@@ -260,7 +318,7 @@ export async function detectEngineFromUserSecrets(): Promise<AgentEngineEntry |
     }
     for (const key of entry.requiredEnvVars) {
       try {
-        if (!(await resolveSecret(key))) return false;
+        if (!(await resolveUsableProviderSecret(key))) return false;
       } catch {
         return false;
       }
@@ -366,6 +424,15 @@ async function resolveOpenAiBaseUrl(): Promise<string | undefined> {
   return raw ? normalizeOpenAiBaseUrl(raw) : undefined;
 }
 
+async function resolveUsableProviderSecret(
+  key: string,
+): Promise<string | null> {
+  const value = await resolveSecret(key);
+  if (!value) return null;
+  const authFailure = await getProviderCredentialAuthFailure({ key, value });
+  return authFailure ? null : value;
+}
+
 async function engineCreateConfigForEntry(
   entry: AgentEngineEntry,
   apiKey: string | undefined,
@@ -389,6 +456,9 @@ async function engineCreateConfigForEntry(
  * AND an API key for it is reachable via the engine's required env vars.
  * Inline keys on the global settings row are ignored; see
  * `isAgentEngineSettingConfigured`.
+ *
+ * Sync helper for CLI/status. Prefer {@link isStoredEngineUsableForRequest}
+ * so sticky auth-failure markers are respected.
  */
 export function isStoredEngineUsable(
   stored: unknown,
@@ -425,16 +495,11 @@ export async function isStoredEngineUsableForRequest(
   }
   for (const key of entry.requiredEnvVars) {
     try {
-      if (await resolveSecret(key)) continue;
+      if (await resolveUsableProviderSecret(key)) continue;
     } catch {
-      // Fall through to the deployment-level check below.
-    }
-    if (
-      !canUseDeployCredentialFallbackForRequest(key) ||
-      !readDeployCredentialEnv(key)
-    ) {
       return false;
     }
+    return false;
   }
   return true;
 }
@@ -461,20 +526,22 @@ export async function isResolvedEngineUsableForRequest(
     return Boolean(creds.privateKey && creds.publicKey);
   }
 
-  if (options.apiKey?.trim()) return true;
+  if (options.apiKey?.trim()) {
+    const key = entry.requiredEnvVars[0];
+    if (!key) return true;
+    return !(await getProviderCredentialAuthFailure({
+      key,
+      value: options.apiKey,
+    }));
+  }
 
   for (const key of entry.requiredEnvVars) {
     try {
-      if (await resolveSecret(key)) continue;
+      if (await resolveUsableProviderSecret(key)) continue;
     } catch {
-      // Fall through to deployment-level fallback when allowed.
-    }
-    if (
-      !canUseDeployCredentialFallbackForRequest(key) ||
-      !readDeployCredentialEnv(key)
-    ) {
       return false;
     }
+    return false;
   }
   return true;
 }
@@ -611,8 +678,9 @@ export async function resolveEngine(
   }
 
   // 8. Auto-detect from any provider env var — so just dropping a key in
-  // .env works without also setting AGENT_ENGINE.
-  const detected = detectEngineFromEnv();
+  // .env works without also setting AGENT_ENGINE. Skip keys with active
+  // auth-failure markers so a rejected deploy key cannot permanently win.
+  const detected = await detectEngineFromEnvForRequest();
   if (detected) {
     return detected.create(await engineCreateConfigForEntry(detected, apiKey));
   }

package/corpus/core/src/agent/production-agent.ts

@@ -29,6 +29,7 @@ import {
 } from "../resources/metadata.js";
 import {
   canUseDeployCredentialFallbackForRequest,
+  getProviderCredentialAuthFailure,
   readDeployCredentialEnv,
 } from "../server/credential-provider.js";
 import { readBody } from "../server/h3-helpers.js";
@@ -436,7 +437,15 @@ export async function getOwnerApiKey(
         scope: ref.scope,
         scopeId: ref.scopeId,
       });
-      if (fromSecrets?.value) return fromSecrets.value;
+      if (
+        fromSecrets?.value &&
+        !(await getProviderCredentialAuthFailure({
+          key: secretKey,
+          value: fromSecrets.value,
+        }))
+      ) {
+        return fromSecrets.value;
+      }
     }
   } catch {
     // app_secrets table not ready — fall through to legacy lookup.
@@ -446,12 +455,26 @@ export async function getOwnerApiKey(
     const stored = await getSetting(`user-api-key:${provider}:${ownerEmail}`);
     const key =
       stored && typeof stored.key === "string" ? stored.key.trim() : "";
-    if (key) return key;
+    if (
+      key &&
+      !(await getProviderCredentialAuthFailure({ key: secretKey, value: key }))
+    ) {
+      return key;
+    }
     if (provider === "anthropic") {
       const legacy = await getSetting(`user-anthropic-api-key:${ownerEmail}`);
       const legacyKey =
         legacy && typeof legacy.key === "string" ? legacy.key.trim() : "";
-      return legacyKey || undefined;
+      if (
+        legacyKey &&
+        !(await getProviderCredentialAuthFailure({
+          key: secretKey,
+          value: legacyKey,
+        }))
+      ) {
+        return legacyKey;
+      }
+      return undefined;
     }
     return undefined;
   } catch {
@@ -490,9 +513,17 @@ export async function getOwnerActiveApiKey(
     const userKey = await getOwnerApiKey(provider, ownerEmail);
     if (userKey) return userKey;
     const envVar = PROVIDER_TO_ENV[provider];
-    return envVar && canUseDeployCredentialFallbackForRequest(envVar)
-      ? readDeployCredentialEnv(envVar)
-      : undefined;
+    if (!envVar || !canUseDeployCredentialFallbackForRequest(envVar)) {
+      return undefined;
+    }
+    const envKey = readDeployCredentialEnv(envVar);
+    if (
+      envKey &&
+      !(await getProviderCredentialAuthFailure({ key: envVar, value: envKey }))
+    ) {
+      return envKey;
+    }
+    return undefined;
   } catch {
     return undefined;
   }

package/corpus/core/src/cli/create.ts

@@ -27,6 +27,12 @@ const STANDALONE_EXACT_DEPENDENCY_OVERRIDES: Record<string, string> = {
   "@react-router/fs-routes": "8.1.0",
   "react-router": "8.1.0",
 };
+const REACT_ROUTER_BUILD_DEPENDENCIES = [
+  "@react-router/dev",
+  "@react-router/fs-routes",
+  "react-router",
+  "vite",
+] as const;
 const SENTRY_MINIMUM_RELEASE_AGE_EXCLUDES = ['"@sentry/*"'];
 const FIRST_PARTY_TARBALL_SYMLINK_EXCLUDES = [
   "*/CLAUDE.md",
@@ -1045,6 +1051,7 @@ function postProcessStandalone(
       // under pnpm 10+ without prompting for `pnpm approve-builds`.
       pkg.dependencies = pkg.dependencies ?? {};
       pkg.dependencies.postgres ??= POSTGRES_DEPENDENCY_VERSION;
+      ensureReactRouterBuildDependencies(pkg);
 
       const requiredBuilt = ["better-sqlite3", "esbuild", "node-pty"];
       if (!pkg.pnpm || typeof pkg.pnpm !== "object") {
@@ -1105,6 +1112,34 @@ function postProcessStandalone(
   setupAgentSymlinks(targetDir);
 }
 
+function ensureReactRouterBuildDependencies(pkg: Record<string, any>): void {
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+    ...pkg.peerDependencies,
+  };
+  if (
+    !allDeps["@react-router/dev"] &&
+    !allDeps["react-router"] &&
+    !allDeps["@react-router/fs-routes"]
+  ) {
+    return;
+  }
+
+  pkg.dependencies = pkg.dependencies ?? {};
+  for (const key of REACT_ROUTER_BUILD_DEPENDENCIES) {
+    const existing =
+      pkg.dependencies[key] ??
+      pkg.devDependencies?.[key] ??
+      pkg.peerDependencies?.[key];
+    if (!existing) continue;
+    pkg.dependencies[key] =
+      STANDALONE_EXACT_DEPENDENCY_OVERRIDES[key] ?? existing;
+    delete pkg.devDependencies?.[key];
+    delete pkg.peerDependencies?.[key];
+  }
+}
+
 function fixStandaloneTsconfig(targetDir: string, templateName?: string): void {
   const tsconfigPath = path.join(targetDir, "tsconfig.json");
   if (!fs.existsSync(tsconfigPath)) return;

package/corpus/core/src/cli/design-connect.ts

@@ -507,6 +507,47 @@ function sendJson(
   res.end(`${JSON.stringify(body, null, 2)}\n`);
 }
 
+function sendText(
+  res: ServerResponse,
+  statusCode: number,
+  body: string,
+  contentType: string,
+) {
+  res.writeHead(statusCode, {
+    "content-type": contentType,
+    "access-control-allow-origin": "*",
+    "access-control-allow-methods": "GET, POST, OPTIONS",
+    "access-control-allow-headers": "content-type, x-bridge-token",
+    "access-control-allow-private-network": "true",
+  });
+  res.end(body);
+}
+
+function sendBytes(
+  res: ServerResponse,
+  statusCode: number,
+  body: Buffer,
+  headers: Headers,
+) {
+  const responseHeaders: Record<string, string> = {
+    "access-control-allow-origin": "*",
+    "access-control-allow-methods": "GET, HEAD, POST, OPTIONS",
+    "access-control-allow-headers": "content-type, x-bridge-token",
+    "access-control-allow-private-network": "true",
+  };
+  for (const name of [
+    "content-type",
+    "cache-control",
+    "etag",
+    "last-modified",
+  ]) {
+    const value = headers.get(name);
+    if (value) responseHeaders[name] = value;
+  }
+  res.writeHead(statusCode, responseHeaders);
+  res.end(body);
+}
+
 function sameOrigin(a: string, b: string): boolean {
   try {
     return new URL(a).origin === new URL(b).origin;
@@ -531,6 +572,23 @@ function resolvePreviewSnapshotUrl(
   return parsed.toString();
 }
 
+function resolvePreviewProxyUrl(
+  devServerUrl: string,
+  requestUrl: string | undefined,
+): string {
+  const base = normalizeHttpUrl(devServerUrl);
+  const parsedRequest = new URL(requestUrl ?? "/", base);
+  const parsed = new URL(
+    `${parsedRequest.pathname}${parsedRequest.search}`,
+    `${base}/`,
+  );
+  parsed.hash = "";
+  if (!sameOrigin(parsed.toString(), base)) {
+    throw new Error("Proxy URL must stay on the connected dev server.");
+  }
+  return parsed.toString();
+}
+
 async function fetchPreviewSnapshot(
   devServerUrl: string,
   targetUrl: string,
@@ -579,6 +637,79 @@ async function fetchPreviewSnapshot(
   }
 }
 
+async function fetchPreviewProxyResource(
+  devServerUrl: string,
+  targetUrl: string,
+  redirects = 0,
+): Promise<{
+  url: string;
+  status: number;
+  headers: Headers;
+  body: Buffer;
+}> {
+  if (redirects > 5) {
+    throw new Error("Too many redirects while proxying preview resource.");
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 10_000);
+  try {
+    const response = await fetch(targetUrl, {
+      method: "GET",
+      redirect: "manual",
+      signal: controller.signal,
+    });
+    const location = response.headers.get("location");
+    if (location && response.status >= 300 && response.status < 400) {
+      const redirected = new URL(location, targetUrl);
+      redirected.hash = "";
+      if (!sameOrigin(redirected.toString(), devServerUrl)) {
+        throw new Error("Proxy redirect left the connected dev server.");
+      }
+      return fetchPreviewProxyResource(
+        devServerUrl,
+        redirected.toString(),
+        redirects + 1,
+      );
+    }
+    return {
+      url: response.url || targetUrl,
+      status: response.status,
+      headers: response.headers,
+      body: Buffer.from(await response.arrayBuffer()),
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+function addLiveEditBaseHref(html: string, href: string): string {
+  const escapedHref = href.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+  const baseTag = `<base href="${escapedHref}">`;
+  if (/<base\b/i.test(html)) return html;
+  if (/<head\b[^>]*>/i.test(html)) {
+    return html.replace(/<head\b[^>]*>/i, (match) => `${match}${baseTag}`);
+  }
+  if (/<html\b[^>]*>/i.test(html)) {
+    return html.replace(
+      /<html\b[^>]*>/i,
+      (match) => `${match}<head>${baseTag}</head>`,
+    );
+  }
+  return `<!DOCTYPE html><html><head>${baseTag}<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"></head><body>${html}</body></html>`;
+}
+
+function injectLiveEditBridge(html: string, targetUrl: string, script: string) {
+  const withBase = addLiveEditBaseHref(html, targetUrl);
+  if (!script) return withBase;
+  if (withBase.includes("</body>")) {
+    return withBase.replace("</body>", `${script}</body>`);
+  }
+  if (withBase.includes("</html>")) {
+    return withBase.replace("</html>", `${script}</html>`);
+  }
+  return `${withBase}${script}`;
+}
+
 /** Read the full request body as a UTF-8 string. */
 async function readRequestBody(req: IncomingMessage): Promise<string> {
   return new Promise<string>((resolve, reject) => {
@@ -1046,6 +1177,7 @@ export async function startDesignConnectBridge(
   // an unauthenticated caller cannot read it.  The server-side grant action
   // obtains it out-of-band (via the exported bridge reference).
   const bridgeToken = crypto.randomBytes(32).toString("hex");
+  let liveEditBridgeScript = "";
 
   const server = http.createServer(
     (req: IncomingMessage, res: ServerResponse) => {
@@ -1077,6 +1209,95 @@ export async function startDesignConnectBridge(
         sendJson(res, 200, { ok: true, source: manifest.source });
         return;
       }
+      if (pathname === "/live-edit-bridge") {
+        if (req.method !== "POST") {
+          sendJson(res, 405, { ok: false, error: "method not allowed" });
+          return;
+        }
+        const tokenHeader = req.headers["x-bridge-token"];
+        const providedToken =
+          typeof tokenHeader === "string" ? tokenHeader : "";
+        let tokenValid = false;
+        try {
+          tokenValid =
+            providedToken.length === bridgeToken.length &&
+            crypto.timingSafeEqual(
+              Buffer.from(providedToken, "utf8"),
+              Buffer.from(bridgeToken, "utf8"),
+            );
+        } catch {
+          tokenValid = false;
+        }
+        if (!tokenValid) {
+          sendJson(res, 401, {
+            ok: false,
+            error: "invalid or missing bridge token",
+          });
+          return;
+        }
+        void (async () => {
+          try {
+            const raw = await readRequestBody(req);
+            const body = JSON.parse(raw) as Record<string, unknown>;
+            const script =
+              typeof body["script"] === "string" ? body["script"] : "";
+            if (!script.includes("agent-native:editor-chrome-ready")) {
+              sendJson(res, 400, {
+                ok: false,
+                error: "script must install the Agent Native editor bridge",
+              });
+              return;
+            }
+            liveEditBridgeScript = script;
+            sendJson(res, 200, { ok: true });
+          } catch (err: unknown) {
+            sendJson(res, 400, {
+              ok: false,
+              error: err instanceof Error ? err.message : String(err),
+            });
+          }
+        })();
+        return;
+      }
+      if (pathname === "/live-edit") {
+        if (req.method !== "GET") {
+          sendJson(res, 405, { ok: false, error: "method not allowed" });
+          return;
+        }
+        void (async () => {
+          try {
+            const requestUrl = new URL(req.url ?? "/", manifest.bridgeUrl);
+            const targetUrl = resolvePreviewSnapshotUrl(
+              manifest.devServerUrl,
+              requestUrl.searchParams.get("url") ??
+                requestUrl.searchParams.get("path"),
+            );
+            const snapshot = await fetchPreviewSnapshot(
+              manifest.devServerUrl,
+              targetUrl,
+            );
+            const html = injectLiveEditBridge(
+              snapshot.html,
+              new URL("/", manifest.bridgeUrl).toString(),
+              liveEditBridgeScript,
+            );
+            sendText(
+              res,
+              snapshot.status >= 400 ? snapshot.status : 200,
+              html,
+              snapshot.contentType.includes("html")
+                ? snapshot.contentType
+                : "text/html; charset=utf-8",
+            );
+          } catch (err: unknown) {
+            sendJson(res, 400, {
+              ok: false,
+              error: err instanceof Error ? err.message : String(err),
+            });
+          }
+        })();
+        return;
+      }
       if (pathname === "/snapshot") {
         if (req.method !== "GET") {
           sendJson(res, 405, { ok: false, error: "method not allowed" });
@@ -1356,6 +1577,33 @@ export async function startDesignConnectBridge(
         return;
       }
 
+      if (req.method === "GET" || req.method === "HEAD") {
+        void (async () => {
+          try {
+            const targetUrl = resolvePreviewProxyUrl(
+              manifest.devServerUrl,
+              req.url,
+            );
+            const proxied = await fetchPreviewProxyResource(
+              manifest.devServerUrl,
+              targetUrl,
+            );
+            sendBytes(
+              res,
+              proxied.status >= 400 ? proxied.status : 200,
+              req.method === "HEAD" ? Buffer.alloc(0) : proxied.body,
+              proxied.headers,
+            );
+          } catch (err: unknown) {
+            sendJson(res, 400, {
+              ok: false,
+              error: err instanceof Error ? err.message : String(err),
+            });
+          }
+        })();
+        return;
+      }
+
       sendJson(res, 404, { ok: false, error: "not found" });
     },
   );