@avocadostudio-ai/orchestrator-core 0.1.0

package/dist/image/gdrive-client.js

@@ -0,0 +1,215 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+// ---------------------------------------------------------------------------
+// Auth
+// ---------------------------------------------------------------------------
+async function createDriveClient() {
+    const serviceAccountJson = process.env.GOOGLE_SERVICE_ACCOUNT_KEY_JSON?.trim();
+    const apiKey = process.env.GOOGLE_API_KEY?.trim();
+    if (!serviceAccountJson && !apiKey)
+        return null;
+    const { google } = await import("googleapis");
+    if (serviceAccountJson) {
+        try {
+            const key = JSON.parse(serviceAccountJson);
+            const auth = new google.auth.JWT({
+                email: key.client_email,
+                key: key.private_key,
+                scopes: ["https://www.googleapis.com/auth/drive.readonly"]
+            });
+            return google.drive({ version: "v3", auth });
+        }
+        catch {
+            return null;
+        }
+    }
+    return google.drive({ version: "v3", auth: apiKey });
+}
+let cachedClient;
+async function getDriveClient() {
+    if (cachedClient !== undefined)
+        return cachedClient;
+    cachedClient = await createDriveClient();
+    return cachedClient;
+}
+/** Reset cached client (useful after env changes or in tests). */
+export function resetDriveClient() {
+    cachedClient = undefined;
+}
+// ---------------------------------------------------------------------------
+// In-memory listing cache (5-min TTL, max 100 entries)
+// ---------------------------------------------------------------------------
+const CACHE_TTL_MS = 5 * 60 * 1000;
+const CACHE_MAX_ENTRIES = 100;
+const listCache = new Map();
+function evictStaleCache() {
+    if (listCache.size <= CACHE_MAX_ENTRIES)
+        return;
+    const now = Date.now();
+    for (const [key, entry] of listCache) {
+        if (now - entry.ts > CACHE_TTL_MS)
+            listCache.delete(key);
+    }
+    // If still over limit after TTL eviction, drop oldest entries
+    if (listCache.size > CACHE_MAX_ENTRIES) {
+        const entries = Array.from(listCache.entries()).sort((a, b) => a[1].ts - b[1].ts);
+        const toRemove = entries.slice(0, entries.length - CACHE_MAX_ENTRIES);
+        for (const [key] of toRemove)
+            listCache.delete(key);
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Convert a file name like "hero_image-v2.jpg" to alt text "hero image v2". */
+export function fileNameToAlt(name) {
+    return name.replace(/\.[^.]+$/, "").replace(/[_-]+/g, " ");
+}
+export function isGdriveConfigured() {
+    return Boolean(process.env.GOOGLE_DRIVE_FOLDER_ID?.trim() &&
+        (process.env.GOOGLE_SERVICE_ACCOUNT_KEY_JSON?.trim() || process.env.GOOGLE_API_KEY?.trim()));
+}
+/** Extract a bare folder ID from a value that may be a full Google Drive URL or a raw ID. */
+function extractFolderId(value) {
+    // https://drive.google.com/drive/u/0/folders/FOLDER_ID or /drive/folders/FOLDER_ID
+    const urlMatch = value.match(/\/folders\/([a-zA-Z0-9_-]+)/);
+    if (urlMatch?.[1])
+        return urlMatch[1];
+    return value;
+}
+/** Resolve folder ID from an override or fall back to env var. Returns undefined if neither is set. */
+export function resolveGdriveFolderId(override) {
+    const trimmed = override?.trim();
+    if (trimmed)
+        return extractFolderId(trimmed);
+    const envId = process.env.GOOGLE_DRIVE_FOLDER_ID?.trim();
+    if (envId)
+        return extractFolderId(envId);
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// List images
+// ---------------------------------------------------------------------------
+const MAX_SUBFOLDER_DEPTH = 3;
+async function listImagesInFolder(drive, folderId, query, log, depth) {
+    const items = [];
+    const subfolderIds = [];
+    // Query both images and subfolders in this folder
+    const qParts = [
+        `'${folderId}' in parents`,
+        `(mimeType contains 'image/' or mimeType = 'application/vnd.google-apps.folder')`,
+        "trashed = false"
+    ];
+    if (query) {
+        // Name filter only applies to images; subfolders are always traversed
+        // We'll filter by name client-side for images while still discovering folders
+    }
+    const pageSize = 100;
+    let pageToken;
+    do {
+        const res = await drive.files.list({
+            q: qParts.join(" and "),
+            fields: "nextPageToken, files(id, name, mimeType, thumbnailLink, size, imageMediaMetadata)",
+            pageSize,
+            pageToken,
+            orderBy: "name"
+        });
+        for (const file of res.data.files ?? []) {
+            if (!file.id || !file.name)
+                continue;
+            if (file.mimeType === "application/vnd.google-apps.folder") {
+                if (depth < MAX_SUBFOLDER_DEPTH)
+                    subfolderIds.push(file.id);
+                continue;
+            }
+            // Apply name filter client-side (so subfolders are still traversed)
+            if (query && !file.name.toLowerCase().includes(query.toLowerCase()))
+                continue;
+            items.push({
+                id: file.id,
+                name: file.name,
+                mimeType: file.mimeType ?? "image/jpeg",
+                thumbnailLink: file.thumbnailLink ?? "",
+                size: Number(file.size ?? 0),
+                width: file.imageMediaMetadata?.width ?? undefined,
+                height: file.imageMediaMetadata?.height ?? undefined
+            });
+        }
+        pageToken = res.data.nextPageToken ?? undefined;
+    } while (pageToken);
+    // Recursively list images in subfolders (in parallel)
+    if (subfolderIds.length > 0) {
+        const subResults = await Promise.all(subfolderIds.map((subId) => listImagesInFolder(drive, subId, query, log, depth + 1)));
+        for (const subItems of subResults)
+            items.push(...subItems);
+    }
+    return items;
+}
+export async function listImages(folderId, query, log, maxResults, skipCache) {
+    const drive = await getDriveClient();
+    if (!drive) {
+        log?.warn({ event: "gdrive_no_client" }, "Google Drive client not configured");
+        return [];
+    }
+    const cacheKey = `${folderId}::${query ?? ""}`;
+    if (!skipCache) {
+        const cached = listCache.get(cacheKey);
+        if (cached && Date.now() - cached.ts < CACHE_TTL_MS) {
+            return maxResults ? cached.items.slice(0, maxResults) : cached.items;
+        }
+    }
+    try {
+        const items = await listImagesInFolder(drive, folderId, query, log, 0);
+        listCache.set(cacheKey, { items, ts: Date.now() });
+        evictStaleCache();
+        log?.info({ event: "gdrive_list", folderId, query, count: items.length }, "Listed Google Drive images");
+        return maxResults ? items.slice(0, maxResults) : items;
+    }
+    catch (err) {
+        log?.warn({ event: "gdrive_list_error", folderId, error: err instanceof Error ? err.message : String(err) }, "Failed to list Google Drive images");
+        return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// Download + optimize
+// ---------------------------------------------------------------------------
+const MAX_WIDTH = 1536;
+const MAX_HEIGHT = 1024;
+const WEBP_QUALITY = 80;
+export async function downloadImage(fileId, log) {
+    const generatedImageDir = process.env.ORCHESTRATOR_GENERATED_IMAGE_DIR ?? resolve(process.cwd(), "../../.data/generated-images");
+    const fileName = `gdrive_${fileId}.webp`;
+    const filePath = resolve(generatedImageDir, fileName);
+    // Try disk cache first — no need for existsSync, just attempt the read
+    try {
+        await readFile(filePath);
+        return { filePath, fileName };
+    }
+    catch {
+        // Not cached, proceed to download
+    }
+    const drive = await getDriveClient();
+    if (!drive)
+        return null;
+    try {
+        const res = await drive.files.get({ fileId, alt: "media" }, { responseType: "arraybuffer" });
+        const rawBytes = Buffer.from(res.data);
+        if (rawBytes.byteLength === 0)
+            return null;
+        const { default: sharp } = await import("sharp");
+        // Optimize: auto-orient first (before resize for correct dimensions), then resize + WebP
+        const optimized = await sharp(rawBytes)
+            .rotate() // auto-orient based on EXIF before resize
+            .resize({ width: MAX_WIDTH, height: MAX_HEIGHT, fit: "inside", withoutEnlargement: true })
+            .webp({ quality: WEBP_QUALITY })
+            .toBuffer();
+        await mkdir(generatedImageDir, { recursive: true });
+        await writeFile(filePath, optimized);
+        log?.info({ event: "gdrive_download", fileId, originalSize: rawBytes.byteLength, optimizedSize: optimized.byteLength }, `Downloaded and optimized Drive image ${fileId}`);
+        return { filePath, fileName };
+    }
+    catch (err) {
+        log?.warn({ event: "gdrive_download_error", fileId, error: err instanceof Error ? err.message : String(err) }, "Failed to download Google Drive image");
+        return null;
+    }
+}

package/dist/image/image-helpers.d.ts

@@ -0,0 +1,95 @@
+import type { PageDoc } from "@avocadostudio-ai/shared";
+import { type UnsplashImage, type UnsplashResolveOptions } from "../variation-images.ts";
+export type ImageLogger = {
+    info: (obj: Record<string, unknown>, msg: string) => void;
+    warn: (obj: Record<string, unknown>, msg: string) => void;
+};
+export declare function recordImageGenDuration(ms: number): void;
+export declare function estimatedImageGenMs(): number;
+export declare function normalizeUnsplashQuery(raw: string): string;
+export declare function extractUnsplashQuery(message: string): string | undefined;
+/**
+ * Detect explicit image generation intent in a message (e.g. "generate a new image", "new photo").
+ * Returns true for phrases that clearly request creating/replacing an image, but NOT for
+ * property edits like "change the image alt text".
+ */
+export declare function isExplicitImageGenRequest(message: string): boolean;
+/**
+ * Extract a detailed image description/prompt from a user message.
+ * Matches patterns like "generate a new image: [full description]".
+ * Returns the description (typically a rich prompt for AI image generation) or undefined.
+ */
+export declare function extractImagePromptFromMessage(message: string): string | undefined;
+export declare function imageKeywordsFromQuery(raw: string, max?: number): string[];
+export declare function heroImageQueryFromContext(args: {
+    message: string;
+    currentPage: PageDoc;
+    targetBlock: PageDoc["blocks"][number];
+    patchCandidate?: Record<string, unknown>;
+}): string;
+export type VariationImageIntent = {
+    baseQuery: string;
+    subjectKeywords: string[];
+    varyBackgrounds: boolean;
+    styleTerms: string[];
+    provider: "unsplash" | "llm";
+    backgroundTerms: string[];
+};
+export declare function deriveVariationImageIntent(args: {
+    message: string;
+    block: PageDoc["blocks"][number];
+}): VariationImageIntent;
+export declare function buildVariationImageQuery(intent: VariationImageIntent, variationIndex: number): string;
+export declare function buildVariationImagePrompt(args: {
+    intent: VariationImageIntent;
+    blockType: string;
+    variationIndex: number;
+    sectionContext?: string;
+    pageContext?: string;
+}): string;
+export declare function generateVariationImageWithOpenAI(args: {
+    prompt: string;
+    altText: string;
+    size?: string;
+    model?: string;
+    background?: "transparent" | "opaque" | "auto";
+    outputFormat?: "png" | "webp" | "jpeg";
+    log?: ImageLogger;
+    signal?: AbortSignal;
+}): Promise<UnsplashImage | null>;
+export declare function saveGeneratedImage(bytes: Buffer, prefix?: string, ext?: string): Promise<{
+    fileName: string;
+    url: string;
+}>;
+/** Extract the first inline image from a Gemini response, save to disk, return URL. */
+export declare function saveGeminiInlineImage(parts: Array<{
+    inlineData?: {
+        data?: string;
+        mimeType?: string;
+    };
+}>, prefix?: string): Promise<{
+    url: string;
+    mimeType: string;
+} | null>;
+export declare const GEMINI_ASPECT_RATIOS: Record<string, string>;
+export declare function getGeminiClient(): Promise<any>;
+export declare function getGeminiImageModel(): string;
+export declare function generateVariationImageWithGemini(args: {
+    prompt: string;
+    altText: string;
+    aspectRatio?: string;
+    quality?: "draft" | "final";
+    background?: "transparent" | "opaque" | "auto";
+    model?: string;
+    log?: ImageLogger;
+    signal?: AbortSignal;
+}): Promise<UnsplashImage | null>;
+export declare function resolveUnsplashImage(query: string, options?: UnsplashResolveOptions, logContext?: {
+    chatRequestId?: string;
+    logger?: ImageLogger;
+}): Promise<UnsplashImage | null>;
+export declare function resolveGdriveImage(query: string, options?: {
+    chatRequestId?: string;
+    logger?: ImageLogger;
+    folderId?: string;
+}): Promise<UnsplashImage | null>;