@isen/chatgpt-image-web-mcp 0.3.0

package/dist/chatgpt-automation.js

@@ -0,0 +1,901 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { atomicWriteJson, detectImageContentType, ensureDirectory, imageExtension, makeJobId, processIsAlive, readJsonFile, resolvePath, safeFileStem, sleep, } from "./utils.js";
+const DEFAULT_OUTPUT_DIR = process.env.IMAGE_BROWSER_DEFAULT_OUTPUT_DIR || "generated/web-images";
+const PREPARED_JOB_PATH_NAME = "prepared-job.json";
+const STOP_SELECTORS = [
+    "button[data-testid='stop-button']",
+    "button[aria-label*='Stop']",
+    "button[aria-label*='停止']",
+];
+const GENERATION_ERROR_PATTERN = /(Something went wrong|There was an error|出错了|发生错误|请重试)/i;
+export function newAssistantMessagesContainError(assistantMessages, baselineCount) {
+    return assistantMessages.slice(Math.max(0, baselineCount)).some((message) => GENERATION_ERROR_PATTERN.test(message));
+}
+const ATTACHMENT_REMOVE_SELECTOR = [
+    "button[aria-label^='Remove file']",
+    "button[aria-label^='Remove image']",
+    "button[aria-label^='移除文件']",
+    "button[aria-label^='删除文件']",
+    "button[aria-label^='移除图片']",
+].join(", ");
+export class ChatGptAutomation {
+    browserManager;
+    agentId;
+    constructor(browserManager, agentId) {
+        this.browserManager = browserManager;
+        this.agentId = agentId;
+    }
+    async autoCloseBrowserAfterSuccess() {
+        if (!this.browserManager.autoCloseAfterSuccess)
+            return;
+        try {
+            await this.browserManager.closeDedicatedBrowser({ preservePreparedJobs: true });
+        }
+        catch (error) {
+            console.error("自动关闭专用浏览器已跳过：", error instanceof Error ? error.message : String(error));
+        }
+    }
+    agentKey(length = 20) {
+        return crypto.createHash("sha256").update(this.agentId).digest("hex").slice(0, length);
+    }
+    preparedJobPath() {
+        const directory = ensureDirectory(path.join(this.browserManager.stateDir, "prepared-jobs"));
+        return path.join(directory, `${this.agentKey()}-${PREPARED_JOB_PATH_NAME}`);
+    }
+    readPreparedJob() {
+        const prepared = JSON.parse(fs.readFileSync(this.preparedJobPath(), "utf8"));
+        if (!prepared || prepared.agentId !== this.agentId || !prepared.jobId) {
+            throw new Error("待发送任务状态无效或不属于当前Agent。请清除后重新准备任务。");
+        }
+        // v0.3.0 initially had no explicit state; preserve those already-prepared jobs.
+        prepared.state ||= "prepared";
+        const validStates = [
+            "prepared",
+            "submitting",
+            "sent",
+            "needs_human",
+            "completed",
+        ];
+        if (!validStates.includes(prepared.state)) {
+            throw new Error("待发送任务状态无法识别。请检查页面，确认后清除并重新准备任务。");
+        }
+        return prepared;
+    }
+    writePreparedJob(prepared) {
+        atomicWriteJson(this.preparedJobPath(), prepared);
+    }
+    assertJobCanBeSubmitted(prepared) {
+        if (prepared.state === "prepared")
+            return;
+        const stateMessages = {
+            submitting: "发送动作已经开始，但是否到达ChatGPT尚不确定",
+            sent: "任务已经发送到ChatGPT",
+            needs_human: "任务已经发送且需要人工检查结果",
+            completed: "任务已经完成",
+        };
+        throw new Error(`${stateMessages[prepared.state]}。为避免重复消耗额度，本次拒绝再次发送；请检查页面并使用 download_latest_image，或明确清除后重新准备任务。`);
+    }
+    outputStemAlreadyExists(outputDir, outputStem, ignoredPaths = []) {
+        const ignored = new Set(ignoredPaths.map((item) => path.resolve(item)));
+        const knownPaths = [
+            path.join(outputDir, `${outputStem}.json`),
+            path.join(outputDir, `${outputStem}-prepared.png`),
+            path.join(outputDir, `${outputStem}-result.png`),
+            path.join(outputDir, `${outputStem}-batch.json`),
+            ...[".png", ".jpg", ".jpeg", ".webp", ".gif", ".avif"].flatMap((extension) => [
+                path.join(outputDir, `${outputStem}${extension}`),
+                path.join(outputDir, `${outputStem}-image${extension}`),
+            ]),
+        ];
+        return knownPaths.some((item) => !ignored.has(path.resolve(item)) && fs.existsSync(item));
+    }
+    reserveOutputStem(outputDir, requestedStem, jobId, ignoredPaths = []) {
+        const reservations = ensureDirectory(path.join(this.browserManager.stateDir, "output-reservations"));
+        const base = safeFileStem(requestedStem);
+        for (let attempt = 0; attempt < 1_000; attempt += 1) {
+            const suffix = attempt === 0
+                ? ""
+                : attempt === 1
+                    ? `-${this.agentKey(8)}`
+                    : `-${this.agentKey(8)}-${attempt}`;
+            const truncatedBase = base.slice(0, Math.max(1, 80 - suffix.length));
+            const candidate = safeFileStem(`${truncatedBase}${suffix}`);
+            if (this.outputStemAlreadyExists(outputDir, candidate, ignoredPaths))
+                continue;
+            const reservationKey = crypto
+                .createHash("sha256")
+                .update(`${outputDir}\u0000${candidate}`)
+                .digest("hex");
+            const reservationPath = path.join(reservations, `${reservationKey}.json`);
+            const reservation = {
+                pid: process.pid,
+                agentId: this.agentId,
+                jobId,
+                outputDir,
+                outputStem: candidate,
+                createdAt: new Date().toISOString(),
+            };
+            try {
+                fs.writeFileSync(reservationPath, `${JSON.stringify(reservation)}\n`, { flag: "wx", mode: 0o600 });
+                return { outputStem: candidate, reservationPath };
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+                const existing = readJsonFile(reservationPath);
+                if (existing?.agentId === this.agentId && existing.jobId === jobId) {
+                    return { outputStem: candidate, reservationPath };
+                }
+                const stat = fs.statSync(reservationPath, { throwIfNoEntry: false });
+                if (!stat) {
+                    attempt -= 1;
+                    continue;
+                }
+                const ageMs = Date.now() - stat.mtimeMs;
+                if (ageMs >= 5_000 && !processIsAlive(existing?.pid)) {
+                    fs.rmSync(reservationPath, { force: true });
+                    attempt -= 1;
+                }
+            }
+        }
+        throw new Error(`无法为输出文件分配唯一名称：${base}`);
+    }
+    releaseOutputReservation(prepared) {
+        if (!prepared.reservationPath)
+            return;
+        const reservation = readJsonFile(prepared.reservationPath);
+        if (reservation?.agentId === prepared.agentId && reservation.jobId === prepared.jobId) {
+            fs.rmSync(prepared.reservationPath, { force: true });
+        }
+    }
+    async findComposer(page, timeoutMs = 5_000) {
+        const selectors = [
+            "#prompt-textarea",
+            "textarea[data-testid='prompt-textarea']",
+            "textarea[placeholder*='Message']",
+            "textarea[placeholder*='消息']",
+            "main [contenteditable='true']",
+        ];
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            for (const selector of selectors) {
+                const candidate = page.locator(selector).first();
+                try {
+                    if (await candidate.isVisible({ timeout: 250 }))
+                        return candidate;
+                }
+                catch {
+                    // Try the next selector while ChatGPT is rendering.
+                }
+            }
+            await sleep(250);
+        }
+        return undefined;
+    }
+    async inspectPage(page) {
+        const composerReady = Boolean(await this.findComposer(page, 1_500));
+        const bodyText = (await page.locator("body").innerText({ timeout: 5_000 }).catch(() => "")).slice(0, 20_000);
+        const loginLikelyRequired = !composerReady &&
+            /(Log in|Sign up|登录|注册|欢迎使用 ChatGPT|Welcome to ChatGPT)/i.test(bodyText);
+        const challengeLikelyPresent = /(verify you are human|security check|Cloudflare|验证码|验证您是真人|安全检查)/i.test(bodyText);
+        return {
+            url: page.url(),
+            title: await page.title().catch(() => ""),
+            composerReady,
+            loginLikelyRequired,
+            challengeLikelyPresent,
+        };
+    }
+    validateReferences(referenceImages) {
+        return referenceImages.map((input) => {
+            const absolute = resolvePath(input);
+            const stat = fs.statSync(absolute, { throwIfNoEntry: false });
+            if (!stat?.isFile())
+                throw new Error(`参考图不存在或不是文件：${absolute}`);
+            if (stat.size > 50 * 1024 * 1024)
+                throw new Error(`参考图超过50MB：${absolute}`);
+            return absolute;
+        });
+    }
+    async uploadReferences(page, references) {
+        if (references.length === 0)
+            return;
+        let fileInput = page.locator("input[type='file']").last();
+        if ((await fileInput.count()) === 0) {
+            const attachSelectors = [
+                "button[data-testid='composer-plus-btn']",
+                "button[aria-label*='Attach']",
+                "button[aria-label*='Upload']",
+                "button[aria-label*='添加']",
+                "button[aria-label*='上传']",
+            ];
+            for (const selector of attachSelectors) {
+                const button = page.locator(selector).first();
+                if (await button.isVisible().catch(() => false)) {
+                    await button.click();
+                    break;
+                }
+            }
+            await sleep(500);
+            fileInput = page.locator("input[type='file']").last();
+        }
+        if ((await fileInput.count()) === 0) {
+            throw new Error("没有找到ChatGPT附件上传控件。浏览器保持打开，请人工检查页面或登录状态。");
+        }
+        await fileInput.setInputFiles(references);
+        await sleep(Math.min(2_000 + references.length * 500, 6_000));
+    }
+    async composerText(composer) {
+        return composer.evaluate((element) => {
+            if (element instanceof HTMLTextAreaElement || element instanceof HTMLInputElement) {
+                return element.value;
+            }
+            return element.innerText || element.textContent || "";
+        }).catch(() => "");
+    }
+    async fillPrompt(composer, prompt) {
+        await composer.click();
+        await composer.fill(prompt);
+        const actual = await this.composerText(composer);
+        if (actual.trim() !== prompt.trim()) {
+            throw new Error("提示词未能完整写入ChatGPT输入框");
+        }
+    }
+    async attachmentCount(page) {
+        const buttons = page.locator(ATTACHMENT_REMOVE_SELECTOR);
+        let visible = 0;
+        for (let index = 0; index < await buttons.count(); index += 1) {
+            if (await buttons.nth(index).isVisible().catch(() => false))
+                visible += 1;
+        }
+        return visible;
+    }
+    async firstVisibleAttachmentRemoveButton(page) {
+        const buttons = page.locator(ATTACHMENT_REMOVE_SELECTOR);
+        for (let index = 0; index < await buttons.count(); index += 1) {
+            const button = buttons.nth(index);
+            if (await button.isVisible().catch(() => false))
+                return button;
+        }
+        return undefined;
+    }
+    async clearComposerContents(page) {
+        const composer = await this.findComposer(page, 3_000);
+        let clearedPrompt = false;
+        if (composer) {
+            await composer.fill("");
+            clearedPrompt = true;
+        }
+        let removedAttachments = 0;
+        for (let attempt = 0; attempt < 20; attempt += 1) {
+            const removeButton = await this.firstVisibleAttachmentRemoveButton(page);
+            if (!removeButton)
+                break;
+            await removeButton.click({ force: true, timeout: 3_000 });
+            removedAttachments += 1;
+            await sleep(150);
+        }
+        if (await this.attachmentCount(page)) {
+            throw new Error("未能清空ChatGPT输入框中的旧附件。为避免引用错误图片，本次任务已停止。");
+        }
+        return { clearedPrompt, removedAttachments };
+    }
+    async savePageScreenshot(page, outputPath) {
+        const bytes = await page.screenshot({ fullPage: false });
+        fs.writeFileSync(outputPath, bytes, { flag: "wx", mode: 0o600 });
+    }
+    async collectImageCandidates(page) {
+        return page.locator("main img").evaluateAll((images) => images
+            .map((element, index) => {
+            const image = element;
+            const roleElement = image.closest("[data-message-author-role]");
+            return {
+                index,
+                src: image.currentSrc || image.src || "",
+                alt: image.alt || "",
+                width: image.naturalWidth || image.width || 0,
+                height: image.naturalHeight || image.height || 0,
+                role: roleElement?.getAttribute("data-message-author-role") || "",
+            };
+        })
+            .filter((image) => {
+            const largeEnough = image.width >= 512 && image.height >= 512;
+            const generatedAlt = /(generated|生成|image)/i.test(image.alt);
+            const assistantImage = image.role === "assistant";
+            return Boolean(image.src) && largeEnough && (assistantImage || generatedAlt);
+        }));
+    }
+    async prepareJobUnlocked(args) {
+        const { page } = await this.browserManager.connect({ agentId: this.agentId });
+        const pageState = await this.inspectPage(page);
+        if (!pageState.composerReady) {
+            throw new Error(pageState.challengeLikelyPresent
+                ? "浏览器出现安全验证，请在专用浏览器中人工完成后重试。"
+                : "ChatGPT输入框不可用。请在专用浏览器中登录Pro账号并进入可发送消息的页面。");
+        }
+        const references = this.validateReferences(args.referenceImages || []);
+        await this.clearComposerContents(page);
+        const previousPrepared = readJsonFile(this.preparedJobPath());
+        if (previousPrepared)
+            this.releaseOutputReservation(previousPrepared);
+        fs.rmSync(this.preparedJobPath(), { force: true });
+        const outputDir = ensureDirectory(resolvePath(args.outputDir || DEFAULT_OUTPUT_DIR));
+        const jobId = makeJobId(`${this.agentId}\n${args.prompt}`);
+        const reserved = this.reserveOutputStem(outputDir, args.outputStem || jobId, jobId);
+        const screenshotPath = path.join(outputDir, `${reserved.outputStem}-prepared.png`);
+        try {
+            await this.uploadReferences(page, references);
+            const composer = await this.findComposer(page, 5_000);
+            if (!composer)
+                throw new Error("上传参考图后找不到提示词输入框");
+            await this.fillPrompt(composer, args.prompt);
+            await this.savePageScreenshot(page, screenshotPath);
+            const baseline = await this.collectImageCandidates(page);
+            const prepared = {
+                agentId: this.agentId,
+                jobId,
+                state: "prepared",
+                outputStem: reserved.outputStem,
+                prompt: args.prompt,
+                referenceImages: references,
+                preparedAt: new Date().toISOString(),
+                reservationPath: reserved.reservationPath,
+                preparedAttachmentCount: await this.attachmentCount(page),
+                baselineImageSources: baseline.map((item) => item.src),
+                outputDir,
+                screenshotPath,
+            };
+            this.writePreparedJob(prepared);
+            return { prepared, pageState: await this.inspectPage(page) };
+        }
+        catch (error) {
+            this.releaseOutputReservation({
+                agentId: this.agentId,
+                jobId,
+                reservationPath: reserved.reservationPath,
+            });
+            throw error;
+        }
+    }
+    async prepareJob(args) {
+        const release = await this.browserManager.acquireJobLock(this.agentId);
+        try {
+            return await this.prepareJobUnlocked(args);
+        }
+        finally {
+            release();
+        }
+    }
+    async clickSend(page) {
+        const sendSelectors = [
+            "button[data-testid='send-button']",
+            "button[aria-label*='Send']",
+            "button[aria-label*='发送']",
+        ];
+        for (const selector of sendSelectors) {
+            const button = page.locator(selector).first();
+            if (await button.isVisible().catch(() => false)) {
+                if (await button.isEnabled().catch(() => false)) {
+                    await button.click();
+                    return;
+                }
+            }
+        }
+        const composer = await this.findComposer(page, 2_000);
+        if (!composer)
+            throw new Error("找不到发送按钮或提示词输入框");
+        await composer.press("Enter");
+    }
+    async generationStillRunning(page) {
+        for (const selector of STOP_SELECTORS) {
+            if (await page.locator(selector).first().isVisible().catch(() => false))
+                return true;
+        }
+        const bodyTail = (await page.locator("main").innerText().catch(() => "")).slice(-3_000);
+        return /(Creating image|Generating image|正在创建|正在生成)/i.test(bodyTail);
+    }
+    async clickStopGeneration(page) {
+        for (const selector of STOP_SELECTORS) {
+            const button = page.locator(selector).first();
+            if (await button.isVisible().catch(() => false) &&
+                await button.isEnabled().catch(() => false)) {
+                await button.click();
+                return true;
+            }
+        }
+        return false;
+    }
+    async waitUntilGenerationStops(page, timeoutMs = 10_000) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            if (!(await this.generationStillRunning(page)))
+                return true;
+            await sleep(250);
+        }
+        return !(await this.generationStillRunning(page));
+    }
+    async stopCurrentGeneration() {
+        if (!this.browserManager.stopToolEnabled) {
+            throw new Error("stop_current_generation 默认禁用。请设置 IMAGE_BROWSER_ENABLE_STOP_TOOL=true 并重新加载MCP。");
+        }
+        const release = await this.browserManager.acquireJobLock(this.agentId);
+        try {
+            const browserStatus = await this.browserManager.status();
+            if (!browserStatus.running) {
+                return {
+                    stopped: false,
+                    stillRunning: false,
+                    message: "专用浏览器当前未运行，没有需要停止的生成任务。",
+                };
+            }
+            const { page } = await this.browserManager.connect({ agentId: this.agentId });
+            const wasRunning = await this.generationStillRunning(page);
+            if (!wasRunning) {
+                return {
+                    stopped: false,
+                    stillRunning: false,
+                    message: "当前页面没有检测到正在运行的图片生成任务。",
+                    pageState: await this.inspectPage(page),
+                };
+            }
+            const stopped = await this.clickStopGeneration(page);
+            const stoppedCompletely = stopped
+                ? await this.waitUntilGenerationStops(page)
+                : false;
+            return {
+                stopped,
+                stillRunning: !stoppedCompletely,
+                message: stopped
+                    ? stoppedCompletely
+                        ? "已点击停止，当前生成任务已结束。不会自动重新发送。"
+                        : "已点击停止，但页面仍显示生成中，请人工检查。"
+                    : "检测到生成状态，但没有找到可点击的停止按钮，请人工检查页面。",
+                pageState: await this.inspectPage(page),
+            };
+        }
+        finally {
+            release();
+        }
+    }
+    async waitForNewImage(page, baselineSources, baselineAssistantMessageCount, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        let stableSource = "";
+        let stableSince = 0;
+        while (Date.now() < deadline) {
+            const candidates = await this.collectImageCandidates(page).catch(() => []);
+            const newest = [...candidates].reverse().find((candidate) => !baselineSources.has(candidate.src));
+            if (newest) {
+                if (newest.src !== stableSource) {
+                    stableSource = newest.src;
+                    stableSince = Date.now();
+                }
+                const running = await this.generationStillRunning(page);
+                if (!running && Date.now() - stableSince >= 4_000) {
+                    return { candidate: newest, outcome: "completed", autoStopped: false };
+                }
+            }
+            const assistantMessages = await page
+                .locator("[data-message-author-role='assistant']")
+                .allInnerTexts()
+                .catch(() => []);
+            if (newAssistantMessagesContainError(assistantMessages, baselineAssistantMessageCount)) {
+                return { outcome: "generation_error", autoStopped: false };
+            }
+            await sleep(2_000);
+        }
+        let autoStopped = false;
+        if (this.browserManager.stopOnTimeout && await this.generationStillRunning(page)) {
+            autoStopped = await this.clickStopGeneration(page);
+            if (autoStopped)
+                await this.waitUntilGenerationStops(page);
+            const candidates = await this.collectImageCandidates(page).catch(() => []);
+            const newest = [...candidates].reverse().find((candidate) => !baselineSources.has(candidate.src));
+            if (newest) {
+                return { candidate: newest, outcome: "stopped_with_image", autoStopped: true };
+            }
+        }
+        return { outcome: "timeout", autoStopped };
+    }
+    validatedImageBytes(bytes, method) {
+        const contentType = detectImageContentType(bytes);
+        return contentType ? { bytes, contentType, method } : undefined;
+    }
+    async fetchImageBytes(context, page, candidate) {
+        if (candidate.src.startsWith("data:")) {
+            const commaIndex = candidate.src.indexOf(",");
+            if (commaIndex > 0) {
+                const metadata = candidate.src.slice(5, commaIndex);
+                const payload = candidate.src.slice(commaIndex + 1);
+                try {
+                    const bytes = /(?:^|;)base64(?:;|$)/i.test(metadata)
+                        ? Buffer.from(payload, "base64")
+                        : Buffer.from(decodeURIComponent(payload), "utf8");
+                    const validated = this.validatedImageBytes(bytes, "page-fetch");
+                    if (validated)
+                        return validated;
+                }
+                catch {
+                    // Fall through to browser fetch or element screenshot.
+                }
+            }
+        }
+        if (/^https?:/i.test(candidate.src)) {
+            const response = await context.request
+                .get(candidate.src, { headers: { referer: page.url() }, timeout: 60_000 })
+                .catch(() => undefined);
+            if (response?.ok()) {
+                const validated = this.validatedImageBytes(await response.body(), "http");
+                if (validated)
+                    return validated;
+            }
+        }
+        const fetched = await page
+            .evaluate(async (sourceUrl) => {
+            const response = await fetch(sourceUrl, { credentials: "include" });
+            if (!response.ok)
+                throw new Error(`HTTP ${response.status}`);
+            const blob = await response.blob();
+            const dataUrl = await new Promise((resolve, reject) => {
+                const reader = new FileReader();
+                reader.onload = () => resolve(String(reader.result));
+                reader.onerror = () => reject(reader.error);
+                reader.readAsDataURL(blob);
+            });
+            return dataUrl;
+        }, candidate.src)
+            .catch(() => undefined);
+        if (fetched) {
+            const bytes = Buffer.from(fetched.split(",", 2)[1] || "", "base64");
+            const validated = this.validatedImageBytes(bytes, "page-fetch");
+            if (validated)
+                return validated;
+        }
+        const currentIndex = await page.locator("main img").evaluateAll((images, sourceUrl) => images.findIndex((element) => {
+            const image = element;
+            return (image.currentSrc || image.src) === sourceUrl;
+        }), candidate.src).catch(() => -1);
+        const image = page.locator("main img").nth(currentIndex >= 0 ? currentIndex : candidate.index);
+        const screenshot = await image.screenshot({ type: "png" });
+        const validated = this.validatedImageBytes(screenshot, "element-screenshot");
+        if (!validated)
+            throw new Error("下载结果不是可识别的图片格式");
+        return validated;
+    }
+    async saveCandidate(context, page, candidate, outputDir, fileStem) {
+        const downloaded = await this.fetchImageBytes(context, page, candidate);
+        const extension = imageExtension(downloaded.contentType, candidate.src);
+        const outputPath = path.join(outputDir, `${safeFileStem(fileStem)}${extension}`);
+        fs.writeFileSync(outputPath, downloaded.bytes, { flag: "wx", mode: 0o600 });
+        return {
+            path: outputPath,
+            method: downloaded.method,
+            sourceUrl: candidate.src,
+            contentType: downloaded.contentType,
+            width: candidate.width,
+            height: candidate.height,
+        };
+    }
+    async submitPreparedJobUnlocked(args) {
+        try {
+            let prepared = this.readPreparedJob();
+            if (args.expectedJobId && prepared.jobId !== args.expectedJobId) {
+                throw new Error("准备任务在发送前被另一个会话替换。为避免发送错误提示词，本次任务已停止。");
+            }
+            this.assertJobCanBeSubmitted(prepared);
+            const outputDir = ensureDirectory(resolvePath(args.outputDir || prepared.outputDir));
+            if (outputDir !== prepared.outputDir || !prepared.reservationPath || !fs.existsSync(prepared.reservationPath)) {
+                const previousReservation = prepared;
+                const reserved = this.reserveOutputStem(outputDir, prepared.outputStem, prepared.jobId, outputDir === prepared.outputDir ? [prepared.screenshotPath] : []);
+                prepared = {
+                    ...prepared,
+                    outputDir,
+                    outputStem: reserved.outputStem,
+                    reservationPath: reserved.reservationPath,
+                };
+                this.writePreparedJob(prepared);
+                if (previousReservation.reservationPath !== reserved.reservationPath) {
+                    this.releaseOutputReservation(previousReservation);
+                }
+            }
+            const timeoutSeconds = Math.max(30, Math.min(args.timeoutSeconds ?? 480, 900));
+            const { context, page } = await this.browserManager.connect({ agentId: this.agentId });
+            const pageState = await this.inspectPage(page);
+            if (!pageState.composerReady) {
+                throw new Error("ChatGPT输入框不可用；请检查登录、安全验证或当前页面。不会启动第二个浏览器。");
+            }
+            const composer = await this.findComposer(page, 2_000);
+            if (!composer || (await this.composerText(composer)).trim() !== prepared.prompt.trim()) {
+                throw new Error("ChatGPT输入框内容与准备任务不一致。为避免发送错误提示词，本次任务已停止；请清除后重新准备。");
+            }
+            if (prepared.preparedAttachmentCount !== undefined) {
+                const currentAttachmentCount = await this.attachmentCount(page);
+                if (currentAttachmentCount !== prepared.preparedAttachmentCount) {
+                    throw new Error(`ChatGPT附件数量已变化（准备时${prepared.preparedAttachmentCount}，当前${currentAttachmentCount}）。为避免引用错误图片，本次任务已停止。`);
+                }
+            }
+            // Capture again immediately before sending, so uploaded reference previews are excluded.
+            const immediateBaseline = await this.collectImageCandidates(page);
+            const baselineAssistantMessageCount = await page
+                .locator("[data-message-author-role='assistant']")
+                .count();
+            const baseline = new Set([
+                ...prepared.baselineImageSources,
+                ...immediateBaseline.map((candidate) => candidate.src),
+            ]);
+            const submitting = {
+                ...prepared,
+                state: "submitting",
+                submittingAt: new Date().toISOString(),
+            };
+            this.writePreparedJob(submitting);
+            await this.clickSend(page);
+            const sent = {
+                ...submitting,
+                state: "sent",
+                sentAt: new Date().toISOString(),
+            };
+            this.writePreparedJob(sent);
+            const waitResult = await this.waitForNewImage(page, baseline, baselineAssistantMessageCount, timeoutSeconds * 1_000);
+            const candidate = waitResult.candidate;
+            const screenshotPath = path.join(outputDir, `${prepared.outputStem}-result.png`);
+            await this.savePageScreenshot(page, screenshotPath);
+            if (!candidate) {
+                const result = {
+                    agentId: this.agentId,
+                    status: "needs_human",
+                    jobId: prepared.jobId,
+                    outputStem: prepared.outputStem,
+                    outputDir,
+                    screenshotPath,
+                    waitOutcome: waitResult.outcome,
+                    autoStopped: waitResult.autoStopped,
+                    message: waitResult.autoStopped
+                        ? "等待超时后已自动点击停止，但没有检测到可保存的新图片。浏览器保持打开，请人工检查；系统不会自动重复发送。"
+                        : "没有可靠检测到新的生成图片。专用浏览器保持打开，请人工检查；系统不会自动重复发送以避免消耗额度。",
+                };
+                const needsHuman = {
+                    ...sent,
+                    state: "needs_human",
+                    needsHumanAt: new Date().toISOString(),
+                };
+                this.writePreparedJob(needsHuman);
+                const finalizedNeedsHuman = { ...needsHuman, reservationPath: undefined };
+                atomicWriteJson(path.join(outputDir, `${prepared.outputStem}.json`), {
+                    ...finalizedNeedsHuman,
+                    ...result,
+                });
+                this.releaseOutputReservation(needsHuman);
+                this.writePreparedJob(finalizedNeedsHuman);
+                return result;
+            }
+            const image = await this.saveCandidate(context, page, candidate, outputDir, `${prepared.outputStem}-image`);
+            const result = {
+                agentId: this.agentId,
+                status: "completed",
+                jobId: prepared.jobId,
+                outputStem: prepared.outputStem,
+                outputDir,
+                image,
+                screenshotPath,
+                waitOutcome: waitResult.outcome,
+                autoStopped: waitResult.autoStopped,
+                message: waitResult.outcome === "stopped_with_image"
+                    ? "等待超时后已自动停止生成，并保存停止前已出现的图片。请检查图片是否完整。"
+                    : "图片已生成并保存。请根据当前项目要求继续处理或质检。",
+            };
+            const completed = {
+                ...sent,
+                state: "completed",
+                completedAt: new Date().toISOString(),
+            };
+            this.writePreparedJob(completed);
+            atomicWriteJson(path.join(outputDir, `${prepared.outputStem}.json`), {
+                ...completed,
+                reservationPath: undefined,
+                ...result,
+            });
+            this.releaseOutputReservation(completed);
+            fs.rmSync(this.preparedJobPath(), { force: true });
+            return result;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                throw new Error("没有待发送任务。请先调用 prepare_image_job。");
+            }
+            throw error;
+        }
+    }
+    async submitPreparedJob(args) {
+        const release = await this.browserManager.acquireJobLock(this.agentId);
+        let completed = false;
+        try {
+            const result = await this.submitPreparedJobUnlocked(args);
+            completed = result.status === "completed";
+            return result;
+        }
+        finally {
+            release();
+            if (completed)
+                await this.autoCloseBrowserAfterSuccess();
+        }
+    }
+    async clearPreparedJobUnlocked() {
+        const { page } = await this.browserManager.connect({ agentId: this.agentId });
+        const cleared = await this.clearComposerContents(page);
+        const prepared = readJsonFile(this.preparedJobPath());
+        if (prepared)
+            this.releaseOutputReservation(prepared);
+        fs.rmSync(this.preparedJobPath(), { force: true });
+        return cleared;
+    }
+    async clearPreparedJob() {
+        const release = await this.browserManager.acquireJobLock(this.agentId);
+        let cleared = false;
+        try {
+            const result = await this.clearPreparedJobUnlocked();
+            cleared = true;
+            return result;
+        }
+        finally {
+            release();
+            if (cleared)
+                await this.autoCloseBrowserAfterSuccess();
+        }
+    }
+    async runJob(args) {
+        const release = await this.browserManager.acquireJobLock(this.agentId);
+        let completed = false;
+        try {
+            const { prepared } = await this.prepareJobUnlocked(args);
+            const result = await this.submitPreparedJobUnlocked({
+                timeoutSeconds: args.timeoutSeconds,
+                outputDir: args.outputDir,
+                expectedJobId: prepared.jobId,
+            });
+            completed = result.status === "completed";
+            return result;
+        }
+        finally {
+            release();
+            if (completed)
+                await this.autoCloseBrowserAfterSuccess();
+        }
+    }
+    async runBatchJobs(args) {
+        const release = await this.browserManager.acquireJobLock(this.agentId);
+        let batchReservation;
+        let batchReservationJobId = "";
+        let completedSuccessfully = false;
+        try {
+            if (args.jobs.length === 0)
+                throw new Error("批量任务不能为空");
+            if (args.jobs.length > 12)
+                throw new Error("单批最多12张图片，请拆成多个批次");
+            const outputDir = ensureDirectory(resolvePath(args.outputDir || DEFAULT_OUTPUT_DIR));
+            const timeoutSeconds = Math.max(30, Math.min(args.timeoutSeconds ?? 480, 900));
+            const delaySeconds = Math.max(0, Math.min(args.delaySeconds ?? 3, 30));
+            const stopOnFailure = args.stopOnFailure ?? true;
+            const requestedBatchId = safeFileStem(makeJobId(`batch:${this.agentId}:${args.jobs.map((job) => job.prompt).join("\n")}`));
+            batchReservationJobId = `batch-manifest:${requestedBatchId}`;
+            batchReservation = this.reserveOutputStem(outputDir, requestedBatchId, batchReservationJobId);
+            const batchId = batchReservation.outputStem;
+            const manifestPath = path.join(outputDir, `${batchId}-batch.json`);
+            const results = [];
+            const writeManifest = (status) => {
+                atomicWriteJson(manifestPath, {
+                    agentId: this.agentId,
+                    batchId,
+                    status,
+                    total: args.jobs.length,
+                    completed: results.filter((item) => item.status === "completed").length,
+                    outputDir,
+                    manifestPath,
+                    results,
+                    updatedAt: new Date().toISOString(),
+                });
+            };
+            writeManifest("running");
+            for (const [index, job] of args.jobs.entries()) {
+                const ordinal = String(index + 1).padStart(2, "0");
+                const outputStem = safeFileStem(job.outputStem || `${batchId}-${ordinal}`);
+                try {
+                    const { prepared } = await this.prepareJobUnlocked({
+                        prompt: job.prompt,
+                        referenceImages: job.referenceImages,
+                        outputDir,
+                        outputStem,
+                    });
+                    const submitted = await this.submitPreparedJobUnlocked({
+                        timeoutSeconds,
+                        outputDir,
+                        expectedJobId: prepared.jobId,
+                    });
+                    const itemStatus = submitted.status === "completed" ? "completed" : "needs_human";
+                    results.push({ index, status: itemStatus, job: submitted });
+                    writeManifest("running");
+                    if (itemStatus !== "completed" && stopOnFailure)
+                        break;
+                }
+                catch (error) {
+                    results.push({
+                        index,
+                        status: "failed",
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                    writeManifest("running");
+                    if (stopOnFailure)
+                        break;
+                    await this.clearPreparedJobUnlocked().catch(() => undefined);
+                }
+                if (index < args.jobs.length - 1 && delaySeconds > 0) {
+                    await sleep(delaySeconds * 1_000);
+                }
+            }
+            const completed = results.filter((item) => item.status === "completed").length;
+            const status = completed === args.jobs.length
+                ? "completed"
+                : completed > 0
+                    ? "partial"
+                    : "failed";
+            const result = {
+                agentId: this.agentId,
+                batchId,
+                status,
+                total: args.jobs.length,
+                completed,
+                outputDir,
+                manifestPath,
+                results,
+            };
+            atomicWriteJson(manifestPath, { ...result, updatedAt: new Date().toISOString() });
+            completedSuccessfully = result.status === "completed";
+            return result;
+        }
+        finally {
+            if (batchReservation) {
+                this.releaseOutputReservation({
+                    agentId: this.agentId,
+                    jobId: batchReservationJobId,
+                    reservationPath: batchReservation.reservationPath,
+                });
+            }
+            release();
+            if (completedSuccessfully)
+                await this.autoCloseBrowserAfterSuccess();
+        }
+    }
+    async downloadLatest(args) {
+        const release = await this.browserManager.acquireJobLock(this.agentId);
+        let downloaded = false;
+        try {
+            const outputDir = ensureDirectory(resolvePath(args.outputDir || DEFAULT_OUTPUT_DIR));
+            const { context, page } = await this.browserManager.connect({ agentId: this.agentId });
+            const candidates = await this.collectImageCandidates(page);
+            const candidate = candidates.at(-1);
+            if (!candidate)
+                throw new Error("当前ChatGPT会话中没有检测到可下载的生成图片");
+            const jobId = makeJobId(`manual-download:${this.agentId}`);
+            const reserved = this.reserveOutputStem(outputDir, args.fileStem || `${jobId}-image`, jobId);
+            try {
+                const result = await this.saveCandidate(context, page, candidate, outputDir, reserved.outputStem);
+                downloaded = true;
+                return result;
+            }
+            finally {
+                this.releaseOutputReservation({
+                    agentId: this.agentId,
+                    jobId,
+                    reservationPath: reserved.reservationPath,
+                });
+            }
+        }
+        finally {
+            release();
+            if (downloaded)
+                await this.autoCloseBrowserAfterSuccess();
+        }
+    }
+}
+//# sourceMappingURL=chatgpt-automation.js.map