ima2-gen 2.0.0 → 2.0.1

package/lib/historyList.js

@@ -2,6 +2,8 @@ import { mkdir, readFile, readdir, stat } from "fs/promises";
 import { dirname, join } from "path";
 import { config } from "../config.js";
 import { readEmbeddedImageMetadataFromFile } from "./imageMetadataStore.js";
+import { thumbPathForVideo, thumbUrlForVideo } from "./videoThumb.js";
+import { thumbPathForImage, thumbUrlForImage } from "./imageThumb.js";
 import { errInfo } from "./errInfo.js";
 async function listImageFiles(baseDir) {
     const out = [];
@@ -14,7 +16,7 @@ async function listImageFiles(baseDir) {
             if (entry.isDirectory() && depth > 0) {
                 await walk(full, depth - 1);
             }
-            else if (entry.isFile() && /\.(png|jpe?g|webp|mp4)$/i.test(entry.name)) {
+            else if (entry.isFile() && /\.(png|jpe?g|webp|mp4)$/i.test(entry.name) && !entry.name.endsWith(".thumb.jpg")) {
                 out.push({ full, rel: full.slice(baseDir.length + 1), name: entry.name });
             }
         }
@@ -29,10 +31,24 @@ export async function listHistoryRows(baseDir = config.storage.generatedDir) {
     const rows = await Promise.all(imgs.map(async ({ full, rel, name }) => {
         const st = await stat(full).catch(() => null);
         const meta = await readImageMetadata(full, rel);
+        const isVideo = /\.mp4$/i.test(name);
+        const encodedUrl = `/generated/${rel.split("/").map(encodeURIComponent).join("/")}`;
+        let thumb = null;
+        if (isVideo) {
+            const thumbExists = await stat(thumbPathForVideo(full)).then(() => true, () => false);
+            if (thumbExists)
+                thumb = thumbUrlForVideo(encodedUrl);
+        }
+        else {
+            const imgThumbExists = await stat(thumbPathForImage(full)).then(() => true, () => false);
+            if (imgThumbExists)
+                thumb = thumbUrlForImage(encodedUrl);
+        }
         return {
             filename: rel,
             url: `/generated/${rel.split("/").map(encodeURIComponent).join("/")}`,
-            mediaType: meta?.mediaType || (/\.mp4$/i.test(name) ? "video" : "image"),
+            thumb,
+            mediaType: meta?.mediaType || (isVideo ? "video" : "image"),
             video: meta?.video || null,
             videoSeries: meta?.videoSeries || null,
             videoContinuity: meta?.videoContinuity || null,

package/lib/imageModels.js

@@ -5,6 +5,8 @@ const FALLBACK_REASONING_EFFORT = "none";
 const VALID_REASONING_EFFORTS = new Set(["none", "low", "medium", "high", "xhigh"]);
 const GROK_FALLBACK_IMAGE_MODEL = "grok-imagine-image";
 const VALID_GROK_IMAGE_MODELS = new Set(["grok-imagine-image", "grok-imagine-image-quality"]);
+const GEMINI_API_FALLBACK_IMAGE_MODEL = "nano-banana-2";
+const VALID_GEMINI_API_MODELS = new Set(["nano-banana-2", "nano-banana-pro"]);
 export function normalizeReasoningEffort(ctx, rawEffort) {
     const configured = ctx?.config?.imageModels;
     const fallback = configured?.reasoningEffort ?? FALLBACK_REASONING_EFFORT;
@@ -58,6 +60,19 @@ export function normalizeGrokImageModel(rawModel) {
     }
     return { model: rawModel };
 }
+export function normalizeGeminiApiModel(rawModel) {
+    if (typeof rawModel !== "string" || rawModel.length === 0) {
+        return { model: GEMINI_API_FALLBACK_IMAGE_MODEL };
+    }
+    if (!VALID_GEMINI_API_MODELS.has(rawModel)) {
+        return {
+            error: `Gemini API image model must be one of: ${[...VALID_GEMINI_API_MODELS].join(", ")}`,
+            code: "INVALID_GEMINI_API_IMAGE_MODEL",
+            status: 400,
+        };
+    }
+    return { model: rawModel };
+}
 // ── Grok video (T2V/I2V) ─────────────────────────────────────────────────
 // Video is a separate generation kind, not an image model. Keep it out of the
 // image model unions/helpers above so `grok-` image classification is unaffected.

package/lib/imageThumb.js

@@ -0,0 +1,38 @@
+import sharp from "sharp";
+import { stat, writeFile } from "node:fs/promises";
+const THUMB_WIDTH = 320;
+const THUMB_QUALITY = 70;
+// Guard against decompression-bomb memory exhaustion (default sharp limit is 268M px).
+const MAX_INPUT_PIXELS = 100_000_000; // 100MP (e.g. ~10000x10000)
+export function thumbPathForImage(imagePath) {
+    return imagePath.replace(/\.(png|jpe?g|webp)$/i, ".thumb.jpg");
+}
+export function thumbUrlForImage(imageUrl) {
+    return imageUrl.replace(/\.(png|jpe?g|webp)$/i, ".thumb.jpg");
+}
+export async function generateImageThumbnail(imagePath) {
+    const thumbPath = thumbPathForImage(imagePath);
+    const buf = await sharp(imagePath, { limitInputPixels: MAX_INPUT_PIXELS })
+        .resize({ width: THUMB_WIDTH, withoutEnlargement: true })
+        .jpeg({ quality: THUMB_QUALITY })
+        .toBuffer();
+    await writeFile(thumbPath, buf);
+    return thumbPath;
+}
+export async function generateImageThumbnailFromBuffer(buffer, outputPath) {
+    const thumbPath = thumbPathForImage(outputPath);
+    const buf = await sharp(buffer, { limitInputPixels: MAX_INPUT_PIXELS })
+        .resize({ width: THUMB_WIDTH, withoutEnlargement: true })
+        .jpeg({ quality: THUMB_QUALITY })
+        .toBuffer();
+    await writeFile(thumbPath, buf);
+}
+export async function imageThumbExists(imageFullPath) {
+    try {
+        await stat(thumbPathForImage(imageFullPath));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/lib/providerOptions.js

@@ -1,5 +1,26 @@
-import { normalizeImageModel, normalizeReasoningEffort, normalizeGrokImageModel } from "./imageModels.js";
+import { normalizeImageModel, normalizeReasoningEffort, normalizeGrokImageModel, normalizeGeminiApiModel } from "./imageModels.js";
 export function resolveProviderOptions(ctx, { provider = "oauth", rawModel, rawReasoningEffort, rawSize = "1024x1024", rawWebSearchEnabled = true, searchMode = "on", } = {}) {
+    if (provider === "agy") {
+        return {
+            provider: "agy",
+            model: "nano-banana-2",
+            reasoningEffort: "none",
+            size: "1024x1024",
+            webSearchEnabled: false,
+        };
+    }
+    if (provider === "gemini-api") {
+        const geminiModelCheck = normalizeGeminiApiModel(rawModel || "nano-banana-2");
+        if (geminiModelCheck.error)
+            return { error: geminiModelCheck.error, code: geminiModelCheck.code, status: geminiModelCheck.status };
+        return {
+            provider: "gemini-api",
+            model: geminiModelCheck.model,
+            reasoningEffort: "none",
+            size: rawSize || "1024x1024",
+            webSearchEnabled: false,
+        };
+    }
     if (provider === "grok") {
         const grokCfg = ctx?.config?.grokProvider || {};
         const modelInput = rawModel || grokCfg.defaultImageModel;
@@ -14,6 +35,20 @@ export function resolveProviderOptions(ctx, { provider = "oauth", rawModel, rawR
             webSearchEnabled: true,
         };
     }
+    if (provider === "grok-api") {
+        const grokCfg = ctx?.config?.grokProvider || {};
+        const modelInput = rawModel || grokCfg.defaultImageModel;
+        const grokModelCheck = normalizeGrokImageModel(modelInput);
+        if (grokModelCheck.error)
+            return { error: grokModelCheck.error, code: grokModelCheck.code, status: grokModelCheck.status };
+        return {
+            provider: "grok-api",
+            model: grokModelCheck.model,
+            reasoningEffort: "none",
+            size: rawSize,
+            webSearchEnabled: true,
+        };
+    }
     const activeProvider = provider === "api" ? "api" : "oauth";
     const apiConfig = ctx?.config?.apiProvider || {};
     const modelInput = activeProvider === "api"

package/lib/responsesFallback.js

@@ -1,57 +1,65 @@
 import { logEvent } from "./logger.js";
 import { imageToolChoice, tools } from "./responsesTools.js";
 import { emptyResponseError } from "./responsesErrors.js";
-import { buildUserTextPrompt } from "./oauthProxy.js";
+import { GENERATE_DEVELOPER_PROMPT, GENERATE_NO_SEARCH_DEVELOPER_PROMPT, buildUserTextPrompt, } from "./oauthProxy.js";
+const MAX_RETRIES = 2;
 export async function retryPromptOnlyJsonImage({ postResponses, ctx, provider, prompt, mode, model, quality, size, moderation, requestId, signal, initial, referencesDroppedOnRetry, webSearchDroppedOnRetry, reasoningEffort, }) {
     if (provider === "api")
         return null;
-    const retryKind = "prompt_only_json_image_tool";
+    const retryKind = "prompt_only_with_developer";
     const retryMeta = {
         retryKind,
         initialEventCount: initial.eventCount,
         initialEventTypes: initial.eventTypes,
         referencesDroppedOnRetry,
-        developerPromptDroppedOnRetry: true,
+        developerPromptDroppedOnRetry: false,
         webSearchDroppedOnRetry,
     };
-    logEvent("oauth", "retry_json", { requestId, ...retryMeta });
-    let retry;
-    try {
-        retry = await postResponses({
-            ctx,
-            provider,
-            scope: "oauth-fallback",
-            requestId,
-            maxImages: 1,
-            signal,
-            payload: {
-                model,
-                input: [{ role: "user", content: buildUserTextPrompt(prompt, mode, { webSearchEnabled: false }) }],
-                tools: tools(false, { quality, size, moderation }),
-                tool_choice: imageToolChoice(true),
-                reasoning: { effort: reasoningEffort || "low" },
-                stream: false,
-            },
-        });
+    const developerPrompt = webSearchDroppedOnRetry
+        ? GENERATE_NO_SEARCH_DEVELOPER_PROMPT
+        : GENERATE_DEVELOPER_PROMPT;
+    let lastRetry = null;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+        logEvent("oauth", "retry_attempt", { requestId, attempt, maxRetries: MAX_RETRIES, ...retryMeta });
+        try {
+            lastRetry = await postResponses({
+                ctx,
+                provider,
+                scope: "oauth-fallback",
+                requestId,
+                maxImages: 1,
+                signal,
+                payload: {
+                    model,
+                    input: [
+                        { role: "developer", content: developerPrompt },
+                        { role: "user", content: buildUserTextPrompt(prompt, mode, { webSearchEnabled: false }) },
+                    ],
+                    tools: tools(false, { quality, size, moderation }),
+                    tool_choice: imageToolChoice(true),
+                    reasoning: { effort: reasoningEffort || "low" },
+                    stream: false,
+                },
+            });
+        }
+        catch (e) {
+            if (attempt === MAX_RETRIES) {
+                if (e && typeof e === "object")
+                    Object.assign(e, retryMeta);
+                throw e;
+            }
+            logEvent("oauth", "retry_error", { requestId, attempt, error: e.message, status: e.status, code: e.code });
+            continue;
+        }
+        const image = lastRetry.images[0];
+        if (image?.b64) {
+            logEvent("oauth", "retry_image", { requestId, retryKind, attempt, imageChars: image.b64.length });
+            return { b64: image.b64, usage: lastRetry.usage, webSearchCalls: initial.webSearchCalls, revisedPrompt: image.revisedPrompt, text: lastRetry.text, ...retryMeta };
+        }
+        logEvent("oauth", "retry_no_image", { requestId, retryKind, attempt, fallbackEventCount: lastRetry.eventCount });
     }
-    catch (e) {
-        if (e && typeof e === "object")
-            Object.assign(e, retryMeta);
-        throw e;
-    }
-    const image = retry.images[0];
-    if (image?.b64) {
-        logEvent("oauth", "retry_image", { requestId, retryKind, imageChars: image.b64.length });
-        return { b64: image.b64, usage: retry.usage, webSearchCalls: initial.webSearchCalls, revisedPrompt: image.revisedPrompt, text: retry.text, ...retryMeta };
-    }
-    logEvent("oauth", "retry_no_image", {
-        requestId,
-        retryKind,
-        fallbackEventCount: retry.eventCount,
-        fallbackImageCallSeen: retry.diagnostics.imageCallSeen,
-        fallbackImageResultCount: retry.diagnostics.imageResultCount,
-    });
-    throw emptyResponseError("No image data received from Responses API fallback", retry, {
+    const diagSource = lastRetry ?? initial;
+    throw emptyResponseError("No image data received after retries", diagSource, {
         provider,
         model,
         quality,
@@ -64,9 +72,9 @@ export async function retryPromptOnlyJsonImage({ postResponses, ctx, provider, p
         toolTypes: ["image_generation"],
         toolChoiceKind: "image_generation",
         ...retryMeta,
-        fallbackEventCount: retry.eventCount,
-        fallbackEventTypes: retry.eventTypes,
-        fallbackImageCallSeen: retry.diagnostics.imageCallSeen,
-        fallbackImageResultCount: retry.diagnostics.imageResultCount,
+        fallbackEventCount: diagSource.eventCount,
+        fallbackEventTypes: diagSource.eventTypes,
+        fallbackImageCallSeen: diagSource.diagnostics.imageCallSeen,
+        fallbackImageResultCount: diagSource.diagnostics.imageResultCount,
     });
 }

package/lib/runtimeContext.js

@@ -57,6 +57,24 @@ export function requireRuntimeContext(ctx) {
     }
     if (target.startedAt === undefined)
         target.startedAt = Date.now();
+    if (target.xaiApiKey === undefined && !Object.prototype.hasOwnProperty.call(target, 'xaiApiKey'))
+        target.xaiApiKey = undefined;
+    if (target.hasXaiApiKey === undefined)
+        target.hasXaiApiKey = false;
+    if (target.xaiApiKeySource === undefined)
+        target.xaiApiKeySource = undefined;
+    if (target.geminiApiKey === undefined && !Object.prototype.hasOwnProperty.call(target, 'geminiApiKey'))
+        target.geminiApiKey = undefined;
+    if (target.hasGeminiApiKey === undefined)
+        target.hasGeminiApiKey = false;
+    if (target.geminiApiKeySource === undefined)
+        target.geminiApiKeySource = undefined;
+    if (target.vertexServiceAccountJson === undefined && !Object.prototype.hasOwnProperty.call(target, 'vertexServiceAccountJson'))
+        target.vertexServiceAccountJson = undefined;
+    if (target.vertexProjectId === undefined)
+        target.vertexProjectId = undefined;
+    if (target.hasVertexKey === undefined)
+        target.hasVertexKey = false;
     return target;
 }
 /** Per-top-level-key merge: caller's nested config keys win, missing nests
@@ -107,6 +125,15 @@ export function createTestRuntimeContext(over = {}) {
         serverConfiguredPort: 11783,
         serverUrl: "http://127.0.0.1:11783",
         startedAt: now,
+        xaiApiKey: undefined,
+        xaiApiKeySource: undefined,
+        hasXaiApiKey: false,
+        geminiApiKey: undefined,
+        geminiApiKeySource: undefined,
+        hasGeminiApiKey: false,
+        vertexServiceAccountJson: undefined,
+        vertexProjectId: undefined,
+        hasVertexKey: false,
     };
     return { ...base, ...over };
 }

package/lib/storageMigration.js

@@ -286,7 +286,7 @@ function getGlobalPrefixCandidates({ env, execPath, argv1 }) {
     return Array.from(prefixes);
 }
 function addHomebrewPrefix(prefixes, execPath) {
-    const marker = `${sep}Cellar${sep}node`;
+    const marker = "/Cellar/node";
     const idx = execPath.indexOf(marker);
     if (idx > 0)
         prefixes.add(execPath.slice(0, idx));

package/lib/thumbBackfill.js

@@ -0,0 +1,59 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { ensureVideoThumbnail, videoThumbExists } from "./videoThumb.js";
+import { generateImageThumbnail, imageThumbExists } from "./imageThumb.js";
+/**
+ * Recursively scan `dir` (up to `maxDepth` levels, matching historyList's walk
+ * depth) and generate missing `.thumb.jpg` thumbnails for every image and video.
+ * Videos and images live both at the top level and inside subdirectories
+ * (e.g. video series clips nested one level deep under a date-stamped folder),
+ * so a flat readdir misses them — this walks the tree so the gallery never
+ * shows a thumbless media tile.
+ */
+export async function backfillThumbnails(dir, maxDepth = 2) {
+    const result = { total: 0, created: 0, skipped: 0, failed: 0 };
+    async function walk(current, depth) {
+        const entries = await readdir(current, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            const full = join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (depth > 0 && entry.name !== "trash")
+                    await walk(full, depth - 1);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (entry.name.endsWith(".thumb.jpg"))
+                continue;
+            if (!/\.(png|jpe?g|webp|mp4)$/i.test(entry.name))
+                continue;
+            result.total++;
+            try {
+                if (/\.mp4$/i.test(entry.name)) {
+                    if (await videoThumbExists(full)) {
+                        result.skipped++;
+                        continue;
+                    }
+                    const ok = await ensureVideoThumbnail(current, entry.name);
+                    if (ok)
+                        result.created++;
+                    else
+                        result.failed++;
+                }
+                else {
+                    if (await imageThumbExists(full)) {
+                        result.skipped++;
+                        continue;
+                    }
+                    await generateImageThumbnail(full);
+                    result.created++;
+                }
+            }
+            catch {
+                result.failed++;
+            }
+        }
+    }
+    await walk(dir, maxDepth);
+    return result;
+}

package/lib/vertexAuth.js

@@ -0,0 +1,44 @@
+import { GoogleAuth } from "google-auth-library";
+let cachedAuth = null;
+let cachedProjectId = null;
+export function initVertexAuth(serviceAccountJson) {
+    let parsed;
+    try {
+        parsed = JSON.parse(serviceAccountJson);
+    }
+    catch {
+        // Never surface the raw JSON (it contains the private key) in the error.
+        throw new Error("Invalid service account JSON: could not parse");
+    }
+    if (!parsed.project_id || parsed.type !== "service_account") {
+        throw new Error("Invalid service account JSON: missing project_id or type !== service_account");
+    }
+    // Build the client first; only commit module state once construction succeeds,
+    // so a throw can't leave isVertexInitialized() true with mismatched creds.
+    const auth = new GoogleAuth({
+        credentials: parsed,
+        scopes: ["https://www.googleapis.com/auth/cloud-platform"],
+    });
+    cachedAuth = auth;
+    cachedProjectId = parsed.project_id;
+    return { projectId: parsed.project_id };
+}
+export async function getVertexAccessToken() {
+    if (!cachedAuth)
+        throw new Error("Vertex AI not initialized — call initVertexAuth first");
+    const client = await cachedAuth.getClient();
+    const tokenRes = await client.getAccessToken();
+    if (!tokenRes.token)
+        throw new Error("Failed to obtain Vertex AI access token");
+    return tokenRes.token;
+}
+export function getVertexProjectId() {
+    return cachedProjectId;
+}
+export function isVertexInitialized() {
+    return cachedAuth !== null && cachedProjectId !== null;
+}
+export function clearVertexAuth() {
+    cachedAuth = null;
+    cachedProjectId = null;
+}

package/lib/videoThumb.js

@@ -0,0 +1,60 @@
+import { execFile } from "node:child_process";
+import { stat, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const FFMPEG_THUMB_TIMEOUT_MS = 15_000;
+export function thumbPathForVideo(videoPath) {
+    return `${videoPath}.thumb.jpg`;
+}
+export function thumbUrlForVideo(videoUrl) {
+    return `${videoUrl}.thumb.jpg`;
+}
+export async function generateVideoThumbnail(videoPath) {
+    const thumbPath = thumbPathForVideo(videoPath);
+    try {
+        await execFileAsync("ffmpeg", [
+            "-y",
+            "-i", videoPath,
+            "-vframes", "1",
+            "-q:v", "4",
+            "-vf", "scale='min(320,iw)':-2",
+            thumbPath,
+        ], {
+            timeout: FFMPEG_THUMB_TIMEOUT_MS,
+            killSignal: process.platform === "win32" ? "SIGTERM" : "SIGKILL",
+            maxBuffer: 1024 * 1024,
+        });
+        return thumbPath;
+    }
+    catch {
+        await unlink(thumbPath).catch(() => { });
+        throw new Error(`Failed to generate thumbnail for ${videoPath}`);
+    }
+}
+export async function ensureVideoThumbnail(generatedDir, filename) {
+    const videoPath = join(generatedDir, filename);
+    const thumbPath = thumbPathForVideo(videoPath);
+    try {
+        await stat(thumbPath);
+        return true;
+    }
+    catch {
+        try {
+            await generateVideoThumbnail(videoPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export async function videoThumbExists(videoFullPath) {
+    try {
+        await stat(thumbPathForVideo(videoFullPath));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ima2-gen",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Local OAuth image generation studio with classic and node workflows",
   "type": "module",
   "bin": {
@@ -28,7 +28,8 @@
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "typecheck:tests": "tsc --noEmit -p tsconfig.tests.json",
     "build:server": "tsc -p tsconfig.build.json",
-    "build:cli": "tsc -p tsconfig.bin.json && node scripts/fix-shebangs.mjs"
+    "build:cli": "tsc -p tsconfig.bin.json && node scripts/fix-shebangs.mjs",
+    "postinstall": "echo '\\n  [ima2] Gallery thumbnails will be auto-generated on next server start.\\n  Or run: ima2 backfill-thumbs\\n'"
   },
   "keywords": [
     "openai",
@@ -67,6 +68,7 @@
     "better-sqlite3": "^12.9.0",
     "dotenv": "^17.4.2",
     "express": "^5.1.0",
+    "google-auth-library": "^10.6.2",
     "openai": "^5.8.2",
     "openai-oauth": "^1.0.2",
     "progrok": "file:vendor/progrok-0.2.0.tgz",