@agent-native/core-corpus 0.214.0 → 0.216.0

package/corpus/templates/slides-2/app/lib/prompt-file-uploads.ts

@@ -0,0 +1,557 @@
+import { appBasePath } from "@agent-native/core/client/api-path";
+import { callAction } from "@agent-native/core/client/hooks";
+import { ensureEmbedAuthFetchInterceptor } from "@agent-native/core/client/host";
+import pLimit from "p-limit";
+
+import {
+  canAddInlineImageToPayload,
+  canInlineImageFile,
+  readFileAsDataUrl,
+} from "@/lib/image-drop-to-agent";
+
+import { MAX_REFERENCE_FILES } from "../../shared/upload-types";
+import {
+  UPLOAD_SERVICE_UNAVAILABLE_CODE,
+  isUploadGatewayStatus,
+  looksLikeMarkup,
+} from "./upload-response";
+
+export interface UploadedFile {
+  path: string;
+  url?: string;
+  dataUrl?: string;
+  originalName: string;
+  filename: string;
+  type: string;
+  size: number;
+}
+
+/**
+ * A failure that says "the service did not answer properly", never "this file
+ * is bad": a gateway or timeout status, an error page where JSON should be, a
+ * client-side timeout, or storage that reports it will recover by itself.
+ * Storage that someone must connect or fix is not this; it has its own copy.
+ */
+export function isPromptUploadServiceUnavailableError(error: unknown): boolean {
+  if (!(error instanceof Error)) return false;
+  const typed = error as {
+    code?: unknown;
+    errorCode?: unknown;
+    status?: unknown;
+    timedOut?: unknown;
+    details?: { whoCanFix?: unknown } | null;
+  };
+  if (
+    typed.code === UPLOAD_SERVICE_UNAVAILABLE_CODE ||
+    typed.errorCode === UPLOAD_SERVICE_UNAVAILABLE_CODE ||
+    typed.timedOut === true
+  ) {
+    return true;
+  }
+  // The uploader already named its own failure (auth, size, storage status);
+  // a status alone must not re-label it.
+  if (typeof typed.code === "string" && typed.code.startsWith("reference_")) {
+    return false;
+  }
+  if (typed.errorCode === "attachment_storage_unavailable") {
+    return typed.details?.whoCanFix === "self_resolving";
+  }
+  if (typeof typed.status === "number" && isUploadGatewayStatus(typed.status)) {
+    return true;
+  }
+  return looksLikeMarkup(error.message);
+}
+
+export function isPromptUploadNetworkError(error: unknown): boolean {
+  return (
+    error instanceof TypeError ||
+    (error instanceof Error &&
+      (error.name === "AbortError" ||
+        ("code" in error &&
+          (error.code === "reference_storage_network_failed" ||
+            error.code === "reference_upload_network_failed")) ||
+        isPromptUploadServiceUnavailableError(error)))
+  );
+}
+
+export function isPromptUploadAuthRequiredError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    "code" in error &&
+    error.code === "reference_storage_auth_required"
+  );
+}
+
+export function isPromptUploadLimitError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    "code" in error &&
+    error.code === "reference_storage_limit_exceeded"
+  );
+}
+
+export function isPromptUploadUnsupportedFileTypeError(
+  error: unknown,
+): boolean {
+  return (
+    error instanceof Error &&
+    "failureReason" in error &&
+    error.failureReason === "unsupported-file-type"
+  );
+}
+
+export function isPromptUploadStorageStatusError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    "code" in error &&
+    (error.code === "reference_storage_http_failed" ||
+      error.code === "reference_storage_contract_failed")
+  );
+}
+
+function referenceStorageStatusError(code: string, cause?: unknown): Error {
+  return Object.assign(
+    new Error(
+      "Reference file storage status could not be verified",
+      cause === undefined ? undefined : { cause },
+    ),
+    { code },
+  );
+}
+
+export async function addInlineImageFallbacks(
+  files: File[],
+  uploaded: UploadedFile[],
+): Promise<UploadedFile[]> {
+  const inlineDataUrls: string[] = [];
+  const result: UploadedFile[] = [];
+  for (let index = 0; index < uploaded.length; index++) {
+    const uploadedFile = uploaded[index];
+    const file = files[index];
+    const isImage =
+      uploadedFile.type.startsWith("image/") ||
+      Boolean(file?.type.startsWith("image/"));
+    if (!isImage || !file) {
+      result.push(uploadedFile);
+      continue;
+    }
+    if (uploadedFile.url) {
+      const { dataUrl: _dataUrl, ...withoutDataUrl } = uploadedFile;
+      result.push(withoutDataUrl);
+      continue;
+    }
+    if (uploadedFile.dataUrl) {
+      if (canAddInlineImageToPayload(inlineDataUrls, uploadedFile.dataUrl)) {
+        inlineDataUrls.push(uploadedFile.dataUrl);
+        result.push(uploadedFile);
+      } else {
+        const { dataUrl: _dataUrl, ...withoutDataUrl } = uploadedFile;
+        result.push(withoutDataUrl);
+      }
+      continue;
+    }
+    if (!canInlineImageFile(file)) {
+      result.push(uploadedFile);
+      continue;
+    }
+    const dataUrl = await readFileAsDataUrl(file);
+    if (canAddInlineImageToPayload(inlineDataUrls, dataUrl)) {
+      inlineDataUrls.push(dataUrl);
+      result.push({ ...uploadedFile, dataUrl });
+    } else {
+      result.push(uploadedFile);
+    }
+  }
+  return result;
+}
+
+const CHUNK_UPLOAD_THRESHOLD_BYTES = 4 * 1024 * 1024;
+const CHUNK_SIZE_BYTES = 4 * 1024 * 1024;
+const MAX_CONCURRENT_LARGE_UPLOADS = 1;
+
+export async function isReferenceStorageReady(): Promise<boolean> {
+  ensureEmbedAuthFetchInterceptor();
+  let status: unknown;
+  try {
+    status = await callAction(
+      "get-slides-2-upload-storage-status",
+      {},
+      { method: "GET" },
+    );
+  } catch (cause) {
+    const failure = cause as {
+      message?: unknown;
+      name?: unknown;
+      status?: unknown;
+      timedOut?: unknown;
+    } | null;
+    if (failure?.status === 401) {
+      throw referenceStorageStatusError(
+        "reference_storage_auth_required",
+        cause,
+      );
+    }
+    if (
+      failure?.timedOut === true ||
+      failure?.name === "AbortError" ||
+      typeof failure?.status !== "number" ||
+      (failure.status === 200 &&
+        typeof failure.message === "string" &&
+        failure.message.includes("body could not be read"))
+    ) {
+      throw referenceStorageStatusError(
+        "reference_storage_network_failed",
+        cause,
+      );
+    }
+    throw referenceStorageStatusError(
+      failure.status === 200
+        ? "reference_storage_contract_failed"
+        : "reference_storage_http_failed",
+      cause,
+    );
+  }
+  if (
+    !status ||
+    typeof status !== "object" ||
+    typeof (status as { referenceStorageReady?: unknown })
+      .referenceStorageReady !== "boolean"
+  ) {
+    throw referenceStorageStatusError("reference_storage_contract_failed");
+  }
+  return (status as { referenceStorageReady: boolean }).referenceStorageReady;
+}
+
+async function readUploadJson(response: Response): Promise<unknown> {
+  try {
+    return await response.json();
+  } catch (error) {
+    throw promptUploadContractError(error);
+  }
+}
+
+function promptUploadContractError(cause?: unknown): Error {
+  return Object.assign(
+    new Error(
+      "Reference file upload returned an invalid response",
+      cause === undefined ? undefined : { cause },
+    ),
+    { code: "reference_storage_contract_failed" },
+  );
+}
+
+function isUploadedFile(value: unknown): value is UploadedFile {
+  if (!value || typeof value !== "object") return false;
+  const file = value as Record<string, unknown>;
+  return (
+    typeof file.path === "string" &&
+    file.path.length > 0 &&
+    typeof file.originalName === "string" &&
+    file.originalName.length > 0 &&
+    typeof file.filename === "string" &&
+    file.filename.length > 0 &&
+    typeof file.type === "string" &&
+    typeof file.size === "number" &&
+    Number.isFinite(file.size) &&
+    file.size >= 0 &&
+    (file.url === undefined || typeof file.url === "string") &&
+    (file.dataUrl === undefined || typeof file.dataUrl === "string")
+  );
+}
+
+async function parseUploadedFiles(
+  data: unknown,
+  expectedCount: number,
+): Promise<UploadedFile[]> {
+  const records = Array.isArray(data) ? data : [data];
+  const uploaded = records.filter(isUploadedFile);
+  if (
+    !Array.isArray(data) ||
+    uploaded.length !== records.length ||
+    uploaded.length !== expectedCount
+  ) {
+    const completed = records.flatMap((record) =>
+      record &&
+      typeof record === "object" &&
+      typeof (record as { path?: unknown }).path === "string" &&
+      (record as { path: string }).path
+        ? [{ path: (record as { path: string }).path }]
+        : [],
+    );
+    await cleanupUploadedPromptFiles(completed);
+    throw promptUploadContractError();
+  }
+  return uploaded;
+}
+
+export function formatPromptUploadFailure(
+  error: unknown,
+  description: string,
+): string {
+  const fileName =
+    error && typeof error === "object" && "fileName" in error
+      ? (error as { fileName?: unknown }).fileName
+      : undefined;
+  return typeof fileName === "string" && fileName.trim()
+    ? `${fileName}: ${description}`
+    : description;
+}
+
+function promptUploadNetworkError(cause: unknown, fileName?: string): Error {
+  return Object.assign(new Error("Reference file upload failed", { cause }), {
+    code: "reference_upload_network_failed",
+    ...(fileName ? { fileName } : {}),
+  });
+}
+
+export function promptUploadHttpError(
+  status: number,
+  fileName?: string,
+  failureReason?: "unsupported-file-type",
+): Error {
+  return Object.assign(new Error("Reference file upload failed"), {
+    code:
+      status === 401 || status === 403
+        ? "reference_storage_auth_required"
+        : status === 413
+          ? "reference_storage_limit_exceeded"
+          : status === 408 || status === 502 || status === 504
+            ? UPLOAD_SERVICE_UNAVAILABLE_CODE
+            : "reference_storage_http_failed",
+    status,
+    ...(fileName ? { fileName } : {}),
+    ...(failureReason ? { failureReason } : {}),
+  });
+}
+
+async function parsePromptUploadFailure(
+  response: Response,
+  files: readonly File[],
+): Promise<Error> {
+  let body: Record<string, unknown> | undefined;
+  try {
+    const value: unknown = await response.json();
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      body = value as Record<string, unknown>;
+    }
+  } catch {
+    // coercion-ok: the HTTP status remains a typed upload failure when its body is malformed.
+  }
+
+  const failedFileName =
+    typeof body?.failedFileName === "string" ? body.failedFileName : undefined;
+  const fileName =
+    files.find((file) => file.name === failedFileName)?.name ??
+    (failedFileName?.trim()
+      ? failedFileName
+      : files.length === 1
+        ? files[0]?.name
+        : undefined);
+  const failureReason =
+    typeof body?.error === "string" &&
+    body.error.includes("Unsupported file type. Allowed: ")
+      ? "unsupported-file-type"
+      : undefined;
+
+  return promptUploadHttpError(response.status, fileName, failureReason);
+}
+
+async function uploadFilesMultipart(files: File[]): Promise<UploadedFile[]> {
+  const formData = new FormData();
+  files.forEach((file) => formData.append("files", file));
+  let response: Response;
+  try {
+    response = await fetch(`${appBasePath()}/api/uploads`, {
+      method: "POST",
+      body: formData,
+      credentials: "include",
+    });
+  } catch (cause) {
+    if (isPromptUploadNetworkError(cause)) {
+      throw promptUploadNetworkError(
+        cause,
+        files.length === 1 ? files[0]?.name : undefined,
+      );
+    }
+    throw cause;
+  }
+  if (!response.ok) {
+    throw await parsePromptUploadFailure(response, files);
+  }
+  const data = await readUploadJson(response);
+  return parseUploadedFiles(data, files.length);
+}
+
+export async function deleteUploadedPromptFile(
+  file: Pick<UploadedFile, "path">,
+): Promise<void> {
+  const response = await fetch(`${appBasePath()}/api/uploads`, {
+    method: "DELETE",
+    headers: { "content-type": "application/json" },
+    credentials: "include",
+    body: JSON.stringify({ path: file.path }),
+  });
+  if (!response.ok) {
+    throw new Error(`Upload cleanup failed (${response.status})`);
+  }
+}
+
+export async function cleanupUploadedPromptFiles(
+  files: Pick<UploadedFile, "path">[],
+) {
+  const results = await Promise.allSettled(
+    files.map((file) => deleteUploadedPromptFile(file)),
+  );
+  results.forEach((result) => {
+    if (result.status === "rejected") {
+      console.error("Uploaded file cleanup failed", result.reason);
+    }
+  });
+}
+
+async function uploadFileChunked(file: File): Promise<UploadedFile> {
+  const startResponse = await fetch(
+    `${appBasePath()}/api/uploads-chunked/start`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify({
+        filename: file.name,
+        mimetype: file.type || "application/octet-stream",
+        declaredSize: file.size,
+      }),
+    },
+  );
+  if (!startResponse.ok) {
+    throw await parsePromptUploadFailure(startResponse, [file]);
+  }
+  const startData = await readUploadJson(startResponse);
+  if (
+    startData &&
+    typeof startData === "object" &&
+    (startData as { uploadMode?: unknown }).uploadMode === "multipart"
+  ) {
+    const [uploaded] = await uploadFilesMultipart([file]);
+    if (!uploaded) throw new Error("Upload failed: no file returned");
+    return uploaded;
+  }
+  const sessionId =
+    startData && typeof startData === "object"
+      ? (startData as { sessionId?: unknown }).sessionId
+      : undefined;
+  if (typeof sessionId !== "string" || !sessionId) {
+    throw promptUploadContractError();
+  }
+
+  const totalChunks = Math.max(1, Math.ceil(file.size / CHUNK_SIZE_BYTES));
+  for (let index = 0; index < totalChunks; index++) {
+    const start = index * CHUNK_SIZE_BYTES;
+    const end = Math.min(start + CHUNK_SIZE_BYTES, file.size);
+    const isFinal = index === totalChunks - 1;
+    const chunkResponse = await fetch(
+      `${appBasePath()}/api/uploads-chunked/${sessionId}/chunk?index=${index}&isFinal=${
+        isFinal ? "1" : "0"
+      }`,
+      {
+        method: "POST",
+        credentials: "include",
+        headers: { "Content-Type": "application/octet-stream" },
+        body: file.slice(start, end),
+      },
+    );
+    if (!chunkResponse.ok) {
+      throw await parsePromptUploadFailure(chunkResponse, [file]);
+    }
+    const chunkData = await readUploadJson(chunkResponse);
+    if (isFinal) {
+      const [result] = await parseUploadedFiles(chunkData, 1);
+      return result;
+    }
+    if (
+      !chunkData ||
+      typeof chunkData !== "object" ||
+      (chunkData as { ok?: unknown }).ok !== true
+    ) {
+      throw promptUploadContractError();
+    }
+  }
+  throw promptUploadContractError();
+}
+
+export async function uploadPromptFiles(
+  files: File[],
+  storageUnavailableMessage: string,
+): Promise<UploadedFile[]> {
+  if (files.length === 0) return [];
+  if (files.length > MAX_REFERENCE_FILES) {
+    throw new Error(`Too many files (max ${MAX_REFERENCE_FILES})`);
+  }
+  if (!(await isReferenceStorageReady())) {
+    throw Object.assign(new Error(storageUnavailableMessage), {
+      code: "reference_storage_unavailable",
+    });
+  }
+  const smallIndices = files.flatMap((file, index) =>
+    file.size <= CHUNK_UPLOAD_THRESHOLD_BYTES ? [index] : [],
+  );
+  const largeIndices = files.flatMap((file, index) =>
+    file.size > CHUNK_UPLOAD_THRESHOLD_BYTES ? [index] : [],
+  );
+  const limitLargeUploads = pLimit(MAX_CONCURRENT_LARGE_UPLOADS);
+  const smallPromise =
+    smallIndices.length > 0
+      ? uploadFilesMultipart(smallIndices.map((index) => files[index]))
+      : Promise.resolve([] as UploadedFile[]);
+  const [smallResult, largeResults] = await Promise.all([
+    smallPromise.then(
+      (value) => ({ status: "fulfilled" as const, value }),
+      (reason) => ({ status: "rejected" as const, reason }),
+    ),
+    Promise.allSettled(
+      largeIndices.map((index) =>
+        limitLargeUploads(() => uploadFileChunked(files[index])),
+      ),
+    ),
+  ]);
+  const successfulLargeUploads = largeResults.flatMap((result) =>
+    result.status === "fulfilled" ? [result.value] : [],
+  );
+  const failedLargeIndex = largeResults.findIndex(
+    (result) => result.status === "rejected",
+  );
+  if (smallResult.status === "rejected") {
+    await cleanupUploadedPromptFiles([...successfulLargeUploads]);
+    throw smallResult.reason;
+  }
+  if (failedLargeIndex !== -1) {
+    await cleanupUploadedPromptFiles([
+      ...smallResult.value,
+      ...successfulLargeUploads,
+    ]);
+    const failure = largeResults[failedLargeIndex];
+    const cause = failure?.status === "rejected" ? failure.reason : undefined;
+    const fileName = files[largeIndices[failedLargeIndex]]?.name;
+    if (isPromptUploadNetworkError(cause)) {
+      throw promptUploadNetworkError(cause, fileName);
+    }
+    if (
+      isPromptUploadAuthRequiredError(cause) ||
+      isPromptUploadLimitError(cause) ||
+      isPromptUploadStorageStatusError(cause)
+    ) {
+      throw cause;
+    }
+    throw promptUploadHttpError(500, fileName);
+  }
+  const smallUploads = smallResult.value;
+  const largeUploads = successfulLargeUploads;
+  const uploads = new Array<UploadedFile>(files.length);
+  smallIndices.forEach((fileIndex, resultIndex) => {
+    uploads[fileIndex] = smallUploads[resultIndex];
+  });
+  largeIndices.forEach((fileIndex, resultIndex) => {
+    uploads[fileIndex] = largeUploads[resultIndex];
+  });
+  return addInlineImageFallbacks(files, uploads);
+}

package/corpus/templates/slides-2/app/lib/recent-references.ts

@@ -0,0 +1,106 @@
+import { appStorageKey } from "@shared/app-storage";
+
+export const RECENT_REFERENCES_STORAGE_KEY = appStorageKey("recent-references");
+
+export type RecentReferenceKind = "deck" | "design-system";
+
+export interface RecentReference {
+  id: string;
+  kind: RecentReferenceKind;
+  lastUsedAt: number;
+}
+
+export interface RecentReferencesResult {
+  items: RecentReference[];
+  readable: boolean;
+}
+
+const MAX_RECENT_REFERENCES = 8;
+
+function isRecentReference(value: unknown): value is RecentReference {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<RecentReference>;
+  return (
+    typeof candidate.id === "string" &&
+    candidate.id.length > 0 &&
+    (candidate.kind === "deck" || candidate.kind === "design-system") &&
+    typeof candidate.lastUsedAt === "number" &&
+    Number.isFinite(candidate.lastUsedAt)
+  );
+}
+
+export function readRecentReferences(
+  storage: Pick<Storage, "getItem"> | null | undefined = typeof window ===
+  "undefined"
+    ? null
+    : window.localStorage,
+): RecentReferencesResult {
+  if (!storage) return { items: [], readable: true };
+
+  let raw: string | null;
+  try {
+    raw = storage.getItem(RECENT_REFERENCES_STORAGE_KEY);
+  } catch {
+    return { items: [], readable: false };
+  }
+
+  if (raw === null) return { items: [], readable: true };
+
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return { items: [], readable: false };
+    return {
+      items: parsed
+        .filter(isRecentReference)
+        .sort((first, second) => second.lastUsedAt - first.lastUsedAt)
+        .slice(0, MAX_RECENT_REFERENCES),
+      readable: true,
+    };
+  } catch {
+    return { items: [], readable: false };
+  }
+}
+
+export function forgetRecentReference(
+  kind: RecentReferenceKind,
+  storage:
+    | Pick<Storage, "getItem" | "setItem">
+    | null
+    | undefined = typeof window === "undefined" ? null : window.localStorage,
+): RecentReferencesResult {
+  const current = readRecentReferences(storage);
+  if (!storage || !current.readable) return current;
+
+  const next = current.items.filter((item) => item.kind !== kind);
+  try {
+    storage.setItem(RECENT_REFERENCES_STORAGE_KEY, JSON.stringify(next));
+    return { items: next, readable: true };
+  } catch {
+    return { items: current.items, readable: false };
+  }
+}
+
+export function rememberRecentReference(
+  reference: Omit<RecentReference, "lastUsedAt">,
+  storage:
+    | Pick<Storage, "getItem" | "setItem">
+    | null
+    | undefined = typeof window === "undefined" ? null : window.localStorage,
+): RecentReferencesResult {
+  const current = readRecentReferences(storage);
+  if (!storage || !current.readable) return current;
+
+  const next: RecentReference[] = [
+    { ...reference, lastUsedAt: Date.now() },
+    ...current.items.filter(
+      (item) => !(item.id === reference.id && item.kind === reference.kind),
+    ),
+  ].slice(0, MAX_RECENT_REFERENCES);
+
+  try {
+    storage.setItem(RECENT_REFERENCES_STORAGE_KEY, JSON.stringify(next));
+    return { items: next, readable: true };
+  } catch {
+    return { items: current.items, readable: false };
+  }
+}