@agent-native/core-corpus 0.213.1 → 0.216.0

package/corpus/templates/slides-2/server/lib/media-search-providers.ts

@@ -0,0 +1,216 @@
+import { resolveSecret } from "@agent-native/core/server";
+
+const GOOGLE_IMAGE_SEARCH_URL = "https://www.googleapis.com/customsearch/v1";
+const LOGO_DEV_SEARCH_URL = "https://api.logo.dev/search";
+const PROVIDER_TIMEOUT_MS = 15_000;
+
+export interface ImageSearchResult {
+  url: string;
+  thumbnail: string;
+  title: string;
+  width?: number;
+  height?: number;
+}
+
+export interface LogoSearchResult {
+  name: string;
+  domain: string;
+  logoUrl: string;
+  source: "logo.dev" | "domain-guess";
+}
+
+export interface MediaSearchRuntime {
+  resolveSecret: (key: string) => Promise<string | null | undefined>;
+  fetch: typeof fetch;
+}
+
+const defaultRuntime: MediaSearchRuntime = {
+  resolveSecret,
+  fetch: (...args) => fetch(...args),
+};
+
+function fetchOptions(init: RequestInit = {}): RequestInit {
+  return {
+    ...init,
+    signal: init.signal ?? AbortSignal.timeout(PROVIDER_TIMEOUT_MS),
+  };
+}
+
+function normalizedDomain(value: string): string {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/^https?:\/\//, "")
+    .replace(/^www\./, "")
+    .split("/", 1)[0]!
+    .replace(/[^a-z0-9.-]/g, "");
+}
+
+function logoResult(
+  name: string,
+  domain: string,
+  source: LogoSearchResult["source"],
+): LogoSearchResult | null {
+  const normalized = normalizedDomain(domain);
+  if (!normalized || !normalized.includes(".")) return null;
+  return {
+    name: name.trim() || normalized.split(".")[0] || normalized,
+    domain: normalized,
+    logoUrl: `https://cdn.brandfetch.io/${normalized}/logo.png`,
+    source,
+  };
+}
+
+function guessedLogoDomains(query: string): LogoSearchResult[] {
+  const normalized = normalizedDomain(query);
+  if (normalized.includes(".")) {
+    const result = logoResult(
+      normalized.split(".")[0] ?? normalized,
+      normalized,
+      "domain-guess",
+    );
+    return result ? [result] : [];
+  }
+
+  const compact = query.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const dashed = query
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "");
+  if (!compact) return [];
+
+  const candidates = [
+    ...["com", "io", "co", "dev", "org", "net"].map(
+      (tld) => `${compact}.${tld}`,
+    ),
+    ...(dashed && dashed !== compact ? [`${dashed}.com`] : []),
+  ];
+  return candidates.flatMap((domain) => {
+    const result = logoResult(query, domain, "domain-guess");
+    return result ? [result] : [];
+  });
+}
+
+export async function searchProviderImages(
+  query: string,
+  count = 10,
+  runtime: MediaSearchRuntime = defaultRuntime,
+): Promise<ImageSearchResult[]> {
+  const normalizedQuery = query.trim();
+  if (!normalizedQuery) throw new Error("Image search requires a query.");
+
+  const [apiKey, searchEngineId] = await Promise.all([
+    runtime.resolveSecret("GOOGLE_API_KEY"),
+    runtime.resolveSecret("GOOGLE_SEARCH_CX"),
+  ]);
+  if (!apiKey || !searchEngineId) {
+    throw new Error(
+      "Google Search not configured. Save GOOGLE_API_KEY and GOOGLE_SEARCH_CX in settings.",
+    );
+  }
+
+  const params = new URLSearchParams({
+    key: apiKey,
+    cx: searchEngineId,
+    q: normalizedQuery,
+    searchType: "image",
+    num: String(Math.max(1, Math.min(Math.floor(count), 10))),
+    safe: "active",
+  });
+  const response = await runtime.fetch(
+    `${GOOGLE_IMAGE_SEARCH_URL}?${params}`,
+    fetchOptions(),
+  );
+  if (!response.ok) {
+    throw new Error(`Google image search failed (${response.status}).`);
+  }
+
+  const data = (await response.json()) as {
+    items?: Array<{
+      link?: unknown;
+      title?: unknown;
+      image?: {
+        width?: unknown;
+        height?: unknown;
+        thumbnailLink?: unknown;
+      };
+    }>;
+  };
+  return (data.items ?? []).flatMap((item) => {
+    if (typeof item.link !== "string" || !item.link) return [];
+    const thumbnail =
+      typeof item.image?.thumbnailLink === "string"
+        ? item.image.thumbnailLink
+        : item.link;
+    return [
+      {
+        url: item.link,
+        thumbnail,
+        title: typeof item.title === "string" ? item.title : "Untitled image",
+        ...(typeof item.image?.width === "number"
+          ? { width: item.image.width }
+          : {}),
+        ...(typeof item.image?.height === "number"
+          ? { height: item.image.height }
+          : {}),
+      },
+    ];
+  });
+}
+
+export async function searchProviderLogos(
+  query: string,
+  runtime: MediaSearchRuntime = defaultRuntime,
+): Promise<LogoSearchResult[]> {
+  const normalizedQuery = query.trim();
+  if (!normalizedQuery) throw new Error("Logo search requires a query.");
+
+  const secretKey = await runtime.resolveSecret("LOGO_DEV_SECRET_KEY");
+  if (secretKey?.startsWith("sk_")) {
+    try {
+      const url = new URL(LOGO_DEV_SEARCH_URL);
+      url.searchParams.set("q", normalizedQuery);
+      const response = await runtime.fetch(
+        url,
+        fetchOptions({
+          headers: { Authorization: `Bearer ${secretKey}` },
+        }),
+      );
+      if (response.ok) {
+        const data = (await response.json()) as Array<{
+          name?: unknown;
+          domain?: unknown;
+        }>;
+        const results = data.flatMap((item) => {
+          if (typeof item.domain !== "string") return [];
+          const result = logoResult(
+            typeof item.name === "string" ? item.name : normalizedQuery,
+            item.domain,
+            "logo.dev",
+          );
+          return result ? [result] : [];
+        });
+        if (results.length > 0) return results;
+      }
+    } catch {
+      // coercion-ok: Logo.dev is optional; domain guesses retain a distinct source label.
+    }
+  }
+
+  return guessedLogoDomains(normalizedQuery);
+}
+
+export async function getLogoProviderConfig(
+  runtime: MediaSearchRuntime = defaultRuntime,
+) {
+  const [brandfetchId, logoDevToken, logoDevSecret] = await Promise.all([
+    runtime.resolveSecret("BRANDFETCH_CLIENT_ID"),
+    runtime.resolveSecret("LOGO_DEV_TOKEN"),
+    runtime.resolveSecret("LOGO_DEV_SECRET_KEY"),
+  ]);
+  return {
+    brandfetchId: brandfetchId || null,
+    logoDevToken: logoDevToken?.startsWith("pk_") ? logoDevToken : null,
+    hasLogoDevSecret: logoDevSecret?.startsWith("sk_") === true,
+  };
+}

package/corpus/templates/slides-2/server/lib/native-creative-context.ts

@@ -0,0 +1,295 @@
+import { createHash } from "node:crypto";
+
+import { putPrivateBlob } from "@agent-native/core/private-blob";
+import { accessFilter, resolveAccess } from "@agent-native/core/sharing";
+import {
+  renderSafeNativeHtmlPreviews,
+  serializePrivateBlobHandle,
+  type NativeResourceCaptureAdapter,
+} from "@agent-native/creative-context/server";
+import { and, inArray } from "drizzle-orm";
+
+import {
+  getAspectRatioDims,
+  type AspectRatio,
+} from "../../shared/aspect-ratios.js";
+import { isSlides2DeckData } from "../../shared/deck-app-scope.js";
+import { slides2DeckScope } from "../../shared/deck-scope.js";
+import { getDb, schema } from "../db/index.js";
+import { createDeckVersionSnapshot } from "./deck-versions.js";
+
+function hash(value: string | Uint8Array) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+function text(value: string) {
+  return value
+    .replace(/<[^>]+>/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function previewText(value: string | undefined, limit = 280) {
+  return text(value ?? "").slice(0, limit);
+}
+
+function slidePreviewDocument(content: string, width: number, height: number) {
+  return `<!doctype html><html><head><style>
+    *,*::before,*::after{box-sizing:border-box}html,body{width:${width}px;height:${height}px;margin:0;overflow:hidden;background:#fff;/* guard:allow-raw-color — slide preview uses a fixed white canvas. */}.context-slide{position:relative;width:${width}px;height:${height}px;overflow:hidden}.context-slide>*{width:100%;height:100%}.fmd-slide{width:100%;height:100%}
+  </style></head><body><div class="context-slide">${content}</div></body></html>`;
+}
+
+async function captureSlidePreviewMedia(input: {
+  deckId: string;
+  ownerEmail: string;
+  slides: Array<{ id: string; content: string; title: string }>;
+  aspectRatio?: AspectRatio;
+}) {
+  const dimensions = getAspectRatioDims(input.aspectRatio);
+  const rendered = await renderSafeNativeHtmlPreviews(
+    input.slides.map((slide) => ({
+      id: slide.id,
+      html: slidePreviewDocument(
+        slide.content,
+        dimensions.width,
+        dimensions.height,
+      ),
+      width: dimensions.width,
+      height: dimensions.height,
+    })),
+  );
+  const media = new Map<
+    string,
+    {
+      kind: "image";
+      mimeType: "image/png";
+      accessMode: "private";
+      storageKey: string;
+      altText: string;
+      contentHash: string;
+      width: number;
+      height: number;
+      metadata: { role: "slide-preview"; slideId: string };
+    }
+  >();
+  await Promise.all(
+    rendered.map(async (preview) => {
+      const contentHash = hash(preview.data);
+      const handle = await putPrivateBlob({
+        data: preview.data,
+        filename: `${input.deckId}-${preview.id}.preview.png`,
+        mimeType: "image/png",
+        ownerEmail: input.ownerEmail,
+        key: `creative-context/slides-2/${input.deckId}/previews/${contentHash}.png`,
+        metadata: {
+          appId: "slides-2",
+          resourceType: "slide-preview",
+          resourceId: input.deckId,
+          contentHash,
+        },
+      })
+        // coercion-ok: slide previews are optional media; deck capture already stores the required source blob.
+        .catch(() => null);
+      if (!handle) return;
+      const slide = input.slides.find(
+        (candidate) => candidate.id === preview.id,
+      );
+      media.set(preview.id, {
+        kind: "image",
+        mimeType: "image/png",
+        accessMode: "private",
+        storageKey: serializePrivateBlobHandle(handle),
+        altText: slide?.title ?? "Slide preview",
+        contentHash,
+        width: preview.width,
+        height: preview.height,
+        metadata: { role: "slide-preview", slideId: preview.id },
+      });
+    }),
+  );
+  return media;
+}
+
+export const nativeDeckCreativeContextAdapter: NativeResourceCaptureAdapter = {
+  appId: "slides-2",
+  resourceType: "deck",
+  async listResourceVersions(resourceIds) {
+    if (!resourceIds.length) return [];
+    return getDb()
+      .select({
+        resourceId: schema.decks.id,
+        sourceModifiedAt: schema.decks.updatedAt,
+      })
+      .from(schema.decks)
+      .where(
+        and(
+          inArray(schema.decks.id, [...resourceIds]),
+          accessFilter(schema.decks, schema.deckShares),
+          slides2DeckScope,
+        ),
+      );
+  },
+  async capture(reference) {
+    const access = await resolveAccess("deck", reference.resourceId);
+    if (!access) throw new Error("Deck not found");
+    const deck = access.resource as {
+      id: string;
+      title: string;
+      data: string;
+      ownerEmail: string;
+      updatedAt: string;
+      visibility?: "private" | "org" | "public";
+    };
+    const parsed = JSON.parse(deck.data) as {
+      appId?: string;
+      aspectRatio?: string;
+      slides?: Array<{
+        id?: string;
+        content?: string;
+        notes?: string;
+        title?: string;
+      }>;
+    };
+    if (!isSlides2DeckData(parsed)) throw new Error("Deck not found");
+    if (
+      reference.expectedUpdatedAt &&
+      reference.expectedUpdatedAt !== deck.updatedAt
+    ) {
+      throw new Error("Deck changed before it could be submitted to Context.");
+    }
+    const version = await createDeckVersionSnapshot(deck, {
+      force: true,
+      label: "Creative Context submission",
+    });
+    const contentHash = hash(deck.data);
+    const handle = await putPrivateBlob({
+      data: Buffer.from(deck.data),
+      filename: `${deck.id}.deck.json`,
+      mimeType: "application/json",
+      ownerEmail: deck.ownerEmail,
+      key: `creative-context/slides-2/${deck.id}/${contentHash}.json`,
+      metadata: {
+        appId: "slides-2",
+        resourceType: "deck",
+        resourceId: deck.id,
+        contentHash,
+      },
+    });
+    if (!handle)
+      throw new Error(
+        "Private blob storage is required to submit a deck to Context.",
+      );
+    const slides = Array.isArray(parsed.slides) ? parsed.slides : [];
+    const slidePreviewMedia = await captureSlidePreviewMedia({
+      deckId: deck.id,
+      ownerEmail: deck.ownerEmail,
+      aspectRatio:
+        parsed.aspectRatio === "16:9" ||
+        parsed.aspectRatio === "1:1" ||
+        parsed.aspectRatio === "9:16" ||
+        parsed.aspectRatio === "4:5"
+          ? parsed.aspectRatio
+          : undefined,
+      slides: slides.slice(0, 12).map((slide, index) => ({
+        id: slide.id ?? String(index),
+        content: slide.content ?? "",
+        title: slide.title ?? `Slide ${index + 1}`,
+      })),
+    });
+    return {
+      artifactKey: `slides-2:deck:${deck.id}`,
+      source: {
+        name: "Slides 2",
+        kind: "native-app",
+        externalRef: deck.id,
+        access: {
+          visibility: deck.visibility ?? "private",
+          canManage: access.role === "owner" || access.role === "admin",
+        },
+      },
+      items: [
+        {
+          externalId: `native:slides-2:deck:${deck.id}`,
+          kind: "slides-deck",
+          title: deck.title || "Untitled deck",
+          canonicalUrl: `/deck/${deck.id}`,
+          mimeType: "application/json",
+          content: slides
+            .map(
+              (slide, index) =>
+                `Slide ${index + 1}: ${text(slide.content ?? "")} ${slide.notes ?? ""}`,
+            )
+            .join("\n")
+            .slice(0, 40_000),
+          summary: `${slides.length} slides captured as an immutable deck version.`,
+          contentHash,
+          sourceModifiedAt: deck.updatedAt,
+          sourceVersion: version.id ?? contentHash,
+          metadata: {
+            preview: {
+              type: "slides",
+              slideCount: slides.length,
+              slides: slides.slice(0, 24).map((slide, index) => ({
+                index: index + 1,
+                title: previewText(slide.title, 120) || `Slide ${index + 1}`,
+                excerpt: previewText(slide.content),
+              })),
+            },
+          },
+          media: [...slidePreviewMedia.values()],
+          edges: slides.map((slide, index) => ({
+            relation: "contains",
+            toExternalId: `native:slides-2:deck:${deck.id}:slide:${slide.id ?? index}`,
+          })),
+        },
+        ...slides.map((slide, index) => {
+          const content =
+            `${text(slide.content ?? "")} ${slide.notes ?? ""}`.trim();
+          const id = slide.id ?? String(index);
+          return {
+            externalId: `native:slides-2:deck:${deck.id}:slide:${id}`,
+            kind: "slide",
+            title: slide.title ?? `Slide ${index + 1}`,
+            canonicalUrl: `/deck/${deck.id}?slide=${encodeURIComponent(id)}`,
+            mimeType: "text/html",
+            content,
+            summary: content.slice(0, 500),
+            contentHash: hash(
+              `${deck.id}:${id}:${slide.content ?? ""}:${slide.notes ?? ""}`,
+            ),
+            sourceModifiedAt: deck.updatedAt,
+            sourceVersion: version.id ?? contentHash,
+            metadata: {
+              preview: {
+                type: "slide",
+                index: index + 1,
+                title: previewText(slide.title, 120) || `Slide ${index + 1}`,
+                excerpt: previewText(slide.content),
+              },
+            },
+            media: slidePreviewMedia.has(id)
+              ? [slidePreviewMedia.get(id)!]
+              : undefined,
+          };
+        }),
+      ],
+      privateMetadata: {
+        nativeResource: {
+          appId: "slides-2",
+          resourceType: "deck",
+          resourceId: deck.id,
+          expectedUpdatedAt: reference.expectedUpdatedAt,
+        },
+        clone: {
+          handle,
+          appId: "slides-2",
+          resourceType: "deck",
+          resourceId: deck.id,
+          contentHash,
+          sourceVersion: version.id ?? contentHash,
+          updatedAt: deck.updatedAt,
+        },
+      },
+    };
+  },
+};

package/corpus/templates/slides-2/server/lib/pdf-parse-setup.ts

@@ -0,0 +1,115 @@
+interface Minimal2DMatrix {
+  a: number;
+  b: number;
+  c: number;
+  d: number;
+  e: number;
+  f: number;
+  is2D: boolean;
+  isIdentity: boolean;
+  multiply(other: Minimal2DMatrix): Minimal2DMatrix;
+  translate(tx?: number, ty?: number): Minimal2DMatrix;
+  scale(sx?: number, sy?: number): Minimal2DMatrix;
+  inverse(): Minimal2DMatrix;
+  toString(): string;
+}
+
+function installDomMatrixPolyfillIfMissing(): void {
+  if (
+    typeof (globalThis as { DOMMatrix?: unknown }).DOMMatrix !== "undefined"
+  ) {
+    return;
+  }
+
+  class PolyfillDOMMatrix implements Minimal2DMatrix {
+    a = 1;
+    b = 0;
+    c = 0;
+    d = 1;
+    e = 0;
+    f = 0;
+
+    constructor(init?: number[] | string) {
+      if (Array.isArray(init) && init.length >= 6) {
+        [this.a, this.b, this.c, this.d, this.e, this.f] = init;
+      }
+    }
+
+    get is2D(): boolean {
+      return true;
+    }
+
+    get isIdentity(): boolean {
+      return (
+        this.a === 1 &&
+        this.b === 0 &&
+        this.c === 0 &&
+        this.d === 1 &&
+        this.e === 0 &&
+        this.f === 0
+      );
+    }
+
+    multiply(other: Minimal2DMatrix): PolyfillDOMMatrix {
+      return new PolyfillDOMMatrix([
+        this.a * other.a + this.c * other.b,
+        this.b * other.a + this.d * other.b,
+        this.a * other.c + this.c * other.d,
+        this.b * other.c + this.d * other.d,
+        this.a * other.e + this.c * other.f + this.e,
+        this.b * other.e + this.d * other.f + this.f,
+      ]);
+    }
+
+    translate(tx = 0, ty = 0): PolyfillDOMMatrix {
+      return this.multiply(new PolyfillDOMMatrix([1, 0, 0, 1, tx, ty]));
+    }
+
+    scale(sx = 1, sy = sx): PolyfillDOMMatrix {
+      return this.multiply(new PolyfillDOMMatrix([sx, 0, 0, sy, 0, 0]));
+    }
+
+    inverse(): PolyfillDOMMatrix {
+      const det = this.a * this.d - this.b * this.c;
+      if (det === 0) return new PolyfillDOMMatrix();
+      const invDet = 1 / det;
+      return new PolyfillDOMMatrix([
+        this.d * invDet,
+        -this.b * invDet,
+        -this.c * invDet,
+        this.a * invDet,
+        (this.c * this.f - this.d * this.e) * invDet,
+        (this.b * this.e - this.a * this.f) * invDet,
+      ]);
+    }
+
+    toString(): string {
+      return `matrix(${this.a}, ${this.b}, ${this.c}, ${this.d}, ${this.e}, ${this.f})`;
+    }
+  }
+
+  (globalThis as { DOMMatrix?: unknown }).DOMMatrix = PolyfillDOMMatrix;
+}
+
+export interface PdfParseSetup {
+  PDFParse: typeof import("pdf-parse").PDFParse;
+  canvasFactory: object | undefined;
+}
+
+export async function setupPdfParse(): Promise<PdfParseSetup> {
+  installDomMatrixPolyfillIfMissing();
+
+  const { PDFParse } = await import("pdf-parse");
+  let canvasFactory: object | undefined;
+  try {
+    const { CanvasFactory, getData } = await import("pdf-parse/worker");
+    PDFParse.setWorker(getData());
+    canvasFactory = CanvasFactory;
+  } catch (err) {
+    console.warn(
+      "[import-file] pdf-parse canvas worker setup failed, continuing without it (text-only extraction is unaffected):",
+      err instanceof Error ? err.message : String(err),
+    );
+  }
+  return { PDFParse, canvasFactory };
+}

package/corpus/templates/slides-2/server/lib/provider-api.ts

@@ -0,0 +1,57 @@
+import {
+  createProviderApiRuntime,
+  listProviderApiIdsForTemplateUse,
+  type ProviderApiDocsOptions,
+  type ProviderApiId,
+  type ProviderApiMethod,
+  type ProviderApiRequestArgs,
+} from "@agent-native/core/provider-api";
+import { getCredentialContext } from "@agent-native/core/server";
+
+import { GOOGLE_DOCS_PROVIDER } from "./google-docs-oauth.js";
+
+export const SLIDES_APP_ID = "slides-2";
+// The core provider catalog still names this capability family "slides".
+export const SLIDES_PROVIDER_API_IDS = listProviderApiIdsForTemplateUse(
+  "slides",
+) as [ProviderApiId, ...ProviderApiId[]];
+export type SlidesProviderApiId = (typeof SLIDES_PROVIDER_API_IDS)[number];
+export type { ProviderApiMethod, ProviderApiRequestArgs };
+
+const runtimeOptions = {
+  appId: SLIDES_APP_ID,
+  providerIds: SLIDES_PROVIDER_API_IDS,
+  localCredentialSource: `${SLIDES_APP_ID}_local`,
+  getCredentialContext: () => {
+    const ctx = getCredentialContext();
+    if (!ctx) {
+      throw new Error(
+        "Slides provider API requests require an authenticated request context.",
+      );
+    }
+    return ctx;
+  },
+  oauthProviderOverrides: {
+    google_drive: GOOGLE_DOCS_PROVIDER,
+  },
+};
+
+const runtime = createProviderApiRuntime(runtimeOptions);
+
+export function getSlidesProviderApiRuntime() {
+  return runtime;
+}
+
+export function listProviderApiCatalog(provider?: SlidesProviderApiId) {
+  return runtime.listCatalog(provider);
+}
+
+export function fetchProviderApiDocs(
+  options: ProviderApiDocsOptions & { provider: SlidesProviderApiId },
+) {
+  return runtime.fetchDocs(options);
+}
+
+export function executeProviderApiRequest(args: ProviderApiRequestArgs) {
+  return runtime.executeRequest(args);
+}