@steipete/oracle 0.13.0 → 0.14.1

package/dist/src/browser/chatgptImages.js

@@ -1,12 +1,41 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { randomUUID } from "node:crypto";
 import { ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR } from "./constants.js";
 import { delay } from "./utils.js";
 import { readAssistantSnapshot } from "./pageActions.js";
 import { getOracleHomeDir } from "../oracleHome.js";
 import { resolveSessionArtifactsDir } from "./artifacts.js";
+import { saveAssistantDownloadButtonArtifacts } from "./chatgptFiles.js";
 const GENERATED_IMAGE_WAIT_MIN_MS = 15_000;
 const GENERATED_IMAGE_WAIT_MAX_MS = 15 * 60_000;
+const CHATGPT_GENERATED_IMAGE_BASE_URL = "https://chatgpt.com/";
+function isAllowedChatGptHost(hostname) {
+    const value = hostname.toLowerCase();
+    return value === "chatgpt.com" || value === "chat.openai.com";
+}
+function normalizeGeneratedImageUrl(value) {
+    const raw = String(value ?? "").trim();
+    if (!raw)
+        return undefined;
+    let url;
+    try {
+        url = new URL(raw, CHATGPT_GENERATED_IMAGE_BASE_URL);
+    }
+    catch {
+        return undefined;
+    }
+    if (url.protocol !== "https:" || url.port || !isAllowedChatGptHost(url.hostname)) {
+        return undefined;
+    }
+    if (url.pathname !== "/backend-api/estuary/content") {
+        return undefined;
+    }
+    if (!(url.searchParams.get("id") ?? "").startsWith("file_")) {
+        return undefined;
+    }
+    return url.href;
+}
 function extractFileId(url) {
     try {
         return new URL(url).searchParams.get("id") ?? undefined;
@@ -39,8 +68,12 @@ function buildAssistantImageExpression(minTurnIndex) {
     const CONVERSATION_SELECTOR = ${conversationLiteral};
     const ASSISTANT_SELECTOR = ${assistantLiteral};
     const isGeneratedImage = (img) => {
-      const url = img?.src || '';
-      if (!url.includes('/backend-api/estuary/content?id=file_')) return false;
+      const url = new URL(img?.src || '', location.origin || 'https://chatgpt.com');
+      const host = url.hostname.toLowerCase();
+      if (url.protocol !== 'https:' || url.port) return false;
+      if (host !== 'chatgpt.com' && host !== 'chat.openai.com') return false;
+      if (url.pathname !== '/backend-api/estuary/content') return false;
+      if (!String(url.searchParams.get('id') || '').startsWith('file_')) return false;
       const alt = String(img.alt || '').toLowerCase();
       if (alt.includes('generated image')) return true;
       let node = img;
@@ -102,13 +135,16 @@ export async function readAssistantGeneratedImages(Runtime, minTurnIndex) {
     });
     const raw = Array.isArray(result?.value) ? result.value : [];
     const normalized = raw
-        .map((item) => ({
-        url: typeof item?.url === "string" ? item.url : "",
-        alt: typeof item?.alt === "string" ? item.alt : undefined,
-        width: typeof item?.width === "number" ? item.width : undefined,
-        height: typeof item?.height === "number" ? item.height : undefined,
-        fileId: typeof item?.url === "string" ? extractFileId(item.url) : undefined,
-    }))
+        .map((item) => {
+        const url = normalizeGeneratedImageUrl(typeof item?.url === "string" ? item.url : "");
+        return {
+            url: url ?? "",
+            alt: typeof item?.alt === "string" ? item.alt : undefined,
+            width: typeof item?.width === "number" ? item.width : undefined,
+            height: typeof item?.height === "number" ? item.height : undefined,
+            fileId: url ? extractFileId(url) : undefined,
+        };
+    })
         .filter((item) => item.url.length > 0);
     return dedupeImages(normalized);
 }
@@ -150,6 +186,29 @@ function contentTypeToExtension(contentType) {
         return "svg";
     return "bin";
 }
+function detectImageFile(buffer) {
+    if (buffer.length >= 8 &&
+        buffer.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {
+        return { extension: "png", mimeType: "image/png" };
+    }
+    if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
+        return { extension: "jpg", mimeType: "image/jpeg" };
+    }
+    if (buffer.length >= 12 &&
+        buffer.subarray(0, 4).toString("ascii") === "RIFF" &&
+        buffer.subarray(8, 12).toString("ascii") === "WEBP") {
+        return { extension: "webp", mimeType: "image/webp" };
+    }
+    const signature = buffer.subarray(0, 6).toString("ascii");
+    if (signature === "GIF87a" || signature === "GIF89a") {
+        return { extension: "gif", mimeType: "image/gif" };
+    }
+    const text = buffer.subarray(0, Math.min(buffer.length, 1024)).toString("utf8").trimStart();
+    if (/^(?:<\?xml[^>]*>\s*)?<svg[\s>]/i.test(text)) {
+        return { extension: "svg", mimeType: "image/svg+xml" };
+    }
+    return null;
+}
 function resolveSiblingImagePath(basePath, index, extension) {
     const ext = path.extname(basePath);
     const dir = path.dirname(basePath);
@@ -169,12 +228,13 @@ function sanitizeGeneratedImageStem(value) {
 }
 function resolveDefaultGeneratedImagePath(images, sessionId) {
     const primary = images[0];
-    const stemSource = primary?.fileId || primary?.alt || primary?.url || `generated-${Date.now().toString(36)}`;
-    const stem = sanitizeGeneratedImageStem(stemSource) || `generated-${Date.now().toString(36)}`;
+    const stemSource = primary?.fileId || primary?.alt || primary?.url || "generated";
+    const stem = sanitizeGeneratedImageStem(stemSource) || "generated";
     const baseDir = sessionId
         ? resolveSessionArtifactsDir(sessionId)
         : path.join(getOracleHomeDir(), ".temp");
-    return path.join(baseDir, `${stem}.png`);
+    const uniqueSuffix = sessionId ? "" : `-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+    return path.join(baseDir, `${stem}${uniqueSuffix}.png`);
 }
 async function buildCookieHeader(Network) {
     const response = await Network.getCookies({ urls: ["https://chatgpt.com/"] });
@@ -183,8 +243,51 @@ async function buildCookieHeader(Network) {
         .map((cookie) => `${cookie.name}=${cookie.value}`)
         .join("; ");
 }
+async function fetchGeneratedImageInBrowserContext(Runtime, url) {
+    const expression = `
+    (async () => {
+      const url = ${JSON.stringify(url)};
+      const response = await fetch(url, { credentials: 'include', redirect: 'follow' });
+      const contentType = response.headers.get('content-type') || '';
+      const buffer = await response.arrayBuffer();
+      const bytes = new Uint8Array(buffer);
+      let binary = '';
+      for (let index = 0; index < bytes.length; index += 0x8000) {
+        binary += String.fromCharCode(...bytes.slice(index, index + 0x8000));
+      }
+      return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        contentType,
+        finalUrl: response.url,
+        b64: btoa(binary),
+      };
+    })()
+  `;
+    const { result, exceptionDetails } = await Runtime.evaluate({
+        expression,
+        awaitPromise: true,
+        returnByValue: true,
+        timeout: 120_000,
+    });
+    if (exceptionDetails) {
+        throw new Error("browser-context fetch threw an exception");
+    }
+    const value = result?.value;
+    if (!value?.ok || typeof value.b64 !== "string") {
+        const status = typeof value?.status === "number" ? value.status : "unknown";
+        const statusText = typeof value?.statusText === "string" ? value.statusText : "";
+        throw new Error(`browser-context fetch failed: ${status} ${statusText}`.trim());
+    }
+    return {
+        buffer: Buffer.from(value.b64, "base64"),
+        contentType: typeof value.contentType === "string" ? value.contentType : null,
+        finalUrl: typeof value.finalUrl === "string" && value.finalUrl ? value.finalUrl : url,
+    };
+}
 export async function saveChatGptGeneratedImages(params) {
-    const { Network, images, outputPath, logger } = params;
+    const { Network, Runtime, images, outputPath, logger } = params;
     if (!images.length)
         return { saved: false, imageCount: 0, savedImages: [], errors: [] };
     const cookieHeader = await buildCookieHeader(Network);
@@ -202,20 +305,41 @@ export async function saveChatGptGeneratedImages(params) {
     for (let index = 0; index < images.length; index += 1) {
         const image = images[index];
         try {
-            const response = await fetch(image.url, {
-                headers: {
-                    cookie: cookieHeader,
-                    "user-agent": "Mozilla/5.0",
-                },
-                redirect: "follow",
-            });
-            if (!response.ok) {
-                throw new Error(`download failed: ${response.status} ${response.statusText}`);
+            const imageUrl = normalizeGeneratedImageUrl(image.url);
+            if (!imageUrl) {
+                throw new Error("rejected non-ChatGPT generated image URL");
+            }
+            let contentType = null;
+            let finalUrl = imageUrl;
+            let buffer;
+            try {
+                const response = await fetch(imageUrl, {
+                    headers: {
+                        cookie: cookieHeader,
+                        "user-agent": "Mozilla/5.0",
+                    },
+                    redirect: "follow",
+                });
+                if (!response.ok) {
+                    throw new Error(`download failed: ${response.status} ${response.statusText}`);
+                }
+                contentType = response.headers.get("content-type");
+                finalUrl = response.url;
+                buffer = Buffer.from(await response.arrayBuffer());
+            }
+            catch (downloadError) {
+                if (!Runtime) {
+                    throw downloadError;
+                }
+                const message = downloadError instanceof Error ? downloadError.message : String(downloadError);
+                logger?.(`[browser] ChatGPT generated image download failed via Node fetch; retrying in browser context (${image.fileId ?? imageUrl}: ${message}).`);
+                const browserFetch = await fetchGeneratedImageInBrowserContext(Runtime, imageUrl);
+                contentType = browserFetch.contentType;
+                finalUrl = browserFetch.finalUrl;
+                buffer = browserFetch.buffer;
             }
-            const contentType = response.headers.get("content-type");
             const extension = contentTypeToExtension(contentType);
             const targetPath = resolveSiblingImagePath(path.resolve(outputPath), index, extension);
-            const buffer = Buffer.from(await response.arrayBuffer());
             await fs.writeFile(targetPath, buffer);
             savedImages.push({
                 kind: "image",
@@ -223,9 +347,9 @@ export async function saveChatGptGeneratedImages(params) {
                 label: index === 0 ? "Generated image" : `Generated image ${index + 1}`,
                 mimeType: contentType ?? undefined,
                 sizeBytes: buffer.length,
-                sourceUrl: image.url,
-                url: image.url,
-                finalUrl: response.url,
+                sourceUrl: imageUrl,
+                url: imageUrl,
+                finalUrl,
                 alt: image.alt,
                 width: image.width,
                 height: image.height,
@@ -245,14 +369,89 @@ export async function saveChatGptGeneratedImages(params) {
         errors,
     };
 }
+async function saveGeneratedImageButtonArtifacts(params) {
+    const buttonDownloads = await saveAssistantDownloadButtonArtifacts({
+        Browser: params.Browser,
+        Client: params.Client,
+        Page: params.Page,
+        Runtime: params.Runtime,
+        logger: params.logger,
+        files: [],
+        allowGenericDownloadLabels: true,
+        downloadPath: path.dirname(params.targetPath),
+        minTurnIndex: params.minTurnIndex,
+    });
+    const buttonImages = [];
+    for (const download of buttonDownloads) {
+        const contents = await fs.readFile(download.path);
+        const detected = detectImageFile(contents);
+        if (!detected) {
+            await fs.unlink(download.path).catch(() => undefined);
+            params.logger?.(`[browser] Ignored non-image assistant download: ${download.label}`);
+            continue;
+        }
+        const index = buttonImages.length;
+        const resolvedPath = resolveSiblingImagePath(params.targetPath, index, detected.extension);
+        if (path.resolve(download.path) !== resolvedPath) {
+            await fs.copyFile(download.path, resolvedPath);
+            await fs.unlink(download.path);
+        }
+        const stat = await fs.stat(resolvedPath);
+        buttonImages.push({
+            kind: "image",
+            path: resolvedPath,
+            label: index === 0 ? "Generated image" : `Generated image ${index + 1}`,
+            mimeType: detected.mimeType,
+            sizeBytes: stat.size,
+            sourceUrl: "browser-download",
+            url: "browser-download",
+            finalUrl: "browser-download",
+            alt: download.label,
+        });
+    }
+    if (buttonImages.length > 0) {
+        params.logger?.(`[browser] Saved ${buttonImages.length} generated image download artifact(s).`);
+    }
+    return buttonImages;
+}
+function formatButtonImageArtifacts(buttonImages, answerText) {
+    const primaryPath = buttonImages[0]?.path ?? "";
+    return {
+        generatedImages: buttonImages.map((image) => ({
+            url: image.url,
+            alt: image.alt,
+        })),
+        savedImages: buttonImages,
+        imageCount: buttonImages.length,
+        markdownSuffix: buttonImages.length > 1
+            ? `\n\n*Generated ${buttonImages.length} image(s). Saved ${buttonImages.length} file(s) starting at: ${primaryPath}*`
+            : `\n\n*Generated 1 image(s). Saved to: ${primaryPath}*`,
+        answerText,
+    };
+}
 export async function collectGeneratedImageArtifacts(params) {
     const explicitTargetPath = params.generateImagePath ?? params.outputPath;
     let generatedImages = await readAssistantGeneratedImagesWithFallback(params.Runtime, params.minTurnIndex ?? undefined);
     let latestAnswerText = params.answerText;
     if (explicitTargetPath && generatedImages.length === 0) {
+        await params.checkBlockingUiWarning?.();
+        const targetPath = path.resolve(explicitTargetPath);
+        const buttonImages = await saveGeneratedImageButtonArtifacts({
+            Browser: params.Browser,
+            Client: params.Client,
+            Page: params.Page,
+            Runtime: params.Runtime,
+            logger: params.logger,
+            minTurnIndex: params.minTurnIndex,
+            targetPath,
+        });
+        if (buttonImages.length > 0) {
+            return formatButtonImageArtifacts(buttonImages, latestAnswerText);
+        }
         const deadline = Date.now() + resolveGeneratedImageWaitTimeoutMs(params.waitTimeoutMs);
         while (Date.now() < deadline) {
             await delay(1500);
+            await params.checkBlockingUiWarning?.();
             generatedImages = await readAssistantGeneratedImagesWithFallback(params.Runtime, params.minTurnIndex ?? undefined);
             if (generatedImages.length > 0) {
                 break;
@@ -263,6 +462,21 @@ export async function collectGeneratedImageArtifacts(params) {
                 latestAnswerText = snapshotText;
             }
         }
+        if (generatedImages.length === 0) {
+            await params.checkBlockingUiWarning?.();
+            const delayedButtonImages = await saveGeneratedImageButtonArtifacts({
+                Browser: params.Browser,
+                Client: params.Client,
+                Page: params.Page,
+                Runtime: params.Runtime,
+                logger: params.logger,
+                minTurnIndex: params.minTurnIndex,
+                targetPath,
+            });
+            if (delayedButtonImages.length > 0) {
+                return formatButtonImageArtifacts(delayedButtonImages, latestAnswerText);
+            }
+        }
     }
     const imageCount = generatedImages.length;
     if (explicitTargetPath && imageCount === 0) {
@@ -283,11 +497,26 @@ export async function collectGeneratedImageArtifacts(params) {
     }
     const saved = await saveChatGptGeneratedImages({
         Network: params.Network,
+        Runtime: params.Runtime,
         images: generatedImages,
         outputPath: targetPath,
         logger: params.logger,
     });
     if (!saved.saved) {
+        if (explicitTargetPath) {
+            const buttonImages = await saveGeneratedImageButtonArtifacts({
+                Browser: params.Browser,
+                Client: params.Client,
+                Page: params.Page,
+                Runtime: params.Runtime,
+                logger: params.logger,
+                minTurnIndex: params.minTurnIndex,
+                targetPath: path.resolve(explicitTargetPath),
+            });
+            if (buttonImages.length > 0) {
+                return formatButtonImageArtifacts(buttonImages, latestAnswerText);
+            }
+        }
         const detail = saved.errors.length > 0 ? `\n${saved.errors.join("\n")}` : "";
         if (explicitTargetPath) {
             throw new Error(`No images generated. Response text:\n${latestAnswerText || "(empty response)"}${detail}`);

package/dist/src/browser/chromeLifecycle.js

@@ -340,6 +340,10 @@ function createSessionBoundChromeClient(browser, sessionId) {
     };
     return {
         ...browser,
+        // Raw `send` here is the browser-level send (not session-bound), so callers
+        // that issue Target.* via `send` must pass this page session id explicitly to
+        // stay scoped to this tab (e.g. Deep Research OOPIF auto-attach).
+        oraclePageSessionId: sessionId,
         Network: bindDomain("Network"),
         Page: bindDomain("Page"),
         Runtime: bindDomain("Runtime"),

package/dist/src/browser/config.js

@@ -55,6 +55,7 @@ export const DEFAULT_BROWSER_CONFIG = {
     manualLoginCookieSync: false,
     researchMode: "off",
     archiveConversations: "auto",
+    resumeConversationUrl: null,
 };
 export function resolveBrowserConfig(config) {
     const debugPortEnv = parseDebugPort(process.env.ORACLE_BROWSER_PORT ?? process.env.ORACLE_BROWSER_DEBUG_PORT);
@@ -112,6 +113,7 @@ export function resolveBrowserConfig(config) {
         thinkingTime: config?.thinkingTime,
         researchMode,
         archiveConversations,
+        resumeConversationUrl: config?.resumeConversationUrl ?? DEFAULT_BROWSER_CONFIG.resumeConversationUrl,
         manualLogin,
         manualLoginProfileDir: manualLogin ? resolvedProfileDir : null,
         manualLoginCookieSync: config?.manualLoginCookieSync ?? DEFAULT_BROWSER_CONFIG.manualLoginCookieSync,