@agent-native/core-corpus 0.214.0 → 0.217.0

package/corpus/templates/slides-2/app/lib/image-drop-to-agent.ts

@@ -0,0 +1,210 @@
+import { parseBase64DataUrl } from "@agent-native/core/shared";
+import {
+  estimateAttachmentBodyBytes,
+  MAX_ESTIMATED_BODY_BYTES,
+} from "@agent-native/toolkit/composer/attachment-accept";
+
+import { MAX_INLINE_IMAGE_BASE64_CHARS } from "../../shared/upload-types";
+
+export interface HostedImageUploadResult {
+  ok: boolean;
+  status: number;
+  url?: string;
+  error?: string;
+  errorCode?: string;
+}
+
+export type ImageDropAgentPayload =
+  | {
+      kind: "hosted";
+      message: string;
+      context: string;
+      referenceImagePaths: string[];
+      images?: string[];
+    }
+  | {
+      kind: "inline";
+      message: string;
+      context: string;
+      images: string[];
+    };
+
+export function isMissingUploadProviderError(
+  _status: number,
+  error: string | undefined,
+  errorCode?: unknown,
+): boolean {
+  if (errorCode === "image_upload_storage_unavailable") return true;
+  const lower = (error ?? "").toLowerCase();
+  return (
+    lower.includes("no object storage is connected") ||
+    lower.includes("no file upload provider") ||
+    lower.includes("registerfileuploadprovider") ||
+    lower.includes("connect builder.io") ||
+    lower.includes("use builder.io") ||
+    lower.includes("connect file storage before uploading images")
+  );
+}
+
+export function isStorageSetupRequiredError(error: unknown): boolean {
+  // Typed first: the server says who can fix storage, and "nobody connected
+  // it" is the workspace admin's setup, whatever the message says.
+  const typed = error as {
+    errorCode?: unknown;
+    details?: { whoCanFix?: unknown } | null;
+  } | null;
+  if (typed?.errorCode === "image_upload_storage_unavailable") return true;
+  if (typed?.errorCode === "attachment_storage_unavailable") {
+    return typed.details?.whoCanFix === "workspace_admin";
+  }
+  // Image-generation providers may still report missing storage in prose.
+  const message =
+    error instanceof Error
+      ? error.message
+      : error && typeof error === "object" && "message" in error
+        ? String(error.message)
+        : undefined;
+  const status =
+    error && typeof error === "object" && "status" in error
+      ? Number(error.status)
+      : 0;
+  return isMissingUploadProviderError(status, message, typed?.errorCode);
+}
+
+export function buildImageDropAgentPayload(args: {
+  intent: string;
+  contextHint?: string;
+  filename: string;
+  upload: HostedImageUploadResult;
+  dataUrl?: string;
+}): ImageDropAgentPayload {
+  const inlineDataUrl =
+    args.dataUrl && canInlineImageDataUrl(args.dataUrl)
+      ? args.dataUrl
+      : undefined;
+  const intentLine =
+    args.intent.length > 0
+      ? args.intent
+      : "Use this image on the current slide.";
+  const contextLines: string[] = [];
+  if (args.contextHint && args.contextHint.trim().length > 0) {
+    contextLines.push(args.contextHint.trim());
+  }
+  contextLines.push(`Filename: ${args.filename}`);
+
+  if (args.upload.ok && args.upload.url) {
+    contextLines.push(`Image URL (already uploaded): ${args.upload.url}`);
+    if (inlineDataUrl) {
+      contextLines.push(
+        "The original image is also attached for visual inspection.",
+      );
+    }
+    return {
+      kind: "hosted",
+      message: intentLine,
+      context: contextLines.join("\n\n"),
+      referenceImagePaths: [args.upload.url],
+      ...(inlineDataUrl ? { images: [inlineDataUrl] } : {}),
+    };
+  }
+
+  if (
+    isMissingUploadProviderError(
+      args.upload.status,
+      args.upload.error,
+      args.upload.errorCode,
+    )
+  ) {
+    throw Object.assign(
+      new Error(
+        args.upload.error ||
+          "Connect object storage to upload images: Builder.io (free) or your own S3-compatible storage keys.",
+      ),
+      {
+        ...(args.upload.errorCode ? { errorCode: args.upload.errorCode } : {}),
+      },
+    );
+  }
+
+  if (!inlineDataUrl) {
+    throw Object.assign(
+      new Error(
+        args.upload.error ||
+          "Image upload failed. Use Builder.io (free) or configure your own S3-compatible storage keys.",
+      ),
+      {
+        ...(args.upload.errorCode ? { errorCode: args.upload.errorCode } : {}),
+      },
+    );
+  }
+
+  if (
+    !isMissingUploadProviderError(
+      args.upload.status,
+      args.upload.error,
+      args.upload.errorCode,
+    )
+  ) {
+    contextLines.push(
+      "Hosted upload failed; the image is attached inline as a data URL. Call upload-image on it before placing it on the slide if a durable URL is required.",
+    );
+  }
+
+  return {
+    kind: "inline",
+    message: intentLine,
+    context: contextLines.join("\n\n"),
+    images: [inlineDataUrl],
+  };
+}
+
+export function canInlineImageFile(file: File): boolean {
+  const mediaType = file.type || "application/octet-stream";
+  if (mediaType.split(";", 1)[0]?.trim().toLowerCase() === "image/svg+xml") {
+    return false;
+  }
+  if (/\.svg$/i.test(file.name)) return false;
+  const encodedLength = Math.ceil(file.size / 3) * 4;
+  return (
+    encodedLength + `data:${mediaType};base64,`.length <=
+    MAX_INLINE_IMAGE_BASE64_CHARS
+  );
+}
+
+export function canInlineImageDataUrl(dataUrl: string): boolean {
+  const parsed = parseBase64DataUrl(dataUrl);
+  return Boolean(
+    parsed &&
+    parsed.mediaType.startsWith("image/") &&
+    parsed.mediaType !== "image/svg+xml" &&
+    dataUrl.length <= MAX_INLINE_IMAGE_BASE64_CHARS,
+  );
+}
+
+export function canAddInlineImageToPayload(
+  existingDataUrls: readonly string[],
+  candidate: string,
+): boolean {
+  return (
+    canInlineImageDataUrl(candidate) &&
+    estimateAttachmentBodyBytes([...existingDataUrls, candidate]) <=
+      MAX_ESTIMATED_BODY_BYTES
+  );
+}
+
+export function readFileAsDataUrl(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const result = reader.result;
+      if (typeof result === "string" && result.startsWith("data:")) {
+        resolve(result);
+      } else {
+        reject(new Error("Failed to read image file."));
+      }
+    };
+    reader.onerror = () =>
+      reject(reader.error ?? new Error("Failed to read image file."));
+    reader.readAsDataURL(file);
+  });
+}

package/corpus/templates/slides-2/app/lib/import-uploaded-deck.ts

@@ -0,0 +1,132 @@
+import { callAction } from "@agent-native/core/client/hooks";
+
+import type { UploadedFile } from "@/components/editor/PromptDialog";
+
+import { SOURCE_IMPORT_NO_WRITE_ERROR_CODE } from "../../shared/source-import-errors";
+
+export type ImportedSourceDeck = {
+  file: UploadedFile;
+  format: "pdf" | "pptx";
+  slideCount: number;
+  imagesSkipped: number;
+};
+
+export const IMPORT_ACTION_TIMEOUT_MS = 5 * 60 * 1000;
+
+export interface ImportUploadedDeckOptions {
+  onImportStarted?: () => void;
+  onImportCleanupSafe?: () => void;
+}
+
+function sourceFormat(file: UploadedFile): "pdf" | "pptx" | null {
+  const name = file.originalName.toLowerCase();
+  if (name.endsWith(".pptx")) return "pptx";
+  if (name.endsWith(".pdf")) return "pdf";
+  return null;
+}
+
+function actionResultRecord(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("The uploaded presentation import returned no result.");
+  }
+  return value as Record<string, unknown>;
+}
+
+function validatedSourceDeckFiles(files: UploadedFile[]): UploadedFile[] {
+  const deckFiles = files.filter((file) => sourceFormat(file));
+  if (deckFiles.length > 1) {
+    throw new Error(
+      "Upload one presentation at a time when asking Slides to improve it. Multiple source decks cannot be merged safely without losing slide order or content.",
+    );
+  }
+  return deckFiles;
+}
+
+export function validateUploadedDeckImport(
+  files: UploadedFile[],
+): UploadedFile[] {
+  return validatedSourceDeckFiles(files);
+}
+
+export async function importUploadedDeckIntoDeck(
+  files: UploadedFile[],
+  deckId: string,
+  options: ImportUploadedDeckOptions = {},
+): Promise<ImportedSourceDeck | null> {
+  const deckFiles = validatedSourceDeckFiles(files);
+  if (deckFiles.length === 0) return null;
+
+  const file = deckFiles[0];
+  if (!file) return null;
+  const format = sourceFormat(file);
+  if (!format) return null;
+
+  options.onImportStarted?.();
+  let actionResult: unknown;
+  try {
+    actionResult = await callAction(
+      format === "pptx" ? "import-pptx" : "import-file",
+      format === "pptx"
+        ? { filePath: file.path, deckId }
+        : {
+            filePath: file.path,
+            format: "pdf",
+            deckId,
+            importIntoDeck: true,
+          },
+      { timeoutMs: IMPORT_ACTION_TIMEOUT_MS },
+    );
+  } catch (error) {
+    if (
+      error &&
+      typeof error === "object" &&
+      "errorCode" in error &&
+      error.errorCode === SOURCE_IMPORT_NO_WRITE_ERROR_CODE
+    ) {
+      options.onImportCleanupSafe?.();
+    }
+    throw error;
+  }
+  const result = actionResultRecord(actionResult);
+  if (result.imported !== true || result.deckId !== deckId) {
+    throw new Error(
+      `The ${format.toUpperCase()} source deck was not imported into the target deck, so no source-preserving improvement was started.`,
+    );
+  }
+
+  const slideCount = result.slideCount;
+  if (
+    typeof slideCount !== "number" ||
+    !Number.isInteger(slideCount) ||
+    slideCount < 0
+  ) {
+    throw new Error(
+      `The ${format.toUpperCase()} import did not report a reliable slide count, so no source-preserving improvement was started.`,
+    );
+  }
+  const imagesSkipped = result.imagesSkipped ?? 0;
+  if (
+    typeof imagesSkipped !== "number" ||
+    !Number.isInteger(imagesSkipped) ||
+    imagesSkipped < 0
+  ) {
+    throw new Error(
+      `The ${format.toUpperCase()} import did not report a reliable image count, so no source-preserving improvement was started.`,
+    );
+  }
+  if (slideCount < 1) {
+    options.onImportCleanupSafe?.();
+    throw new Error(
+      `The ${format.toUpperCase()} source deck contained no importable slides.`,
+    );
+  }
+
+  if (imagesSkipped > 0) {
+    throw new Error(
+      `The ${format.toUpperCase()} source deck could not preserve ${imagesSkipped} image(s), so Slides stopped before restyling it. Re-export the deck with browser-renderable images, or upload a PDF for source-faithful page preservation.`,
+    );
+  }
+
+  options.onImportCleanupSafe?.();
+  return { file, format, slideCount, imagesSkipped };
+}

package/corpus/templates/slides-2/app/lib/inline-edit-remote.ts

@@ -0,0 +1,55 @@
+/**
+ * The open text edit's side of showing another writer's saved edit to the same
+ * slide. The deck state asks the registered editor to put `remote` on its
+ * canvas; it adopts the copy only when the editor did, because an adopted copy
+ * the canvas never showed would be saved over by the next draft.
+ *
+ * - `applied`: the canvas now shows `remote` around the unsaved edit.
+ * - `later`: the editor cannot take it right now (an IME composition is open);
+ *   it asks for a retry through `requestInlineEditRemoteRetry`.
+ * - `held`: the other writer's change touches the edited text or the slide's
+ *   structure. It waits for the edit to end, or meets the draft at save time.
+ */
+export type InlineEditRemoteResult = "applied" | "later" | "held";
+
+export type InlineEditRemoteApplier = (
+  confirmed: string,
+  remote: string,
+) => InlineEditRemoteResult;
+
+const appliers = new Map<string, InlineEditRemoteApplier>();
+const retryHandlers = new Set<(deckId: string) => void>();
+
+const keyOf = (deckId: string, slideId: string) => `${deckId}\u0000${slideId}`;
+
+export function registerInlineEditRemoteApplier(
+  deckId: string,
+  slideId: string,
+  applier: InlineEditRemoteApplier,
+): () => void {
+  const key = keyOf(deckId, slideId);
+  appliers.set(key, applier);
+  return () => {
+    if (appliers.get(key) === applier) appliers.delete(key);
+  };
+}
+
+export function applyRemoteSlideUnderInlineEdit(
+  deckId: string,
+  slideId: string,
+  confirmed: string,
+  remote: string,
+): InlineEditRemoteResult {
+  return appliers.get(keyOf(deckId, slideId))?.(confirmed, remote) ?? "held";
+}
+
+export function onInlineEditRemoteRetry(
+  handler: (deckId: string) => void,
+): () => void {
+  retryHandlers.add(handler);
+  return () => retryHandlers.delete(handler);
+}
+
+export function requestInlineEditRemoteRetry(deckId: string) {
+  for (const handler of retryHandlers) handler(deckId);
+}

package/corpus/templates/slides-2/app/lib/localize-slides-changelog.ts

@@ -0,0 +1,47 @@
+export type SlidesChangelogTranslations = {
+  editorHoveredObjects: string;
+  deckEditingControls: string;
+  googleSlidesMissingImageData: string;
+  globalMediaPickerScope: string;
+  savedSlideImages: string;
+};
+
+const localizedBodies = [
+  {
+    source:
+      "The editor highlights hovered objects and keeps image replace and crop actions on the canvas.",
+    key: "editorHoveredObjects",
+  },
+  {
+    source:
+      "The slide-list toggle, deck title, and Present button now match the shared workspace controls.",
+    key: "deckEditingControls",
+  },
+  {
+    source:
+      "Google Slides imports now report missing image data instead of adding empty images.",
+    key: "googleSlidesMissingImageData",
+  },
+  {
+    source: "Scope global media picks to assets the current deck can resolve.",
+    key: "globalMediaPickerScope",
+  },
+  {
+    source: "Images used by saved slides stay available in your library.",
+    key: "savedSlideImages",
+  },
+] as const satisfies ReadonlyArray<{
+  source: string;
+  key: keyof SlidesChangelogTranslations;
+}>;
+
+export function localizeSlidesChangelog(
+  markdown: string,
+  translations: SlidesChangelogTranslations,
+): string {
+  return localizedBodies.reduce(
+    (localized, { source, key }) =>
+      localized.replace(source, translations[key]),
+    markdown,
+  );
+}

package/corpus/templates/slides-2/app/lib/mermaid-blocks.ts

@@ -0,0 +1,18 @@
+export function mermaidBlockPattern(): RegExp {
+  return /<div\s+class="mermaid"[^>]*>([\s\S]*?)<\/div>/gi;
+}
+
+export function extractMermaidBlocks(content: string): {
+  blocks: string[];
+  contentWithPlaceholders: string;
+} {
+  const blocks: string[] = [];
+  const contentWithPlaceholders = content.replace(
+    mermaidBlockPattern(),
+    (_, definition) => {
+      blocks.push(String(definition).trim());
+      return `<div data-mermaid-index="${blocks.length - 1}"></div>`;
+    },
+  );
+  return { blocks, contentWithPlaceholders };
+}

package/corpus/templates/slides-2/app/lib/new-deck-reference-selection.ts

@@ -0,0 +1,174 @@
+import { appPath } from "@agent-native/core/client/api-path";
+import type { AgentChatContextItem } from "@agent-native/toolkit/composer";
+
+import type { SlidesComposerContext } from "./composer-context";
+
+export interface NewDeckReferenceSelection {
+  composerContext?: SlidesComposerContext;
+  contextItems?: readonly AgentChatContextItem[];
+  designSystemId?: string | null;
+  automaticReferenceDeckId?: string | null;
+  referenceDeckId?: string | null;
+  referenceDeckIdSource?: ReferenceDeckIdSource;
+  referenceFilePaths?: string[];
+  importedReferenceFilePath?: string;
+  referenceSource?: {
+    kind: "google-docs" | "website" | "figma";
+    value: string;
+  } | null;
+}
+
+export type ReferenceDeckIdSource = "prompt" | "selection" | "automatic";
+
+export type NewDeckReferenceSource = NonNullable<
+  NewDeckReferenceSelection["referenceSource"]
+>;
+
+export function getAutomaticReferenceDeckIdToRemove(
+  selection: NewDeckReferenceSelection | undefined,
+  fallback?: string | null,
+): string | null {
+  const automaticReferenceDeckId =
+    selection?.automaticReferenceDeckId ?? fallback ?? null;
+  const hasExplicitSelection =
+    selection?.referenceDeckIdSource === "selection" ||
+    (selection?.referenceDeckId !== undefined &&
+      selection.referenceDeckIdSource !== "prompt" &&
+      selection.referenceDeckIdSource !== "automatic");
+  if (
+    hasExplicitSelection &&
+    selection?.referenceDeckId === automaticReferenceDeckId
+  ) {
+    return null;
+  }
+  return automaticReferenceDeckId;
+}
+
+export function withoutAutomaticReferenceDeck(
+  selection: NewDeckReferenceSelection,
+): NewDeckReferenceSelection {
+  const automaticDeckIds = new Set(
+    [
+      getAutomaticReferenceDeckIdToRemove(selection),
+      selection.referenceDeckIdSource === "automatic"
+        ? selection.referenceDeckId
+        : null,
+    ].filter((id): id is string => Boolean(id)),
+  );
+  const next = { ...selection };
+  delete next.automaticReferenceDeckId;
+  if (selection.referenceDeckIdSource === "automatic") {
+    delete next.referenceDeckId;
+    delete next.referenceDeckIdSource;
+  }
+  if (automaticDeckIds.size === 0) return next;
+
+  if (selection.composerContext) {
+    next.composerContext = {
+      ...selection.composerContext,
+      references: selection.composerContext.references.filter(
+        (reference) =>
+          reference.source !== "slides" || !automaticDeckIds.has(reference.id),
+      ),
+    };
+  }
+  if (selection.contextItems) {
+    const automaticContextItemKeys = new Set(
+      [...automaticDeckIds].map((id) => `slides:${id}:`),
+    );
+    next.contextItems = selection.contextItems.filter(
+      (item) => !automaticContextItemKeys.has(item.key),
+    );
+  }
+  return next;
+}
+
+export function findPromptReferenceDeckId(
+  prompt: string,
+  origin: string,
+  decks: readonly { id: string }[],
+): string | null {
+  const idsByPath = new Map(
+    decks.map((deck) => [
+      new URL(appPath(`/deck/${encodeURIComponent(deck.id)}`), origin).pathname,
+      deck.id,
+    ]),
+  );
+  const matches = new Set<string>();
+
+  for (const rawUrl of prompt.match(/https?:\/\/[^\s<>"'`]+/g) ?? []) {
+    try {
+      const url = new URL(rawUrl.replace(/[)\]}>,.;!?]+$/u, ""));
+      if (url.origin !== origin) continue;
+      const id = idsByPath.get(url.pathname);
+      if (id) matches.add(id);
+    } catch {
+      continue;
+    }
+  }
+
+  return matches.size === 1 ? (matches.values().next().value ?? null) : null;
+}
+
+export function resolveRetryReferenceDeckSelection(args: {
+  automaticReferenceDeckRemovedFromComposer: boolean;
+  carriedDeckMissing: boolean;
+  hasComposerContext: boolean;
+  hasExplicitComposerDeckReference: boolean;
+  carriedImportedReferenceDeckId?: string;
+  promptReferenceDeckId: string | null;
+  reusingRetryInputs: boolean;
+  retryReferenceDeckId?: string | null;
+  retryReferenceDeckIdSource?: ReferenceDeckIdSource;
+}): {
+  referenceDeckId: string | null | undefined;
+  referenceDeckIdSource?: ReferenceDeckIdSource;
+} {
+  const {
+    automaticReferenceDeckRemovedFromComposer,
+    carriedDeckMissing,
+    hasComposerContext,
+    hasExplicitComposerDeckReference,
+    carriedImportedReferenceDeckId,
+    promptReferenceDeckId,
+    reusingRetryInputs,
+    retryReferenceDeckId,
+    retryReferenceDeckIdSource,
+  } = args;
+  const referenceDeckId =
+    carriedDeckMissing || hasExplicitComposerDeckReference
+      ? null
+      : retryReferenceDeckIdSource === "automatic"
+        ? (promptReferenceDeckId ??
+          (!reusingRetryInputs || automaticReferenceDeckRemovedFromComposer
+            ? null
+            : (carriedImportedReferenceDeckId ??
+              retryReferenceDeckId ??
+              (hasComposerContext ? null : undefined))))
+        : retryReferenceDeckIdSource === "prompt"
+          ? reusingRetryInputs
+            ? (retryReferenceDeckId ?? promptReferenceDeckId ?? null)
+            : (promptReferenceDeckId ?? null)
+          : retryReferenceDeckIdSource === "selection"
+            ? (retryReferenceDeckId ?? null)
+            : retryReferenceDeckId !== undefined
+              ? retryReferenceDeckId
+              : (carriedImportedReferenceDeckId ??
+                promptReferenceDeckId ??
+                (hasComposerContext ? null : undefined));
+  const hasExplicitDeckSelection =
+    hasExplicitComposerDeckReference ||
+    retryReferenceDeckIdSource === "selection" ||
+    (retryReferenceDeckId !== undefined &&
+      retryReferenceDeckIdSource !== "prompt" &&
+      retryReferenceDeckIdSource !== "automatic");
+
+  return {
+    referenceDeckId,
+    referenceDeckIdSource: hasExplicitDeckSelection
+      ? "selection"
+      : promptReferenceDeckId
+        ? "prompt"
+        : retryReferenceDeckIdSource,
+  };
+}