@agent-native/core 0.141.7 → 0.144.1

package/corpus/templates/slides/actions/import-google-slides-reference.ts

@@ -1,10 +1,19 @@
 import { defineAction } from "@agent-native/core";
+import { ssrfSafeFetch } from "@agent-native/core/extensions/url-safety";
 import { buildDeepLink } from "@agent-native/core/server";
 import { getRequestUserEmail } from "@agent-native/core/server/request-context";
+import pLimit from "p-limit";
 import { z } from "zod";
 
+import {
+  parsePptx,
+  type ParsedPresentation,
+} from "../server/handlers/import/pptx-parser.js";
 import { getGoogleDocsAccessToken } from "../server/lib/google-docs-oauth.js";
-import { importPptxBufferToDeck } from "./import-pptx.js";
+import {
+  importPptxBufferToDeck,
+  type ImportedImageFallback,
+} from "./import-pptx.js";
 
 function deckDeepLink(deckId: string): string {
   return buildDeepLink({
@@ -14,6 +23,38 @@ function deckDeepLink(deckId: string): string {
   });
 }
 
+export function extractGoogleSlidesPresentationId(value: string): string {
+  const candidate = value.trim();
+  if (!candidate)
+    throw new Error("A Google Slides file ID or URL is required.");
+
+  if (!/^https?:\/\//i.test(candidate)) {
+    if (!/^[a-zA-Z0-9_-]+$/.test(candidate)) {
+      throw new Error(
+        "Use a Google Slides file ID or a docs.google.com presentation URL.",
+      );
+    }
+    return candidate;
+  }
+
+  let url: URL;
+  try {
+    url = new URL(candidate);
+  } catch {
+    throw new Error("Use a valid Google Slides presentation URL.");
+  }
+  if (url.hostname !== "docs.google.com") {
+    throw new Error("Use a docs.google.com Google Slides presentation URL.");
+  }
+  const match = url.pathname.match(
+    /^\/presentation\/d\/([a-zA-Z0-9_-]+)(?:\/|$)/,
+  );
+  if (!match) {
+    throw new Error("That URL is not a Google Slides presentation link.");
+  }
+  return match[1];
+}
+
 async function exportGoogleSlidesAsPptx(fileId: string, accessToken: string) {
   const response = await fetch(
     `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}/export?mimeType=application/vnd.openxmlformats-officedocument.presentationml.presentation`,
@@ -36,36 +77,254 @@ async function exportGoogleSlidesAsPptx(fileId: string, accessToken: string) {
   return Buffer.from(bytes);
 }
 
+interface GoogleSlidesImageElement {
+  objectId?: string;
+  size?: {
+    width?: { magnitude?: number };
+    height?: { magnitude?: number };
+  };
+  transform?: {
+    scaleX?: number;
+    scaleY?: number;
+    translateX?: number;
+    translateY?: number;
+  };
+  image?: {
+    contentUrl?: string;
+    imageProperties?: {
+      cropProperties?: {
+        leftOffset?: number;
+        rightOffset?: number;
+        topOffset?: number;
+        bottomOffset?: number;
+      };
+    };
+  };
+}
+
+interface GoogleSlidesPresentationImages {
+  slides?: Array<{
+    pageElements?: GoogleSlidesImageElement[];
+  }>;
+}
+
+interface GoogleSlidesImageCandidate {
+  slideIndex: number;
+  imageIndex: number;
+  objectId?: string;
+  contentUrl: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  crop?: ImportedImageFallback["crop"];
+}
+
+function finiteNumber(value: number | undefined): number | undefined {
+  return value != null && Number.isFinite(value) ? value : undefined;
+}
+
+/**
+ * Google Drive's PPTX export can omit image page elements that remain present
+ * in the native Slides document. Read those native objects as a fidelity
+ * fallback so a direct Google Slides import does not silently lose artwork.
+ */
+async function fetchGoogleSlidesImageFallbacks(
+  fileId: string,
+  accessToken: string,
+  presentation: ParsedPresentation,
+): Promise<ImportedImageFallback[]> {
+  const fields =
+    "slides(pageElements(objectId,size,transform,image(contentUrl,imageProperties(cropProperties))))";
+  const response = await ssrfSafeFetch(
+    `https://slides.googleapis.com/v1/presentations/${encodeURIComponent(fileId)}?fields=${encodeURIComponent(fields)}`,
+    { headers: { Authorization: `Bearer ${accessToken}` } },
+    { httpsOnly: true, maxRedirects: 2 },
+  );
+  if (!response.ok) {
+    throw new Error(
+      `Google Slides returned HTTP ${response.status} while reading native image elements. Reconnect Google Drive and try the import again.`,
+    );
+  }
+  const googlePresentation =
+    (await response.json()) as GoogleSlidesPresentationImages;
+  const candidates: GoogleSlidesImageCandidate[] = [];
+  const candidateKeys = new Set<string>();
+
+  for (const [slideIndex, slide] of (
+    googlePresentation.slides ?? []
+  ).entries()) {
+    for (const [imageIndex, element] of (slide.pageElements ?? []).entries()) {
+      const contentUrl = element.image?.contentUrl;
+      const baseWidth = finiteNumber(element.size?.width?.magnitude);
+      const baseHeight = finiteNumber(element.size?.height?.magnitude);
+      const scaleX = finiteNumber(element.transform?.scaleX) ?? 1;
+      const scaleY = finiteNumber(element.transform?.scaleY) ?? 1;
+      const x = finiteNumber(element.transform?.translateX);
+      const y = finiteNumber(element.transform?.translateY);
+      const width =
+        baseWidth == null ? undefined : baseWidth * Math.abs(scaleX);
+      const height =
+        baseHeight == null ? undefined : baseHeight * Math.abs(scaleY);
+      if (
+        !contentUrl ||
+        x == null ||
+        y == null ||
+        width == null ||
+        height == null ||
+        width <= 0 ||
+        height <= 0
+      ) {
+        continue;
+      }
+
+      const existingImage = presentation.slides[slideIndex]?.elements.some(
+        (existing) =>
+          existing.kind === "image" &&
+          Math.abs(existing.x - x) < 1000 &&
+          Math.abs(existing.y - y) < 1000 &&
+          Math.abs(existing.width - width) < 1000 &&
+          Math.abs(existing.height - height) < 1000,
+      );
+      if (existingImage) continue;
+
+      const cropProperties = element.image?.imageProperties?.cropProperties;
+      const crop = cropProperties
+        ? {
+            left: cropProperties.leftOffset ?? 0,
+            top: cropProperties.topOffset ?? 0,
+            right: cropProperties.rightOffset ?? 0,
+            bottom: cropProperties.bottomOffset ?? 0,
+          }
+        : undefined;
+      const candidateKey = `${slideIndex}:${x}:${y}:${width}:${height}`;
+      if (candidateKeys.has(candidateKey)) continue;
+      candidateKeys.add(candidateKey);
+      candidates.push({
+        slideIndex,
+        imageIndex,
+        ...(element.objectId ? { objectId: element.objectId } : {}),
+        contentUrl,
+        x,
+        y,
+        width,
+        height,
+        ...(crop ? { crop } : {}),
+      });
+    }
+  }
+
+  const downloadLimit = pLimit(4);
+  const imageDownloads = new Map<
+    string,
+    Promise<{ data: Uint8Array; mimeType: string }>
+  >();
+  const downloadImage = (candidate: GoogleSlidesImageCandidate) => {
+    const existing = imageDownloads.get(candidate.contentUrl);
+    if (existing) return existing;
+
+    const download = downloadLimit(async () => {
+      const imageResponse = await ssrfSafeFetch(
+        candidate.contentUrl,
+        { headers: { Authorization: `Bearer ${accessToken}` } },
+        { httpsOnly: true, maxRedirects: 2 },
+      );
+      if (!imageResponse.ok) {
+        throw new Error(
+          `Google Slides returned HTTP ${imageResponse.status} while downloading image ${candidate.imageIndex + 1} on slide ${candidate.slideIndex + 1}.`,
+        );
+      }
+      const mimeType =
+        imageResponse.headers.get("content-type")?.split(";", 1)[0] ||
+        "image/png";
+      if (!mimeType.startsWith("image/")) {
+        throw new Error(
+          `Google Slides returned a non-image asset for image ${candidate.imageIndex + 1} on slide ${candidate.slideIndex + 1}.`,
+        );
+      }
+      return {
+        data: new Uint8Array(await imageResponse.arrayBuffer()),
+        mimeType,
+      };
+    });
+    imageDownloads.set(candidate.contentUrl, download);
+    return download;
+  };
+
+  return Promise.all(
+    candidates.map(async (candidate) => {
+      const { data, mimeType } = await downloadImage(candidate);
+      return {
+        slideIndex: candidate.slideIndex,
+        x: candidate.x,
+        y: candidate.y,
+        width: candidate.width,
+        height: candidate.height,
+        data,
+        mimeType,
+        name: `google-slides-${candidate.slideIndex + 1}-${candidate.objectId ?? candidate.imageIndex}.png`,
+        ...(candidate.crop ? { crop: candidate.crop } : {}),
+      };
+    }),
+  );
+}
+
 export default defineAction({
   description:
-    "Import a Google Slides deck selected from Google Picker and save it as a reusable Slides reference deck. " +
+    "Import a Google Slides deck selected from Google Picker or provided as a Google Slides URL and save it as a reusable Slides reference deck. " +
     "The selected presentation is exported from Drive as PPTX, parsed, and stored as a normal deck in the caller's Slides workspace.",
-  schema: z.object({
-    fileId: z.string().describe("Google Slides file ID from Google Picker"),
-    title: z
-      .string()
-      .optional()
-      .describe("Optional title for the imported reference deck"),
-  }),
-  run: async ({ fileId, title }) => {
+  schema: z
+    .object({
+      fileId: z
+        .string()
+        .optional()
+        .describe("Google Slides file ID from Google Picker"),
+      presentationUrl: z
+        .string()
+        .url()
+        .optional()
+        .describe("A docs.google.com Google Slides presentation URL"),
+      title: z
+        .string()
+        .optional()
+        .describe("Optional title for the imported reference deck"),
+    })
+    .refine(
+      ({ fileId, presentationUrl }) => Boolean(fileId || presentationUrl),
+      {
+        message: "Provide either fileId or presentationUrl.",
+      },
+    ),
+  run: async ({ fileId, presentationUrl, title }) => {
     const owner = getRequestUserEmail();
     if (!owner) throw new Error("no authenticated user");
 
     const connection = await getGoogleDocsAccessToken(owner);
     if (!connection) {
       throw new Error(
-        "Connect Google Docs before importing a Google Slides deck.",
+        "Google Drive is not connected. Use the Connect Google button in Slides, then try again.",
       );
     }
 
+    const presentationId = extractGoogleSlidesPresentationId(
+      presentationUrl ?? fileId ?? "",
+    );
     const fileBuffer = await exportGoogleSlidesAsPptx(
-      fileId,
+      presentationId,
+      connection.accessToken,
+    );
+    const parsedPresentation = await parsePptx(fileBuffer);
+    const imageFallbacks = await fetchGoogleSlidesImageFallbacks(
+      presentationId,
       connection.accessToken,
+      parsedPresentation,
     );
     return importPptxBufferToDeck({
       fileBuffer,
+      parsedPresentation,
       title,
       source: "import-google-slides-reference",
+      imageFallbacks,
     });
   },
   link: ({ result }) => {

package/corpus/templates/slides/actions/import-pptx.ts

@@ -1,6 +1,5 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
-import { uploadFile } from "@agent-native/core/file-upload";
 import {
   getRequestUserEmail,
   getRequestOrgId,
@@ -13,58 +12,86 @@ import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
 import { notifyClients } from "../server/handlers/decks.js";
 import { convertToSlideHtml } from "../server/handlers/import/html-converter.js";
+import { uploadPptxSlideImages } from "../server/handlers/import/pptx-assets.js";
 import {
   parsePptx,
-  type ParsedSlide,
+  type ParsedElement,
+  type ParsedImage,
+  type ParsedPresentation,
 } from "../server/handlers/import/pptx-parser.js";
+import { buildSourceImportMetadata } from "../server/lib/source-import.js";
+import {
+  ASPECT_RATIOS,
+  DEFAULT_ASPECT_RATIO,
+  type AspectRatio,
+} from "../shared/aspect-ratios.js";
 import { getDeckUrl } from "./_app-url.js";
 import { readUserUploadedFile } from "./_uploaded-files.js";
 
-// EMF/WMF (Windows metafiles) and TIFF are valid PPTX embed formats but
-// browsers can't render them in an <img> tag — uploading and linking one
-// would just produce a broken image icon.
-const BROWSER_RENDERABLE_IMAGE_MIME_TYPES = new Set([
-  "image/png",
-  "image/jpeg",
-  "image/gif",
-  "image/webp",
-  "image/svg+xml",
-  "image/bmp",
-]);
-
-async function uploadFirstSlideImage(
-  slide: ParsedSlide,
-  slideIndex: number,
-  ownerEmail: string,
-): Promise<string | undefined> {
-  const image = slide.images[0];
-  if (!image || !BROWSER_RENDERABLE_IMAGE_MIME_TYPES.has(image.mimeType)) {
-    return undefined;
-  }
-  const filename =
-    "pptx-import-" + Date.now() + "-s" + slideIndex + "-" + image.name;
-  try {
-    const result = await uploadFile({
-      data: Buffer.from(image.data),
-      filename,
-      mimeType: image.mimeType,
-      ownerEmail,
-      recordAsset: false,
-    });
-    return result?.url;
-  } catch {
-    // A single slide's upload failing (network/API/rate-limit) shouldn't
-    // abort the whole deck import — that slide's text still imports fine,
-    // it just falls back to a placeholder like an unsupported format would.
-    return undefined;
+export interface ImportedImageFallback {
+  slideIndex: number;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  data: Uint8Array;
+  mimeType: string;
+  name: string;
+  crop?: ParsedImage["crop"];
+}
+
+/** Add source-native image objects that a Google Slides PPTX export omitted. */
+export function applyImageFallbacks(
+  presentation: Awaited<ReturnType<typeof parsePptx>>,
+  fallbacks: ImportedImageFallback[] = [],
+): number {
+  let added = 0;
+  for (const [fallbackIndex, fallback] of fallbacks.entries()) {
+    const slide = presentation.slides[fallback.slideIndex];
+    if (!slide || fallback.width <= 0 || fallback.height <= 0) continue;
+
+    const duplicate = slide.elements.some(
+      (element) =>
+        element.kind === "image" &&
+        Math.abs(element.x - fallback.x) < 1000 &&
+        Math.abs(element.y - fallback.y) < 1000 &&
+        Math.abs(element.width - fallback.width) < 1000 &&
+        Math.abs(element.height - fallback.height) < 1000,
+    );
+    if (duplicate) continue;
+
+    const image: ParsedImage = {
+      data: fallback.data,
+      mimeType: fallback.mimeType,
+      name: fallback.name,
+      aspectRatio: fallback.width / fallback.height,
+      ...(fallback.crop ? { crop: fallback.crop } : {}),
+    };
+    const element: ParsedElement = {
+      id: `image-fallback-${fallback.slideIndex}-${fallbackIndex}`,
+      name: fallback.name,
+      kind: "image",
+      x: fallback.x,
+      y: fallback.y,
+      width: fallback.width,
+      height: fallback.height,
+      image,
+    };
+    slide.images.push(image);
+    slide.elements.push(element);
+    added++;
   }
+  return added;
 }
 
 export async function importPptxBufferToDeck(args: {
   fileBuffer: Buffer;
   title?: string;
   deckId?: string;
+  designSystemId?: string | null;
   source?: string;
+  imageFallbacks?: ImportedImageFallback[];
+  parsedPresentation?: ParsedPresentation;
 }): Promise<{
   id: string;
   title: string;
@@ -74,8 +101,17 @@ export async function importPptxBufferToDeck(args: {
   url: string;
   imagesSkipped?: number;
 }> {
-  const { fileBuffer, title, deckId, source = "import-pptx" } = args;
-  const presentation = await parsePptx(fileBuffer);
+  const {
+    fileBuffer,
+    title,
+    deckId,
+    designSystemId,
+    source = "import-pptx",
+    imageFallbacks,
+    parsedPresentation,
+  } = args;
+  const presentation = parsedPresentation ?? (await parsePptx(fileBuffer));
+  applyImageFallbacks(presentation, imageFallbacks);
   const deckTitle = title || presentation.title || "Imported Presentation";
   const ownerEmail = getRequestUserEmail();
   if (!ownerEmail) throw new Error("no authenticated user");
@@ -88,38 +124,38 @@ export async function importPptxBufferToDeck(args: {
     await assertAccess("deck", deckId, "editor");
   }
 
-  // Convert each parsed slide to our HTML format, uploading the first
-  // embedded image (if any) so it renders as a real image instead of a
-  // text placeholder. Concurrency is capped so a large deck doesn't fire
-  // one outbound upload per slide at once. An image can end up unused
-  // (unsupported format, or upload storage not configured) without
-  // failing the whole import — the slide's text still imports fine — but
-  // that shouldn't be a silent, invisible degradation, so it's counted
-  // and returned to the caller.
+  // Convert each parsed slide to its positioned scene graph, uploading every
+  // browser-renderable image so the imported deck keeps the source layering
+  // and media instead of collapsing to a one-image approximation.
   const uploadLimit = pLimit(4);
   const results = await Promise.all(
     presentation.slides.map((parsedSlide, i) =>
       uploadLimit(async () => {
-        const imageUrl = await uploadFirstSlideImage(
-          parsedSlide,
-          i,
+        const uploadedImages = await uploadPptxSlideImages({
+          slide: parsedSlide,
+          slideIndex: i,
           ownerEmail,
+        });
+        const html = convertToSlideHtml(
+          parsedSlide,
+          uploadedImages.urls,
+          themeFont,
         );
-        const html = convertToSlideHtml(parsedSlide, imageUrl, themeFont);
+        const id = `slide-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
         return {
           slide: {
-            id: `slide-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+            id,
             content: html,
             layout: parsedSlide.layoutHint ?? "content",
             notes: parsedSlide.notes,
+            ...(parsedSlide.transition
+              ? { transition: parsedSlide.transition }
+              : {}),
+            ...(parsedSlide.splitByParagraph ? { splitByParagraph: true } : {}),
           },
-          // Only the first image on a slide is ever uploaded, so every
-          // other image on that slide is unconditionally dropped too —
-          // not just the first one when it's unsupported.
-          imageSkippedCount: Math.max(
-            0,
-            parsedSlide.images.length - (imageUrl ? 1 : 0),
-          ),
+          sourceText: parsedSlide.texts.map((text) => text.content).join("\n"),
+          imageUrls: Object.values(uploadedImages.urls),
+          imageSkippedCount: uploadedImages.imageSkippedCount,
         };
       }),
     ),
@@ -129,6 +165,26 @@ export async function importPptxBufferToDeck(args: {
     (total, r) => total + r.imageSkippedCount,
     0,
   );
+  if (imagesSkipped > 0) {
+    throw new Error(
+      `Source-faithful PPTX import could not preserve ${imagesSkipped} image(s). No deck was written. Retry with browser-renderable images or use a PDF export for page-faithful preservation.`,
+    );
+  }
+  const sourceImport = buildSourceImportMetadata({
+    format: "pptx",
+    slides: results.map((result) => ({
+      id: result.slide.id,
+      text: result.sourceText,
+      notes: result.slide.notes ?? "",
+      imageUrls: result.imageUrls,
+      editableText: true,
+    })),
+    imagesSkipped,
+  });
+  const aspectRatio = nearestAspectRatio(
+    presentation.slides[0]?.widthEmu,
+    presentation.slides[0]?.heightEmu,
+  );
 
   const db = getDb();
   const now = new Date().toISOString();
@@ -143,10 +199,25 @@ export async function importPptxBufferToDeck(args: {
       throw new Error(`Deck ${deckId} not found`);
     }
 
-    const data = { title: deckTitle, slides, updatedAt: now };
+    const previousData = safeParseDeckData(existing[0].data);
+    const data = {
+      ...previousData,
+      title: deckTitle,
+      slides,
+      ...(aspectRatio ? { aspectRatio } : {}),
+      sourceImport,
+      updatedAt: now,
+    };
     await db
       .update(schema.decks)
-      .set({ title: deckTitle, data: JSON.stringify(data), updatedAt: now })
+      .set({
+        title: deckTitle,
+        data: JSON.stringify(data),
+        ...(designSystemId !== undefined
+          ? { designSystemId }
+          : { designSystemId: existing[0].designSystemId }),
+        updatedAt: now,
+      })
       .where(eq(schema.decks.id, deckId));
 
     notifyClients(deckId);
@@ -168,13 +239,21 @@ export async function importPptxBufferToDeck(args: {
 
   // Create new deck
   const id = `deck-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
-  const data = { title: deckTitle, slides, createdAt: now, updatedAt: now };
+  const data = {
+    title: deckTitle,
+    slides,
+    ...(aspectRatio ? { aspectRatio } : {}),
+    sourceImport,
+    createdAt: now,
+    updatedAt: now,
+  };
   await db.insert(schema.decks).values({
     id,
     title: deckTitle,
     data: JSON.stringify(data),
     ownerEmail,
     orgId: getRequestOrgId(),
+    designSystemId: designSystemId ?? undefined,
     createdAt: now,
     updatedAt: now,
   });
@@ -197,8 +276,8 @@ export default defineAction({
   description:
     "Import a PPTX file and create a slide deck from it. " +
     "Parses the PowerPoint file, extracts text and layout information, " +
-    "converts each slide to the app's HTML format, and creates or updates a deck. " +
-    "Returns the deck ID and slide count.",
+    "converts each slide to the app's positioned HTML format, records source-preservation metadata, and creates or updates a deck. " +
+    "If an embedded image cannot be preserved, the action fails before writing a partial deck. Returns the deck ID and slide count.",
   schema: z.object({
     filePath: z
       .string()
@@ -209,6 +288,11 @@ export default defineAction({
       .describe(
         "If provided, import slides into this existing deck (replaces all slides)",
       ),
+    designSystemId: z
+      .string()
+      .nullable()
+      .optional()
+      .describe("Optional design system to link when creating a new deck"),
     title: z
       .string()
       .optional()
@@ -216,8 +300,49 @@ export default defineAction({
         "Deck title — defaults to the title extracted from the presentation",
       ),
   }),
-  run: async ({ filePath, deckId, title }) => {
+  run: async ({ filePath, deckId, title, designSystemId }) => {
     const { data: fileBuffer } = await readUserUploadedFile(filePath);
-    return importPptxBufferToDeck({ fileBuffer, deckId, title });
+    return importPptxBufferToDeck({
+      fileBuffer,
+      deckId,
+      title,
+      designSystemId,
+    });
   },
 });
+
+function nearestAspectRatio(
+  width: number | undefined,
+  height: number | undefined,
+): AspectRatio | undefined {
+  if (!width || !height || width <= 0 || height <= 0) return undefined;
+  const target = width / height;
+  let best: AspectRatio = DEFAULT_ASPECT_RATIO;
+  let bestDiff = Infinity;
+  for (const key of Object.keys(ASPECT_RATIOS) as AspectRatio[]) {
+    const preset = ASPECT_RATIOS[key];
+    const diff = Math.abs(preset.width / preset.height - target);
+    if (diff < bestDiff) {
+      best = key;
+      bestDiff = diff;
+    }
+  }
+  return best;
+}
+
+function safeParseDeckData(raw: string): Record<string, unknown> {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(
+      "The target deck contains invalid JSON; refusing to overwrite it.",
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(
+      "The target deck data is invalid; refusing to overwrite it.",
+    );
+  }
+  return parsed as Record<string, unknown>;
+}