@agent-native/core 0.128.0 → 0.128.1

package/corpus/templates/slides/app/components/design-system/builder-design-system-upload.ts

@@ -0,0 +1,271 @@
+import { appApiPath } from "@agent-native/core/client/api-path";
+
+import {
+  type BuilderIndexResult,
+  readBuilderIndexResponse,
+} from "./builder-index-response";
+
+// 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 request body (the serverless host caps bodies well below
+// Figma export sizes).
+const GCS_CHUNK_SIZE = 16 * 1024 * 1024;
+const MAX_CHUNK_RETRIES = 5;
+
+interface UploadSlot {
+  idx: number;
+  uploadUrl: string;
+  uploadToken: string;
+}
+
+async function readJson(res: Response): Promise<any> {
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+async function requestUploadSlots(files: File[]): Promise<UploadSlot[]> {
+  const res = await fetch(appApiPath("/api/design-system-upload-start"), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      attachments: files.map((file) => ({
+        name: file.name,
+        mimetype: file.type || "application/octet-stream",
+        declaredSize: file.size,
+      })),
+    }),
+  });
+  const json = await readJson(res);
+  if (!res.ok || json?.error) {
+    throw new Error(json?.error || `Failed to start upload (${res.status})`);
+  }
+  const slots = Array.isArray(json?.uploads)
+    ? ([...json.uploads] as UploadSlot[]).sort((a, b) => a.idx - b.idx)
+    : [];
+  if (slots.length !== files.length) {
+    throw new Error("Upload could not be started for all files.");
+  }
+  return slots;
+}
+
+async function initiateResumableSession(
+  uploadUrl: string,
+  mimetype: string,
+  fileSize: number,
+): Promise<string> {
+  const response = await fetch(uploadUrl, {
+    method: "POST",
+    headers: {
+      "x-goog-resumable": "start",
+      // The signed URL commits to the exact declared size; echo it back
+      // byte-for-byte or GCS rejects the session.
+      "x-goog-content-length-range": `0,${fileSize}`,
+      "Content-Type": mimetype,
+    },
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to initiate upload session (${response.status})`);
+  }
+  const sessionUri = response.headers.get("Location");
+  if (!sessionUri) {
+    throw new Error("Upload session URI missing from storage response");
+  }
+  return sessionUri;
+}
+
+// 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(
+  sessionUri: string,
+  total: number,
+): Promise<number> {
+  const response = await fetch(sessionUri, {
+    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(`Failed to query upload status (${response.status})`);
+}
+
+function delay(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      return reject(new DOMException("Aborted", "AbortError"));
+    }
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(new DOMException("Aborted", "AbortError"));
+      },
+      { once: true },
+    );
+  });
+}
+
+async function streamFileToStorage(
+  slot: UploadSlot,
+  file: File,
+  onProgress: (uploadedBytes: number) => void,
+): Promise<void> {
+  const mimetype = file.type || "application/octet-stream";
+  const sessionUri = await initiateResumableSession(
+    slot.uploadUrl,
+    mimetype,
+    file.size,
+  );
+  const total = file.size;
+
+  if (total === 0) {
+    const response = await fetch(sessionUri, {
+      method: "PUT",
+      headers: { "Content-Range": "bytes */0" },
+      body: new Uint8Array(0),
+    });
+    if (response.status !== 200 && response.status !== 201) {
+      throw new Error(
+        `Failed to finalize zero-byte upload (${response.status})`,
+      );
+    }
+    onProgress(0);
+    return;
+  }
+
+  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 fetch(sessionUri, {
+        method: "PUT",
+        headers: { "Content-Range": `bytes ${offset}-${end - 1}/${total}` },
+        body: file.slice(offset, end),
+      });
+      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(`Upload stalled at byte ${offset}`);
+        }
+        offset = nextOffset;
+      } else {
+        throw new Error(`Unexpected upload status ${response.status}`);
+      }
+      retries = 0;
+      onProgress(offset);
+    } catch (err) {
+      if (++retries > MAX_CHUNK_RETRIES) throw err;
+      await delay(500 * retries);
+      try {
+        offset = await queryCommittedOffset(sessionUri, 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.
+      }
+      onProgress(offset);
+    }
+  }
+}
+
+export interface UploadAndIndexOptions {
+  projectName?: string;
+  onProgress?: (fraction: number) => void;
+}
+
+/**
+ * Streams `.fig`/design files straight to storage in resumable chunks, then
+ * finalizes Builder DSI indexing with the resulting upload tokens. No file
+ * bytes pass through the app server, so arbitrarily large Figma files work.
+ */
+export async function uploadAndIndexFigmaFiles(
+  files: File[],
+  options: UploadAndIndexOptions = {},
+): Promise<BuilderIndexResult> {
+  if (files.length === 0) throw new Error("No files to upload.");
+
+  const slots = await requestUploadSlots(files);
+
+  const totalBytes = files.reduce((sum, file) => sum + file.size, 0) || 1;
+  const uploadedPerFile = new Array<number>(files.length).fill(0);
+  for (let i = 0; i < files.length; i++) {
+    await streamFileToStorage(slots[i], files[i], (uploaded) => {
+      uploadedPerFile[i] = uploaded;
+      const done = uploadedPerFile.reduce((sum, n) => sum + n, 0);
+      options.onProgress?.(Math.min(done / totalBytes, 1));
+    });
+  }
+
+  const res = await fetch(appApiPath("/api/index-design-system-sources"), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      projectName: options.projectName,
+      uploadTokens: slots.map((slot) => slot.uploadToken),
+    }),
+  });
+  return readBuilderIndexResponse(res);
+}
+
+export interface DecodeJobStatus {
+  status: "pending" | "processing" | "complete" | "error";
+  branchUrl: string | null;
+  error: string | null;
+  framesProcessed: number;
+  totalFrames: number;
+}
+
+const DECODE_JOB_POLL_INTERVAL_MS = 5_000;
+const DECODE_JOB_MAX_POLLS = 120; // ~10 min at 5s, so a stuck job can't loop forever
+
+export interface PollDecodeJobOptions {
+  signal?: AbortSignal;
+  onUpdate?: (status: DecodeJobStatus) => void;
+}
+
+/**
+ * After indexing returns a jobId, the `.fig` decode job is still `pending` with
+ * no branchUrl. Poll until the branch appears or the job reaches a terminal
+ * state. A job that reports `status: "error"` resolves so the caller can read
+ * `status.error`; network failures, timeouts, and aborts reject.
+ */
+export async function pollDecodeJobStatus(
+  jobId: string,
+  options: PollDecodeJobOptions = {},
+): Promise<DecodeJobStatus> {
+  const { signal, onUpdate } = options;
+  const path = appApiPath(
+    `/api/design-system-decode-job-status?jobId=${encodeURIComponent(jobId)}`,
+  );
+  for (let i = 0; i < DECODE_JOB_MAX_POLLS; i++) {
+    if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+    const res = await fetch(path, { signal });
+    const json = await readJson(res);
+    if (!res.ok || json?.error) {
+      throw new Error(json?.error || `Status check failed (${res.status})`);
+    }
+    const status = json as DecodeJobStatus;
+    onUpdate?.(status);
+    if (
+      status.branchUrl ||
+      status.status === "complete" ||
+      status.status === "error"
+    ) {
+      return status;
+    }
+    await delay(DECODE_JOB_POLL_INTERVAL_MS, signal);
+  }
+  throw new Error(
+    "Timed out waiting for the design system to finish decoding.",
+  );
+}

package/corpus/templates/slides/app/components/design-system/builder-index-response.ts

@@ -13,7 +13,7 @@ export interface BuilderIndexResult {
   builderConnectUrl?: string;
 }
 
-export const MAX_BUILDER_INDEX_UPLOAD_BYTES = 200 * 1024 * 1024;
+export const MAX_BUILDER_INDEX_UPLOAD_BYTES = 512 * 1024 * 1024;
 
 export function formatFileSize(bytes: number): string {
   return `${Math.round(bytes / 1024 / 1024)} MB`;

package/corpus/templates/slides/app/i18n/en-US.ts

@@ -537,6 +537,7 @@ const messages = {
     builderDesignSystemId: "Design system",
     builderJobId: "Job",
     openInBuilder: "Open in Builder",
+    decodeFailed: "Decoding failed: {{error}}",
     websiteUrl: "Website URL",
     websitePlaceholder: "example.com or Nike",
     add: "Add",

package/corpus/templates/slides/server/handlers/design-system-decode-job-status.ts

@@ -0,0 +1,49 @@
+import {
+  FeatureNotConfiguredError,
+  fetchBuilderDesignSystemDecodeJobStatus,
+  getSession,
+} from "@agent-native/core/server";
+import { defineEventHandler, getQuery, setResponseStatus } from "h3";
+
+import { withSlidesRequestContext } from "./request-auth-context.js";
+
+/**
+ * Reads a Builder design-system decode job's status. The UI polls this after
+ * `/api/index-design-system-sources` returns a jobId, until the `.fig` decode
+ * job leaves `pending` and exposes a `branchUrl` (or reports an `error`).
+ */
+export const designSystemDecodeJobStatus = defineEventHandler(async (event) => {
+  const session = await getSession(event).catch(() => null);
+  if (!session?.email) {
+    setResponseStatus(event, 401);
+    return { error: "Unauthorized" };
+  }
+
+  const jobId = getQuery(event).jobId;
+  if (typeof jobId !== "string" || !jobId.trim()) {
+    setResponseStatus(event, 400);
+    return { error: "jobId is required." };
+  }
+
+  try {
+    return await withSlidesRequestContext(event, () =>
+      fetchBuilderDesignSystemDecodeJobStatus(jobId.trim()),
+    );
+  } catch (err) {
+    if (err instanceof FeatureNotConfiguredError) {
+      setResponseStatus(event, 412);
+      return {
+        error: err.message,
+        builderConnectUrl:
+          err.builderConnectUrl ?? "/_agent-native/builder/connect",
+      };
+    }
+    setResponseStatus(event, 502);
+    return {
+      error:
+        err instanceof Error
+          ? err.message
+          : "Failed to read decode job status.",
+    };
+  }
+});

package/corpus/templates/slides/server/handlers/design-system-upload-start.ts

@@ -0,0 +1,87 @@
+import {
+  FeatureNotConfiguredError,
+  getSession,
+  startBuilderDesignSystemUpload,
+} from "@agent-native/core/server";
+import { defineEventHandler, readBody, setResponseStatus } from "h3";
+
+import { withSlidesRequestContext } from "./request-auth-context.js";
+
+const MAX_FIG_BYTES = 512 * 1024 * 1024;
+
+interface AttachmentInput {
+  name?: unknown;
+  mimetype?: unknown;
+  declaredSize?: unknown;
+}
+
+/**
+ * Opens signed resumable-upload slots so the browser can stream large `.fig`
+ * bytes straight to storage. Only small JSON metadata rides through the app
+ * server; the file bytes never do.
+ */
+export const designSystemUploadStart = defineEventHandler(async (event) => {
+  const session = await getSession(event).catch(() => null);
+  if (!session?.email) {
+    setResponseStatus(event, 401);
+    return { error: "Unauthorized" };
+  }
+
+  const body = (await readBody(event).catch(() => null)) as {
+    attachments?: AttachmentInput[];
+  } | null;
+  const rawList = Array.isArray(body?.attachments) ? body.attachments : [];
+  if (rawList.length === 0) {
+    setResponseStatus(event, 400);
+    return { error: "No attachments provided." };
+  }
+
+  const attachments: {
+    name: string;
+    mimetype: string;
+    declaredSize: number;
+  }[] = [];
+  for (const raw of rawList) {
+    const name = typeof raw?.name === "string" ? raw.name.trim() : "";
+    const mimetype =
+      typeof raw?.mimetype === "string" && raw.mimetype.trim()
+        ? raw.mimetype.trim()
+        : "application/octet-stream";
+    const declaredSize = Number(raw?.declaredSize);
+    if (!name) {
+      setResponseStatus(event, 400);
+      return { error: "Attachment name is required." };
+    }
+    if (!Number.isSafeInteger(declaredSize) || declaredSize <= 0) {
+      setResponseStatus(event, 400);
+      return { error: "Attachment declaredSize must be a positive integer." };
+    }
+    if (declaredSize > MAX_FIG_BYTES) {
+      setResponseStatus(event, 413);
+      return {
+        error: `File too large (max ${Math.round(MAX_FIG_BYTES / 1024 / 1024)} MB).`,
+      };
+    }
+    attachments.push({ name, mimetype, declaredSize });
+  }
+
+  try {
+    const uploads = await withSlidesRequestContext(event, () =>
+      startBuilderDesignSystemUpload(attachments),
+    );
+    return { uploads };
+  } catch (err) {
+    if (err instanceof FeatureNotConfiguredError) {
+      setResponseStatus(event, 412);
+      return {
+        error: err.message,
+        builderConnectUrl:
+          err.builderConnectUrl ?? "/_agent-native/builder/connect",
+      };
+    }
+    setResponseStatus(event, 502);
+    return {
+      error: err instanceof Error ? err.message : "Failed to start upload.",
+    };
+  }
+});

package/corpus/templates/slides/server/handlers/index-design-system-sources.ts

@@ -0,0 +1,79 @@
+import {
+  FeatureNotConfiguredError,
+  getSession,
+  indexBuilderDesignSystem,
+} from "@agent-native/core/server";
+import { defineEventHandler, readBody, setResponseStatus } from "h3";
+
+import { upsertBuilderProxyDesignSystem } from "../lib/builder-design-system-proxy.js";
+import { withSlidesRequestContext } from "./request-auth-context.js";
+
+/**
+ * Finalizes Builder DSI indexing from upload tokens produced by the
+ * browser-streamed resumable upload. The file bytes were streamed straight to
+ * storage; this endpoint only forwards the opaque tokens.
+ */
+export const indexDesignSystemSources = defineEventHandler(async (event) => {
+  const session = await getSession(event).catch(() => null);
+  if (!session?.email) {
+    setResponseStatus(event, 401);
+    return { error: "Unauthorized" };
+  }
+
+  const body = (await readBody(event).catch(() => null)) as {
+    projectName?: unknown;
+    uploadTokens?: unknown;
+  } | null;
+  const uploadTokens = Array.isArray(body?.uploadTokens)
+    ? body.uploadTokens.filter(
+        (token): token is string =>
+          typeof token === "string" && token.length > 0,
+      )
+    : [];
+  if (uploadTokens.length === 0) {
+    setResponseStatus(event, 400);
+    return { error: "No uploaded files to index." };
+  }
+  const projectName =
+    typeof body?.projectName === "string"
+      ? body.projectName.trim() || undefined
+      : undefined;
+
+  const sources = uploadTokens.map((uploadToken) => ({
+    kind: "file" as const,
+    uploadToken,
+  }));
+
+  try {
+    return await withSlidesRequestContext(event, async ({ email, orgId }) => {
+      const result = await indexBuilderDesignSystem({ sources, projectName });
+      const proxy = await upsertBuilderProxyDesignSystem({
+        result,
+        ownerEmail: email ?? session.email,
+        orgId: orgId ?? null,
+        projectName,
+      });
+      return {
+        ...result,
+        ...proxy,
+        uploadedFileCount: uploadTokens.length,
+      };
+    });
+  } catch (err) {
+    if (err instanceof FeatureNotConfiguredError) {
+      setResponseStatus(event, 412);
+      return {
+        error: err.message,
+        builderConnectUrl:
+          err.builderConnectUrl ?? "/_agent-native/builder/connect",
+      };
+    }
+    setResponseStatus(event, 502);
+    return {
+      error:
+        err instanceof Error
+          ? err.message
+          : "Builder design-system indexing failed.",
+    };
+  }
+});

package/corpus/templates/slides/server/routes/api/design-system-decode-job-status.get.ts

@@ -0,0 +1 @@
+export { designSystemDecodeJobStatus as default } from "../../handlers/design-system-decode-job-status";

package/corpus/templates/slides/server/routes/api/design-system-upload-start.post.ts

@@ -0,0 +1 @@
+export { designSystemUploadStart as default } from "../../handlers/design-system-upload-start";

package/corpus/templates/slides/server/routes/api/index-design-system-sources.post.ts

@@ -0,0 +1 @@
+export { indexDesignSystemSources as default } from "../../handlers/index-design-system-sources";

package/corpus/templates/tasks/_gitignore

@@ -8,8 +8,10 @@ npm-debug.log*
 pnpm-debug.log*
 
 node_modules
+build/
 dist
 dist-ssr
+.output/
 *.local
 
 # Editor directories and files

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/progress/routes.d.ts

@@ -15,7 +15,7 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;
 //# sourceMappingURL=routes.d.ts.map

package/dist/provider-api/actions/custom-provider-registration.d.ts

@@ -75,8 +75,9 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
-    id?: undefined;
     deleted?: undefined;
+    id?: undefined;
+    provider?: undefined;
     found?: undefined;
     message?: undefined;
     providers: {
@@ -89,45 +90,44 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         updatedAt: number;
     }[];
     count: number;
-    provider?: undefined;
     registered?: undefined;
     label?: undefined;
 } | {
-    id?: undefined;
     deleted?: undefined;
+    count?: undefined;
+    id?: undefined;
     message?: undefined;
     providers?: undefined;
-    count?: undefined;
     found: boolean;
     provider: import("../custom-registry.js").CustomProviderConfig;
     registered?: undefined;
     label?: undefined;
 } | {
     deleted?: undefined;
-    message?: undefined;
-    providers?: undefined;
     count?: undefined;
     provider?: undefined;
+    message?: undefined;
+    providers?: undefined;
     found: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
 } | {
+    count?: undefined;
+    provider?: undefined;
     found?: undefined;
     message?: undefined;
     providers?: undefined;
-    count?: undefined;
-    provider?: undefined;
     deleted: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
 } | {
     deleted?: undefined;
-    found?: undefined;
-    providers?: undefined;
     count?: undefined;
     provider?: undefined;
+    found?: undefined;
+    providers?: undefined;
     registered: boolean;
     id: string;
     label: string;

package/dist/provider-api/actions/provider-api.d.ts

@@ -311,9 +311,8 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         notes?: string | undefined;
         scope?: "org" | "user" | undefined;
     }, {
-        deleted?: undefined;
         id?: undefined;
-        provider?: undefined;
+        deleted?: undefined;
         found?: undefined;
         providers: {
             id: string;
@@ -325,13 +324,14 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
             updatedAt: number;
         }[];
         count: number;
+        provider?: undefined;
         registered?: undefined;
         label?: undefined;
         message?: undefined;
     } | {
+        id?: undefined;
         deleted?: undefined;
         count?: undefined;
-        id?: undefined;
         providers?: undefined;
         found: boolean;
         provider: import("../custom-registry.js").CustomProviderConfig;
@@ -341,18 +341,18 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
     } | {
         deleted?: undefined;
         count?: undefined;
-        provider?: undefined;
         providers?: undefined;
+        provider?: undefined;
         found: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
         message?: undefined;
     } | {
-        count?: undefined;
-        provider?: undefined;
         found?: undefined;
+        count?: undefined;
         providers?: undefined;
+        provider?: undefined;
         deleted: boolean;
         id: string;
         registered?: undefined;
@@ -360,10 +360,10 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         message?: undefined;
     } | {
         deleted?: undefined;
-        count?: undefined;
-        provider?: undefined;
         found?: undefined;
+        count?: undefined;
         providers?: undefined;
+        provider?: undefined;
         registered: boolean;
         id: string;
         label: string;

package/dist/server/agent-engine-api-key-route.d.ts

@@ -27,11 +27,11 @@ export declare function resolveAgentEngineApiKeyWriteTarget(event: H3Event, scop
 export declare function createAgentEngineApiKeyHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: any;
 } | {
+    error?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
-    error?: undefined;
 }>>;
 export {};
 //# sourceMappingURL=agent-engine-api-key-route.d.ts.map