ima2-gen 2.0.0 → 2.0.2

package/lib/responsesFallback.js

@@ -1,57 +1,66 @@
 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" },
+                    // OAuth/Codex proxy returns empty output[] for non-stream image requests; SSE required.
+                    stream: true,
+                },
+            });
+        }
+        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 +73,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/routeHelpers.js

@@ -0,0 +1,44 @@
+export function validateModeration(ctx, moderation) {
+    if (typeof moderation !== "string" || !ctx.config.oauth.validModeration.has(moderation)) {
+        return { error: "moderation must be one of: auto, low" };
+    }
+    return { moderation };
+}
+export function imageFormatFromMime(mime) {
+    if (mime === "image/jpeg")
+        return "jpeg";
+    if (mime === "image/webp")
+        return "webp";
+    return "png";
+}
+export function writeSse(res, event, data) {
+    res.write(`event: ${event}\n`);
+    res.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+export function dataUrlFromB64(format, b64) {
+    return `data:image/${format === "jpeg" ? "jpeg" : format};base64,${b64}`;
+}
+export function upstreamErrorFields(src) {
+    return {
+        upstreamCode: src.upstreamCode || null,
+        upstreamType: src.upstreamType || null,
+        upstreamParam: src.upstreamParam || null,
+        diagnosticReason: src.diagnosticReason || null,
+        retryKind: src.retryKind || null,
+        initialEventCount: src.initialEventCount ?? null,
+        initialEventTypes: src.initialEventTypes || null,
+        referencesDroppedOnRetry: src.referencesDroppedOnRetry ?? null,
+        developerPromptDroppedOnRetry: src.developerPromptDroppedOnRetry ?? null,
+        webSearchDroppedOnRetry: src.webSearchDroppedOnRetry ?? null,
+        fallbackEventCount: src.fallbackEventCount ?? null,
+        fallbackEventTypes: src.fallbackEventTypes || null,
+        fallbackImageCallSeen: src.fallbackImageCallSeen ?? null,
+        fallbackImageResultCount: src.fallbackImageResultCount ?? null,
+        errorEventCount: src.eventCount ?? null,
+        eventTypes: src.eventTypes || null,
+        webSearchCalls: src.webSearchCalls ?? null,
+        responseDiagnostics: src.responseDiagnostics || null,
+        toolTypes: src.toolTypes || null,
+        toolChoiceKind: src.toolChoiceKind || null,
+    };
+}

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/ssePublish.js

@@ -0,0 +1,12 @@
+import { publish } from "./eventBus.js";
+import { isJobCanceled } from "./inflight.js";
+/**
+ * Publish a multiplexed job event. Suppresses terminal `done` after cancel so
+ * clients never resolve success when abortJob already emitted `error`.
+ */
+export function publishJobEvent(requestId, event, data) {
+    if (event === "done" && isJobCanceled(requestId))
+        return false;
+    publish(requestId, event, data);
+    return true;
+}

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/storyboardPrefix.js

@@ -0,0 +1,28 @@
+export const STORYBOARD_PREFIX = [
+    "[STORYBOARD MODE — Video Production Keyframe / Storyboard Grid]",
+    "This image will be used for video production. It may be a single keyframe OR a 3x3 storyboard grid.",
+    "The prompt and all injected instructions MUST be in English.",
+    "",
+    "IF GENERATING A 3x3 STORYBOARD GRID:",
+    "- Panel 1 (top-left) MUST be COMPLETELY SOLID BLACK — no image, no text, just pure black.",
+    "- Panels 2-9 contain the action sequence (8 key moments).",
+    "- Do NOT add timestamp labels or text overlays to any panel — they burn into the video.",
+    "- Maintain identical character designs across all panels.",
+    "- Each panel should look like a cinematic film still, not a sketch.",
+    "",
+    "CHARACTER LOCK:",
+    "- Identify each character by 2-3 VISUAL identifiers (clothing color + physique + position/props). Never by name alone.",
+    "- Copy character descriptions VERBATIM from the reference/prior frame. Do NOT rephrase or drift.",
+    "",
+    "SCENE CONTINUITY:",
+    "- Lock lighting direction, color palette, environment, and art style to prior frames.",
+    "- Change ONLY: action, shot scale, camera angle, or expression.",
+    "- Reference image = canonical anchor. Preserve it faithfully.",
+    "",
+    "VIDEO-READY COMPOSITION:",
+    "- Frame for animation: leave space for motion, avoid static-only poses.",
+    "- Use descriptive caption format: shot type + subject action + environment + technical (lens, lighting) + mood.",
+    "- Specify intended camera movement for the video phase (e.g. 'slow dolly-in', 'static wide').",
+    "- End pose must be stable and suitable for video continuation.",
+    "",
+].join("\n") + "\n";

package/lib/thumbBackfill.js

@@ -0,0 +1,70 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { ensureVideoThumbnail, videoThumbExists } from "./videoThumb.js";
+import { generateImageThumbnail, imageThumbExists } from "./imageThumb.js";
+const FAILURE_DETAIL_LIMIT = 20;
+function errorReason(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * 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, failures: [] };
+    function recordFailure(file, kind, reason) {
+        result.failed++;
+        if (result.failures.length >= FAILURE_DETAIL_LIMIT)
+            return;
+        result.failures.push({ file, kind, reason });
+    }
+    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++;
+            const kind = /\.mp4$/i.test(entry.name) ? "video" : "image";
+            try {
+                if (kind === "video") {
+                    if (await videoThumbExists(full)) {
+                        result.skipped++;
+                        continue;
+                    }
+                    const ok = await ensureVideoThumbnail(current, entry.name);
+                    if (ok)
+                        result.created++;
+                    else
+                        recordFailure(full, kind, "thumbnail generation returned false");
+                }
+                else {
+                    if (await imageThumbExists(full)) {
+                        result.skipped++;
+                        continue;
+                    }
+                    await generateImageThumbnail(full);
+                    result.created++;
+                }
+            }
+            catch (error) {
+                recordFailure(full, kind, errorReason(error));
+            }
+        }
+    }
+    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.2",
   "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",
@@ -38,6 +39,7 @@
     "cli"
   ],
   "license": "MIT",
+  "homepage": "https://lidge-jun.github.io/ima2-gen/",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lidge-jun/ima2-gen.git"
@@ -56,6 +58,7 @@
     "assets/card-news/templates/",
     ".env.example",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE",
     "server.js",
     "config.js"
@@ -64,9 +67,11 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@openai/codex": "latest",
     "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",

package/routes/agy.js

@@ -0,0 +1,44 @@
+import { spawn } from "node:child_process";
+// Detect whether the Antigravity CLI (`agy`) is installed, using the same
+// spawn-and-catch style as lib/agyImageAdapter.ts (no shell `which`/`where`).
+// Login state cannot be probed — agy has no status command — so we only
+// report installation here.
+function isAgyInstalled() {
+    return new Promise((resolve) => {
+        let settled = false;
+        const done = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(value);
+        };
+        try {
+            const child = spawn("agy", ["--version"], { stdio: "ignore" });
+            child.on("error", () => done(false)); // ENOENT when not on PATH
+            child.on("exit", (code) => done(code === 0));
+            // Safety timeout so a hung binary never blocks the request.
+            setTimeout(() => {
+                try {
+                    if (!child.killed)
+                        child.kill();
+                }
+                catch { /* ignore */ }
+                done(false);
+            }, 3000).unref?.();
+        }
+        catch {
+            done(false);
+        }
+    });
+}
+export function registerAgyRoutes(app) {
+    app.get("/api/agy/status", async (_req, res) => {
+        try {
+            const installed = await isAgyInstalled();
+            res.json({ installed });
+        }
+        catch {
+            res.json({ installed: false });
+        }
+    });
+}