@agent-native/core 0.127.3 → 0.128.1

package/src/server/agent-chat-plugin.ts

@@ -502,21 +502,9 @@ export function createAgentChatPlugin(
       const { awaitBootstrap } = await import("./framework-request-handler.js");
       await awaitBootstrap(nitroApp);
 
-      // Reap phantom runs left over from the previous process (HMR restart,
-      // process crash, isolate eviction). Any run whose heartbeat is already
-      // stale by startup time had a dead producer; mark it errored so the
-      // next /runs/active check returns a terminal status and reconnecting
-      // clients don't spin on "Thinking...". Runs owned by OTHER live
-      // isolates are protected by their fresh heartbeats.
-      try {
-        const { reapAllStaleRuns } = await import("../agent/run-store.js");
-        const reaped = await reapAllStaleRuns();
-        if (reaped > 0) {
-          console.log(`[agent-chat] reaped ${reaped} stale run(s) on startup`);
-        }
-      } catch {
-        // Best effort — don't block plugin init if SQL isn't ready yet.
-      }
+      // Never make route readiness wait on an org-global stale-run sweep.
+      // `/runs/active` reaps the requested run on demand, and the periodic
+      // recovery sweep below handles abandoned runs with no connected client.
 
       const env = process.env.NODE_ENV;
       // AGENT_MODE=production forces production agent constraints even in dev
@@ -561,44 +549,47 @@ export function createAgentChatPlugin(
         extensionTools: options?.extensionTools,
       });
 
-      // Initialize MCP client. Merges file/env config + auto-detected binaries
-      // + any remote servers users have added through the settings UI (persisted
-      // in the settings table, scanned across all scopes so we never drop
-      // another user's entries). Graceful-degrade: any failure yields zero MCP
-      // tools and agent-chat keeps working as before.
-      let mcpConfig = await buildMergedConfig().catch((err) => {
-        console.warn(
-          `[mcp-client] buildMergedConfig failed: ${err?.message ?? err}`,
-        );
-        return null;
-      });
-      if (!mcpConfig) {
-        const fileOrEnv = loadMcpConfig() ?? autoDetectMcpConfig();
-        mcpConfig = fileOrEnv;
-        if (mcpConfig?.source) {
-          console.log(
-            `[mcp-client] loaded config from ${mcpConfig.source} (${Object.keys(mcpConfig.servers).length} server(s))`,
+      // Route readiness must not wait on settings scans, remote hub fetches, or
+      // third-party MCP handshakes. Build the action surface against an empty
+      // manager, then hydrate it after every live action registry has subscribed
+      // to manager changes.
+      const mcpManager = new McpClientManager(null);
+      setGlobalMcpManager(mcpManager);
+      const mcpActionEntries: Record<string, ActionEntry> = {};
+      let mcpInitializationPromise: Promise<void> | null = null;
+      const initializeMcpManager = async (): Promise<void> => {
+        let mcpConfig = await buildMergedConfig().catch((err) => {
+          console.warn(
+            `[mcp-client] buildMergedConfig failed: ${err?.message ?? err}`,
           );
-        } else if (process.env.DEBUG) {
+          return null;
+        });
+        if (!mcpConfig) {
+          mcpConfig = loadMcpConfig() ?? autoDetectMcpConfig();
+          if (mcpConfig?.source) {
+            console.log(
+              `[mcp-client] loaded config from ${mcpConfig.source} (${Object.keys(mcpConfig.servers).length} server(s))`,
+            );
+          } else if (process.env.DEBUG) {
+            console.log(
+              "[mcp-client] no configured MCP servers — skipping MCP tools",
+            );
+          }
+        } else if (mcpConfig.source) {
           console.log(
-            "[mcp-client] no configured MCP servers — skipping MCP tools",
+            `[mcp-client] merged config (${Object.keys(mcpConfig.servers).length} server(s), source: ${mcpConfig.source})`,
           );
         }
-      } else if (mcpConfig.source) {
-        console.log(
-          `[mcp-client] merged config (${Object.keys(mcpConfig.servers).length} server(s), source: ${mcpConfig.source})`,
-        );
-      }
-      const mcpManager = new McpClientManager(mcpConfig);
-      try {
-        await mcpManager.start();
-      } catch (err: any) {
-        console.warn(
-          `[mcp-client] start() failed: ${err?.message ?? err}. Continuing without MCP tools.`,
-        );
-      }
-      setGlobalMcpManager(mcpManager);
-      const mcpActionEntries = mcpToolsToActionEntries(mcpManager);
+        try {
+          await mcpManager.reconfigure(mcpConfig);
+        } catch (err: any) {
+          console.warn(
+            `[mcp-client] initialization failed: ${err?.message ?? err}. Continuing without MCP tools.`,
+          );
+        } finally {
+          startMcpConfigRefresh(mcpManager);
+        }
+      };
       const getJobMcpActionEntries = (
         job?: RecurringJobContext,
       ): Record<string, ActionEntry> => {
@@ -619,8 +610,11 @@ export function createAgentChatPlugin(
       // Mount status + management routes so the settings UI can list / add /
       // remove remote MCP servers and hot-reload the running manager.
       mountMcpStatusRoute(nitroApp, mcpManager);
-      mountMcpServersRoutes(nitroApp, mcpManager);
-      startMcpConfigRefresh(mcpManager);
+      mountMcpServersRoutes(nitroApp, mcpManager, {
+        // Serialize an unusually early settings mutation behind the initial
+        // config snapshot so stale startup data cannot overwrite the write.
+        waitUntilReady: () => mcpInitializationPromise ?? Promise.resolve(),
+      });
       // Hub-serve: expose org-scope servers to other agent-native apps in the
       // workspace when `AGENT_NATIVE_MCP_HUB_TOKEN` is set (dispatch, by
       // convention). Gated by the env var so mounting is a no-op otherwise.
@@ -5694,6 +5688,13 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
         }
       }
 
+      mcpInitializationPromise = initializeMcpManager().catch((err) => {
+        console.warn(
+          `[mcp-client] deferred initialization failed: ${err?.message ?? err}`,
+        );
+      });
+      void mcpInitializationPromise;
+
       // ─── Agent Teams orphan sweep ─────────────────────────────────────
       // Re-fires stuck/queued dispatches when the browser is closed and the
       // RunsTray's per-user reconciliation never triggers. Runs every 2 minutes
@@ -6001,7 +6002,7 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
           });
           if (process.env.DEBUG)
             console.log("[triggers] Trigger dispatcher initialized");
-        } catch (err) {
+        } catch {
           // Triggers module not available — skip silently
         }
       }

package/src/server/builder-design-systems.ts

@@ -1,3 +1,5 @@
+import type { DesignSystemSourceInput } from "@builder.io/ai-utils";
+
 import { withBuilderUtmTrackingParams } from "../shared/builder-link-tracking.js";
 import { FeatureNotConfiguredError } from "./credential-provider.js";
 import {
@@ -7,6 +9,12 @@ import {
 
 const DEFAULT_TIMEOUT_MS = 120_000;
 
+// GCS resumable uploads require every chunk except the last to be a multiple
+// of 256 KiB. 16 MiB is the recommended default and keeps very large `.fig`
+// files off a single unbounded request body.
+const GCS_CHUNK_SIZE = 16 * 1024 * 1024;
+const MAX_CHUNK_RETRIES = 5;
+
 export interface BuilderDesignSystemIndexFile {
   name: string;
   data: Uint8Array;
@@ -123,16 +131,65 @@ interface UploadStartResponse {
   uploads?: Array<{ idx: number; uploadUrl: string; uploadToken: string }>;
 }
 
-interface GenerateResponse {
-  projectId?: string;
-  jobId?: string;
+interface IndexResponse {
   designSystemId?: string;
+  jobId?: string;
+  projectId?: string;
+  branchUrl?: string;
+  branchName?: string;
+}
+
+export interface BuilderDesignSystemUploadAttachment {
+  name: string;
+  mimetype: string;
+  declaredSize: number;
+}
+
+export interface BuilderDesignSystemUploadSlot {
+  idx: number;
+  uploadUrl: string;
+  uploadToken: string;
+}
+
+export interface BuilderDesignSystemIndexFromSourcesOptions {
+  sources: DesignSystemSourceInput[];
+  projectName?: string;
+  devToolsVersion?: string;
+}
+
+export interface BuilderDesignSystemDecodeJobStatus {
+  jobId: string;
+  status: "pending" | "processing" | "complete" | "error";
+  framesProcessed: number;
+  totalFrames: number;
+  branchName: string | null;
+  branchUrl: string | null;
+  error: string | null;
+  partialFailure?: boolean;
+  createdAt: number;
+  updatedAt: number;
 }
 
 const DEFAULT_MAX_CODE_FILES = 50;
 const DEFAULT_MAX_TOTAL_CODE_BYTES = 2 * 1024 * 1024;
 const MAX_DOC_CONTENT_CHARS = 4_000;
 
+export async function fetchBuilderDesignSystemDecodeJobStatus(
+  jobId: string,
+): Promise<BuilderDesignSystemDecodeJobStatus> {
+  const credentials = await resolveBuilderDesignSystemCredentials();
+  const url = makeBuilderDesignSystemUrl(
+    "decode-jobs/" + encodeURIComponent(jobId),
+    credentials,
+  );
+  const response = await fetchWithTimeout(url, {
+    method: "GET",
+    headers: makeBuilderHeaders(credentials),
+  });
+  await assertOk(response, "Builder design-system decode-job status failed");
+  return (await response.json()) as BuilderDesignSystemDecodeJobStatus;
+}
+
 function trimTrailingSlash(value: string): string {
   return value.replace(/\/+$/, "");
 }
@@ -318,17 +375,45 @@ async function assertOk(response: Response, label: string): Promise<void> {
   );
 }
 
+// GCS reports the highest committed byte in a `Range: bytes=0-<end>` header.
+function committedOffsetFromRange(response: Response): number | null {
+  const match = response.headers.get("Range")?.match(/bytes=0-(\d+)/);
+  return match ? parseInt(match[1], 10) + 1 : null;
+}
+
+async function queryCommittedOffset(
+  sessionUrl: string,
+  total: number,
+): Promise<number> {
+  const response = await fetchWithTimeout(sessionUrl, {
+    method: "PUT",
+    headers: { "Content-Range": `bytes */${total}` },
+  });
+  if (response.status === 200 || response.status === 201) return total;
+  if (response.status === 308) {
+    return committedOffsetFromRange(response) ?? 0;
+  }
+  throw new Error(
+    `Builder design-system upload status query failed (${response.status}).`,
+  );
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 async function uploadToResumableUrl(
   slot: { uploadUrl: string },
   file: BuilderDesignSystemIndexFile,
 ): Promise<void> {
   const mimeType = mimeTypeForFile(file);
   const bytes = file.data;
+  const total = bytes.byteLength;
   const start = await fetchWithTimeout(slot.uploadUrl, {
     method: "POST",
     headers: {
       "x-goog-resumable": "start",
-      "x-goog-content-length-range": `0,${bytes.byteLength}`,
+      "x-goog-content-length-range": `0,${total}`,
       "Content-Type": mimeType,
     },
   });
@@ -338,15 +423,60 @@ async function uploadToResumableUrl(
     throw new Error("Builder design-system upload session returned no URL.");
   }
 
-  const response = await fetchWithTimeout(sessionUrl, {
-    method: "PUT",
-    headers: {
-      "Content-Range": `bytes 0-${bytes.byteLength - 1}/${bytes.byteLength}`,
-      "Content-Type": mimeType,
-    },
-    body: makeBody(bytes, mimeType),
-  });
-  await assertOk(response, "Builder design-system file upload failed");
+  if (total === 0) {
+    const response = await fetchWithTimeout(sessionUrl, {
+      method: "PUT",
+      headers: { "Content-Range": "bytes */0" },
+      body: makeBody(bytes, mimeType),
+    });
+    await assertOk(response, "Builder design-system file upload failed");
+    return;
+  }
+
+  // A failed PUT may have still landed at GCS, so the local offset can't be
+  // trusted after an error — only GCS's committed-offset response is
+  // authoritative.
+  let offset = 0;
+  let retries = 0;
+  while (offset < total) {
+    const end = Math.min(offset + GCS_CHUNK_SIZE, total);
+    const isLast = end === total;
+    try {
+      const response = await fetchWithTimeout(sessionUrl, {
+        method: "PUT",
+        headers: {
+          "Content-Range": `bytes ${offset}-${end - 1}/${total}`,
+          "Content-Type": mimeType,
+        },
+        body: makeBody(bytes.subarray(offset, end), mimeType),
+      });
+      if (response.status === 200 || response.status === 201) {
+        offset = total;
+      } else if (!isLast && response.status === 308) {
+        const nextOffset = committedOffsetFromRange(response) ?? offset;
+        if (nextOffset <= offset) {
+          throw new Error(
+            `Builder design-system upload stalled at byte ${offset}.`,
+          );
+        }
+        offset = nextOffset;
+      } else {
+        throw new Error(
+          `Builder design-system file upload failed (${response.status}).`,
+        );
+      }
+      retries = 0;
+    } catch (err) {
+      if (++retries > MAX_CHUNK_RETRIES) throw err;
+      await delay(500 * retries);
+      try {
+        offset = await queryCommittedOffset(sessionUrl, total);
+      } catch {
+        // If the offset query also fails, retry from the last local offset —
+        // GCS's resumable PUT safely re-acknowledges bytes it already has.
+      }
+    }
+  }
 }
 
 function nonEmptyFiles(
@@ -368,6 +498,25 @@ export function builderDesignSystemUrl(designSystemId?: string | null): string {
   });
 }
 
+export function builderProjectBranchUrl(
+  projectId?: string | null,
+  branchName?: string | null,
+): string | undefined {
+  const project = projectId?.trim();
+  const branch = branchName?.trim();
+  if (!project || !branch) return undefined;
+  const host = trimTrailingSlash(getBuilderAppHost());
+  const path =
+    "/app/projects/" +
+    encodeURIComponent(project) +
+    "/" +
+    encodeURIComponent(branch);
+  return withBuilderUtmTrackingParams(host + path, {
+    campaign: "product",
+    content: "design_system_intelligence",
+  });
+}
+
 export function localBuilderDesignSystemId(
   builderDesignSystemId: string,
 ): string {
@@ -569,65 +718,58 @@ export async function hydrateBuilderDesignSystemReference(
   };
 }
 
-export async function startBuilderDesignSystemIndex(
-  options: BuilderDesignSystemIndexOptions,
-): Promise<BuilderDesignSystemIndexResult> {
-  const files = nonEmptyFiles(options.files);
-  const description = options.description?.trim();
-  if (description) {
-    files.unshift({
-      name: "additional-context.txt",
-      data: new TextEncoder().encode(description),
-      mimeType: "text/plain",
-    });
+/**
+ * Opens signed resumable-upload slots for `.fig`/code/design attachments so
+ * the browser can stream each file's bytes straight to GCS. Large `.fig`
+ * files must not ride through the app server as one request body -- the
+ * serverless host caps request bodies well below Figma export sizes.
+ */
+export async function startBuilderDesignSystemUpload(
+  attachments: BuilderDesignSystemUploadAttachment[],
+): Promise<BuilderDesignSystemUploadSlot[]> {
+  if (attachments.length === 0) return [];
+  const credentials = await resolveBuilderDesignSystemCredentials();
+  const uploadStart = await fetchWithTimeout(
+    makeBuilderDesignSystemUrl("upload/start", credentials),
+    {
+      method: "POST",
+      headers: {
+        ...makeBuilderHeaders(credentials),
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ attachments }),
+    },
+  );
+  await assertOk(uploadStart, "Builder design-system upload start failed");
+  const uploadJson = (await uploadStart.json()) as UploadStartResponse;
+  const slots = [...(uploadJson.uploads ?? [])].sort((a, b) => a.idx - b.idx);
+  if (slots.length !== attachments.length) {
+    throw new Error("Builder did not return upload slots for all files.");
   }
-  if (
-    files.length === 0 &&
-    !options.githubRepoUrl &&
-    !options.connectedProjectId
-  ) {
+  for (let i = 0; i < slots.length; i++) {
+    if (slots[i].idx !== i) {
+      throw new Error("Builder upload slot mismatch: expected " + i + ".");
+    }
+  }
+  return slots;
+}
+
+/**
+ * Finalizes indexing from already-resolved sources (uploaded file tokens,
+ * public repos, connected projects). Callers that stream uploads from the
+ * browser pass the returned `uploadToken`s as `file` sources here.
+ */
+export async function indexBuilderDesignSystem(
+  options: BuilderDesignSystemIndexFromSourcesOptions,
+): Promise<BuilderDesignSystemIndexResult> {
+  if (options.sources.length === 0) {
     throw new Error(
       "Provide at least one .fig/code/text file or a GitHub repository URL to index with Builder.",
     );
   }
-
   const credentials = await resolveBuilderDesignSystemCredentials();
-  let uploadTokens: string[] = [];
-  if (files.length > 0) {
-    const uploadStart = await fetchWithTimeout(
-      makeBuilderDesignSystemUrl("upload/start", credentials),
-      {
-        method: "POST",
-        headers: {
-          ...makeBuilderHeaders(credentials),
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-          attachments: files.map((file) => ({
-            name: file.name,
-            mimetype: mimeTypeForFile(file),
-            declaredSize: file.data.byteLength,
-          })),
-        }),
-      },
-    );
-    await assertOk(uploadStart, "Builder design-system upload start failed");
-    const uploadJson = (await uploadStart.json()) as UploadStartResponse;
-    const slots = [...(uploadJson.uploads ?? [])].sort((a, b) => a.idx - b.idx);
-    if (slots.length !== files.length) {
-      throw new Error("Builder did not return upload slots for all files.");
-    }
-    for (let i = 0; i < slots.length; i++) {
-      if (slots[i].idx !== i) {
-        throw new Error(`Builder upload slot mismatch: expected ${i}.`);
-      }
-      await uploadToResumableUrl(slots[i], files[i]);
-    }
-    uploadTokens = slots.map((slot) => slot.uploadToken);
-  }
-
-  const generate = await fetchWithTimeout(
-    makeBuilderDesignSystemUrl("generate", credentials),
+  const index = await fetchWithTimeout(
+    makeBuilderDesignSystemUrl("index", credentials),
     {
       method: "POST",
       headers: {
@@ -635,39 +777,114 @@ export async function startBuilderDesignSystemIndex(
         "Content-Type": "application/json",
       },
       body: JSON.stringify({
-        uploads: uploadTokens,
+        sources: options.sources,
         ...(options.projectName?.trim()
-          ? { projectName: options.projectName.trim() }
-          : {}),
-        ...(options.githubRepoUrl?.trim()
-          ? { githubRepoUrl: options.githubRepoUrl.trim() }
+          ? { designSystemName: options.projectName.trim() }
           : {}),
-        ...(options.connectedProjectId?.trim()
-          ? { connectedProjectId: options.connectedProjectId.trim() }
-          : {}),
-        ...(options.selection ? { selection: options.selection } : {}),
         ...(options.devToolsVersion?.trim()
           ? { devToolsVersion: options.devToolsVersion.trim() }
           : {}),
       }),
     },
   );
-  await assertOk(generate, "Builder design-system indexing failed");
-  const generated = (await generate.json()) as GenerateResponse;
-  if (!generated.projectId || !generated.jobId || !generated.designSystemId) {
+  await assertOk(index, "Builder design-system indexing failed");
+  const indexed = (await index.json()) as IndexResponse;
+  if (!indexed.designSystemId) {
     throw new Error(
       "Builder design-system indexing returned an incomplete response.",
     );
   }
 
+  const jobId = indexed.jobId ?? "";
+  // The `.fig` decode job creates the Fusion branch asynchronously, so
+  // `/index` usually can't return a branchUrl yet — the caller polls the
+  // decode-job status endpoint for it once the job completes.
+  const branchUrl = indexed.branchUrl?.trim() || null;
+
   return {
     ok: true,
     source: "builder",
-    projectId: generated.projectId,
-    jobId: generated.jobId,
-    designSystemId: generated.designSystemId,
+    projectId: indexed.projectId ?? "",
+    jobId,
+    designSystemId: indexed.designSystemId,
     suggestedTitle: options.projectName?.trim() || null,
-    builderUrl: builderDesignSystemUrl(generated.designSystemId),
+    builderUrl:
+      branchUrl ||
+      builderProjectBranchUrl(indexed.projectId, indexed.branchName) ||
+      builderDesignSystemUrl(indexed.designSystemId),
     status: "in-progress",
   };
 }
+
+/**
+ * Server-side indexing for in-memory files (the agent action's small inline
+ * payloads). Uploads each file server->GCS in resumable chunks, then
+ * finalizes. Browser callers should instead stream via
+ * `startBuilderDesignSystemUpload` + `indexBuilderDesignSystem`.
+ */
+export async function startBuilderDesignSystemIndex(
+  options: BuilderDesignSystemIndexOptions,
+): Promise<BuilderDesignSystemIndexResult> {
+  const files = nonEmptyFiles(options.files);
+  const description = options.description?.trim();
+  if (description) {
+    files.unshift({
+      name: "additional-context.txt",
+      data: new TextEncoder().encode(description),
+      mimeType: "text/plain",
+    });
+  }
+  if (
+    files.length === 0 &&
+    !options.githubRepoUrl &&
+    !options.connectedProjectId
+  ) {
+    throw new Error(
+      "Provide at least one .fig/code/text file or a GitHub repository URL to index with Builder.",
+    );
+  }
+
+  const sources: DesignSystemSourceInput[] = [];
+  if (files.length > 0) {
+    const slots = await startBuilderDesignSystemUpload(
+      files.map((file) => ({
+        name: file.name,
+        mimetype: mimeTypeForFile(file),
+        declaredSize: file.data.byteLength,
+      })),
+    );
+    for (let i = 0; i < slots.length; i++) {
+      await uploadToResumableUrl(slots[i], files[i]);
+    }
+    for (let i = 0; i < slots.length; i++) {
+      const name = files[i].name;
+      const fileSelection = options.selection?.[name];
+      sources.push({
+        kind: "file",
+        uploadToken: slots[i].uploadToken,
+        ...(fileSelection && fileSelection.length > 0
+          ? { selection: { [name]: fileSelection } }
+          : {}),
+      });
+    }
+  }
+
+  if (options.githubRepoUrl?.trim()) {
+    sources.push({
+      kind: "public-repo",
+      repoUrl: options.githubRepoUrl.trim(),
+    });
+  }
+  if (options.connectedProjectId?.trim()) {
+    sources.push({
+      kind: "connected-repo",
+      fusionProjectId: options.connectedProjectId.trim(),
+    });
+  }
+
+  return indexBuilderDesignSystem({
+    sources,
+    projectName: options.projectName,
+    devToolsVersion: options.devToolsVersion,
+  });
+}

package/src/server/core-routes-plugin.ts

@@ -4251,8 +4251,13 @@ export function createCoreRoutesPlugin(
       }
       resolveInit();
     } catch (error) {
+      // Do NOT rethrow. Nitro invokes plugins as `try { plugin(app) } catch`,
+      // which cannot catch an async rejection, so rethrowing here surfaces as
+      // an unhandledRejection: Node exits, the serverless container dies, and
+      // every in-flight request on it returns a bare 502. `rejectInit` already
+      // routes this failure to the readiness gate, which answers the affected
+      // paths with a retryable 503 instead.
       rejectInit(error);
-      throw error;
     }
   };
 }