@isen/chatgpt-image-web-mcp 0.3.0

package/dist/browser-manager.js

@@ -0,0 +1,710 @@
+import crypto from "node:crypto";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { chromium } from "playwright-core";
+import { atomicWriteJson, ensureDirectory, processIsAlive, readJsonFile, resolvePath, sleep, } from "./utils.js";
+const CHATGPT_URL = process.env.IMAGE_BROWSER_START_URL || "https://chatgpt.com/";
+const AGENT_TAB_PREFIX = "chatgpt-image-web-mcp-agent:";
+function defaultStateDirectory() {
+    if (process.env.IMAGE_BROWSER_HOME)
+        return resolvePath(process.env.IMAGE_BROWSER_HOME);
+    if (process.platform === "darwin") {
+        return path.join(os.homedir(), "Library", "Application Support", "ChatGPTImageWebMCP");
+    }
+    if (process.platform === "win32") {
+        return path.join(process.env.LOCALAPPDATA || os.homedir(), "ChatGPTImageWebMCP");
+    }
+    return path.join(os.homedir(), ".local", "share", "chatgpt-image-web-mcp");
+}
+function boundedParallelism() {
+    const parsed = Number(process.env.IMAGE_BROWSER_MAX_PARALLEL_TABS || "3");
+    if (!Number.isFinite(parsed))
+        return 3;
+    return Math.max(1, Math.min(Math.trunc(parsed), 8));
+}
+function useHeadlessAutomation() {
+    return !/^(0|false|no|off)$/i.test(process.env.IMAGE_BROWSER_HEADLESS || "true");
+}
+function environmentFlag(name, defaultValue = false) {
+    const fallback = defaultValue ? "true" : "false";
+    return /^(1|true|yes|on)$/i.test(process.env[name] || fallback);
+}
+export class BrowserManager {
+    connectedBrowser;
+    connectedContext;
+    connectedMetadata;
+    stateDir;
+    profileDir;
+    metadataPath;
+    loginMetadataPath;
+    activePortPath;
+    launchLockPath;
+    tabLockPath;
+    jobAdmissionLockPath;
+    maintenanceLockPath;
+    legacyJobLockPath;
+    jobLocksDir;
+    slotLocksDir;
+    maxParallelTabs;
+    autoCloseAfterSuccess;
+    stopToolEnabled;
+    stopOnTimeout;
+    constructor(stateDir = defaultStateDirectory()) {
+        this.stateDir = ensureDirectory(stateDir);
+        this.profileDir = ensureDirectory(path.join(this.stateDir, "chrome-profile"));
+        this.metadataPath = path.join(this.stateDir, "browser.json");
+        this.loginMetadataPath = path.join(this.stateDir, "login-browser.json");
+        this.activePortPath = path.join(this.profileDir, "DevToolsActivePort");
+        this.launchLockPath = path.join(this.stateDir, "launch.lock");
+        this.tabLockPath = path.join(this.stateDir, "tab-assignment.lock");
+        this.jobAdmissionLockPath = path.join(this.stateDir, "job-admission.lock");
+        this.maintenanceLockPath = path.join(this.stateDir, "maintenance.lock");
+        this.legacyJobLockPath = path.join(this.stateDir, "job.lock");
+        this.jobLocksDir = ensureDirectory(path.join(this.stateDir, "agent-job-locks"));
+        this.slotLocksDir = ensureDirectory(path.join(this.stateDir, "parallel-slots"));
+        this.maxParallelTabs = boundedParallelism();
+        this.autoCloseAfterSuccess = environmentFlag("IMAGE_BROWSER_AUTO_CLOSE");
+        this.stopToolEnabled = environmentFlag("IMAGE_BROWSER_ENABLE_STOP_TOOL");
+        this.stopOnTimeout = environmentFlag("IMAGE_BROWSER_STOP_ON_TIMEOUT");
+        // Remove the legacy global lock only when no live owner remains.
+        const legacyOwner = readJsonFile(path.join(this.legacyJobLockPath, "owner.json"));
+        if (fs.existsSync(this.legacyJobLockPath) && !processIsAlive(legacyOwner?.pid)) {
+            fs.rmSync(this.legacyJobLockPath, { recursive: true, force: true });
+        }
+    }
+    agentKey(agentId) {
+        return crypto.createHash("sha256").update(agentId).digest("hex").slice(0, 20);
+    }
+    tabName(agentId) {
+        return `${AGENT_TAB_PREFIX}${this.agentKey(agentId)}`;
+    }
+    findExecutable() {
+        const configured = process.env.IMAGE_BROWSER_EXECUTABLE;
+        const candidates = [
+            configured,
+            process.platform === "darwin"
+                ? "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+                : undefined,
+            process.platform === "darwin"
+                ? path.join(os.homedir(), "Applications", "Google Chrome.app", "Contents", "MacOS", "Google Chrome")
+                : undefined,
+            process.platform === "darwin"
+                ? "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
+                : undefined,
+            process.platform === "win32"
+                ? path.join(process.env.PROGRAMFILES || "C:\\Program Files", "Google", "Chrome", "Application", "chrome.exe")
+                : undefined,
+            process.platform === "win32"
+                ? path.join(process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)", "Google", "Chrome", "Application", "chrome.exe")
+                : undefined,
+            process.platform === "linux" ? "/usr/bin/google-chrome" : undefined,
+            process.platform === "linux" ? "/usr/bin/google-chrome-stable" : undefined,
+            process.platform === "linux" ? "/usr/bin/chromium" : undefined,
+            process.platform === "linux" ? "/usr/bin/chromium-browser" : undefined,
+        ].filter((item) => Boolean(item));
+        const executable = candidates.find((item) => fs.existsSync(item));
+        if (!executable) {
+            throw new Error("找不到 Chrome/Brave。请安装 Google Chrome，或设置 IMAGE_BROWSER_EXECUTABLE 为浏览器可执行文件路径。");
+        }
+        return executable;
+    }
+    readMetadata() {
+        return readJsonFile(this.metadataPath);
+    }
+    readLoginMetadata() {
+        return readJsonFile(this.loginMetadataPath);
+    }
+    readActivePort() {
+        try {
+            const firstLine = fs.readFileSync(this.activePortPath, "utf8").split(/\r?\n/, 1)[0];
+            const port = Number(firstLine);
+            return Number.isInteger(port) && port > 0 ? port : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async endpointIsHealthy(port) {
+        try {
+            const response = await fetch(`http://127.0.0.1:${port}/json/version`, {
+                signal: AbortSignal.timeout(1_500),
+            });
+            if (!response.ok)
+                return false;
+            const payload = (await response.json());
+            return Boolean(payload.webSocketDebuggerUrl);
+        }
+        catch {
+            return false;
+        }
+    }
+    lockOwner(lockPath) {
+        return readJsonFile(path.join(lockPath, "owner.json"));
+    }
+    removeStaleLock(lockPath, minimumAgeMs = 5_000) {
+        if (!fs.existsSync(lockPath))
+            return false;
+        const owner = this.lockOwner(lockPath);
+        const stat = fs.statSync(lockPath);
+        if (!processIsAlive(owner?.pid) && Date.now() - stat.mtimeMs >= minimumAgeMs) {
+            fs.rmSync(lockPath, { recursive: true, force: true });
+            return true;
+        }
+        return false;
+    }
+    activeJobOwners() {
+        const owners = [];
+        if (fs.existsSync(this.legacyJobLockPath)) {
+            const legacy = readJsonFile(path.join(this.legacyJobLockPath, "owner.json"));
+            if (!processIsAlive(legacy?.pid)) {
+                fs.rmSync(this.legacyJobLockPath, { recursive: true, force: true });
+            }
+            else if (legacy?.pid) {
+                owners.push({
+                    pid: legacy.pid,
+                    agentId: "legacy-v0.2-global-lock",
+                    startedAt: legacy.startedAt || "unknown",
+                });
+            }
+        }
+        for (const entry of fs.readdirSync(this.jobLocksDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const lockPath = path.join(this.jobLocksDir, entry.name);
+            if (this.removeStaleLock(lockPath))
+                continue;
+            const owner = this.lockOwner(lockPath);
+            if (owner && processIsAlive(owner.pid))
+                owners.push(owner);
+        }
+        return owners;
+    }
+    assertNoActiveJobs(action) {
+        const active = this.activeJobOwners();
+        if (active.length > 0) {
+            throw new Error(`${action}被拒绝：仍有${active.length}个Agent任务运行中（${active.map((item) => item.agentId).join(", ")}）。`);
+        }
+    }
+    async status() {
+        const metadata = this.readMetadata();
+        const loginBrowser = this.readLoginMetadata();
+        const loginModeActive = processIsAlive(loginBrowser?.pid);
+        const activeJobs = this.activeJobOwners().map(({ agentId, pid, startedAt }) => ({ agentId, pid, startedAt }));
+        const port = metadata?.port || this.readActivePort();
+        if (!port) {
+            return {
+                running: false,
+                loginModeActive,
+                loginBrowser: loginModeActive ? loginBrowser : undefined,
+                maxParallelTabs: this.maxParallelTabs,
+                autoCloseAfterSuccess: this.autoCloseAfterSuccess,
+                stopToolEnabled: this.stopToolEnabled,
+                stopOnTimeout: this.stopOnTimeout,
+                activeJobs,
+                profileDir: this.profileDir,
+                stateDir: this.stateDir,
+                reason: loginModeActive
+                    ? "专用浏览器正处于人工登录模式（无自动化调试端口）"
+                    : "未找到专用浏览器调试端口",
+            };
+        }
+        const healthy = await this.endpointIsHealthy(port);
+        return {
+            running: healthy,
+            endpoint: healthy ? `http://127.0.0.1:${port}` : undefined,
+            metadata,
+            loginModeActive,
+            loginBrowser: loginModeActive ? loginBrowser : undefined,
+            maxParallelTabs: this.maxParallelTabs,
+            autoCloseAfterSuccess: this.autoCloseAfterSuccess,
+            stopToolEnabled: this.stopToolEnabled,
+            stopOnTimeout: this.stopOnTimeout,
+            activeJobs,
+            profileDir: this.profileDir,
+            stateDir: this.stateDir,
+            reason: healthy ? undefined : "专用浏览器进程不存在或调试端口不可访问",
+        };
+    }
+    async withDirectoryLock(lockPath, timeoutMs, callback) {
+        const deadline = Date.now() + timeoutMs;
+        while (true) {
+            try {
+                fs.mkdirSync(lockPath, { mode: 0o700 });
+                fs.writeFileSync(path.join(lockPath, "owner.json"), JSON.stringify({ pid: process.pid, agentId: "system", startedAt: new Date().toISOString() }), { mode: 0o600 });
+                break;
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+                if (this.removeStaleLock(lockPath))
+                    continue;
+                if (Date.now() >= deadline)
+                    throw new Error(`等待锁超时：${path.basename(lockPath)}`);
+                await sleep(150);
+            }
+        }
+        try {
+            return await callback();
+        }
+        finally {
+            fs.rmSync(lockPath, { recursive: true, force: true });
+        }
+    }
+    async withLaunchLock(callback) {
+        return this.withDirectoryLock(this.launchLockPath, 15_000, callback);
+    }
+    async withJobAdmissionLock(callback) {
+        return this.withDirectoryLock(this.jobAdmissionLockPath, 15_000, callback);
+    }
+    async beginExclusiveMaintenance(action) {
+        return this.withJobAdmissionLock(async () => {
+            if (fs.existsSync(this.maintenanceLockPath)) {
+                if (!this.removeStaleLock(this.maintenanceLockPath)) {
+                    const owner = this.lockOwner(this.maintenanceLockPath);
+                    throw new Error(`浏览器正在进行维护操作（${owner?.action || "unknown"}，owner pid: ${owner?.pid ?? "unknown"}）。`);
+                }
+            }
+            fs.mkdirSync(this.maintenanceLockPath, { mode: 0o700 });
+            try {
+                atomicWriteJson(path.join(this.maintenanceLockPath, "owner.json"), {
+                    pid: process.pid,
+                    agentId: "system",
+                    action,
+                    startedAt: new Date().toISOString(),
+                });
+                this.assertNoActiveJobs(action);
+            }
+            catch (error) {
+                fs.rmSync(this.maintenanceLockPath, { recursive: true, force: true });
+                throw error;
+            }
+            let finished = false;
+            return () => {
+                if (finished)
+                    return;
+                finished = true;
+                fs.rmSync(this.maintenanceLockPath, { recursive: true, force: true });
+            };
+        });
+    }
+    async withExclusiveMaintenance(action, callback) {
+        return this.withLaunchLock(async () => {
+            const finishMaintenance = await this.beginExclusiveMaintenance(action);
+            try {
+                return await callback();
+            }
+            finally {
+                finishMaintenance();
+            }
+        });
+    }
+    async ensureRunning() {
+        return this.withLaunchLock(async () => {
+            const current = await this.status();
+            if (current.loginModeActive) {
+                throw new Error("专用浏览器正在人工登录模式。请完成登录后调用 switch_to_automation_browser；系统不会同时打开第二个浏览器。");
+            }
+            fs.rmSync(this.loginMetadataPath, { force: true });
+            const desiredHeadless = useHeadlessAutomation();
+            if (current.running && current.metadata?.headless === desiredHeadless)
+                return current.metadata;
+            if (current.running && !current.metadata) {
+                throw new Error("检测到正在运行的专用浏览器，但其PID元数据缺失。为避免打开第二个浏览器，请先手动关闭该专用窗口。");
+            }
+            const previous = this.readMetadata();
+            const previousIsAlive = Boolean(previous && processIsAlive(previous.pid));
+            const maintenanceAction = current.running
+                ? desiredHeadless
+                    ? "切换无窗口后台模式"
+                    : "切换可见浏览器模式"
+                : previousIsAlive
+                    ? "重启无法连接的专用浏览器"
+                    : undefined;
+            const finishMaintenance = maintenanceAction
+                ? await this.beginExclusiveMaintenance(maintenanceAction)
+                : undefined;
+            try {
+                if (previous && previousIsAlive) {
+                    try {
+                        process.kill(previous.pid, "SIGTERM");
+                    }
+                    catch {
+                        // Process may have exited between checks.
+                    }
+                    const stopDeadline = Date.now() + 8_000;
+                    while (processIsAlive(previous.pid) && Date.now() < stopDeadline)
+                        await sleep(200);
+                    if (processIsAlive(previous.pid)) {
+                        throw new Error("旧的专用浏览器仍在运行但无法连接；请手动关闭后重试。不会再启动第二个浏览器。");
+                    }
+                }
+                fs.rmSync(this.activePortPath, { force: true });
+                const executable = this.findExecutable();
+                const headless = useHeadlessAutomation();
+                const browserArgs = [
+                    "--remote-debugging-address=127.0.0.1",
+                    "--remote-debugging-port=0",
+                    `--user-data-dir=${this.profileDir}`,
+                    "--profile-directory=Default",
+                    "--no-first-run",
+                    "--no-default-browser-check",
+                    "--disable-background-mode",
+                    "--disable-session-crashed-bubble",
+                    "--disable-background-timer-throttling",
+                    "--disable-backgrounding-occluded-windows",
+                    "--disable-renderer-backgrounding",
+                    "--window-size=1280,960",
+                ];
+                if (headless)
+                    browserArgs.push("--headless=new");
+                else
+                    browserArgs.push("--start-minimized", "--new-window");
+                browserArgs.push(CHATGPT_URL);
+                const child = spawn(executable, browserArgs, { detached: true, stdio: "ignore" });
+                child.unref();
+                if (!child.pid)
+                    throw new Error("无法启动专用浏览器进程");
+                const deadline = Date.now() + 30_000;
+                let port;
+                while (Date.now() < deadline) {
+                    port = this.readActivePort();
+                    if (port && (await this.endpointIsHealthy(port)))
+                        break;
+                    if (!processIsAlive(child.pid))
+                        break;
+                    await sleep(250);
+                }
+                if (!port || !(await this.endpointIsHealthy(port))) {
+                    throw new Error("专用浏览器启动失败：30秒内没有可用的调试端口");
+                }
+                const metadata = {
+                    pid: child.pid,
+                    port,
+                    headless,
+                    executable,
+                    profileDir: this.profileDir,
+                    launchedAt: new Date().toISOString(),
+                };
+                atomicWriteJson(this.metadataPath, metadata);
+                return metadata;
+            }
+            finally {
+                finishMaintenance?.();
+            }
+        });
+    }
+    async openLoginBrowser() {
+        return this.withExclusiveMaintenance("切换人工登录模式", async () => {
+            const existingLogin = this.readLoginMetadata();
+            if (existingLogin && processIsAlive(existingLogin.pid))
+                return existingLogin;
+            fs.rmSync(this.loginMetadataPath, { force: true });
+            const automated = this.readMetadata();
+            if (automated && processIsAlive(automated.pid)) {
+                try {
+                    process.kill(automated.pid, "SIGTERM");
+                }
+                catch {
+                    // Process may have exited between checks.
+                }
+                const deadline = Date.now() + 10_000;
+                while (processIsAlive(automated.pid) && Date.now() < deadline)
+                    await sleep(200);
+                if (processIsAlive(automated.pid)) {
+                    throw new Error("无法关闭自动化浏览器，因此不会再打开人工登录浏览器。请手动关闭专用窗口后重试。");
+                }
+            }
+            this.connectedBrowser = undefined;
+            this.connectedContext = undefined;
+            this.connectedMetadata = undefined;
+            fs.rmSync(this.metadataPath, { force: true });
+            fs.rmSync(this.activePortPath, { force: true });
+            await sleep(1_000);
+            const executable = this.findExecutable();
+            const child = spawn(executable, [
+                `--user-data-dir=${this.profileDir}`,
+                "--profile-directory=Default",
+                "--no-first-run",
+                "--no-default-browser-check",
+                "--new-window",
+                CHATGPT_URL,
+            ], { detached: true, stdio: "ignore" });
+            child.unref();
+            if (!child.pid)
+                throw new Error("无法启动人工登录浏览器");
+            await sleep(2_000);
+            if (!processIsAlive(child.pid)) {
+                throw new Error("人工登录浏览器启动后立即退出。请确认没有其他进程占用专用Profile。");
+            }
+            const loginMetadata = {
+                pid: child.pid,
+                executable,
+                profileDir: this.profileDir,
+                launchedAt: new Date().toISOString(),
+            };
+            atomicWriteJson(this.loginMetadataPath, loginMetadata);
+            return loginMetadata;
+        });
+    }
+    async switchToAutomationBrowser(agentId = "default") {
+        await this.withExclusiveMaintenance("切换自动化模式", async () => {
+            const login = this.readLoginMetadata();
+            if (login && processIsAlive(login.pid)) {
+                try {
+                    process.kill(login.pid, "SIGTERM");
+                }
+                catch {
+                    // Process may have exited between checks.
+                }
+                const deadline = Date.now() + 12_000;
+                while (processIsAlive(login.pid) && Date.now() < deadline)
+                    await sleep(200);
+                if (processIsAlive(login.pid)) {
+                    throw new Error("人工登录浏览器未能关闭。为避免第二个浏览器，请手动关闭该窗口后重试。");
+                }
+            }
+            fs.rmSync(this.loginMetadataPath, { force: true });
+            await sleep(1_000);
+        });
+        const release = await this.acquireJobLock(agentId);
+        try {
+            return await this.connect({ agentId, bringToFront: false });
+        }
+        finally {
+            release();
+        }
+    }
+    async browserConnection(metadata) {
+        let browser = this.connectedBrowser;
+        let context = this.connectedContext;
+        if (!browser ||
+            !browser.isConnected() ||
+            !context ||
+            this.connectedMetadata?.port !== metadata.port) {
+            browser = await chromium.connectOverCDP(`http://127.0.0.1:${metadata.port}`, { timeout: 15_000 });
+            context = browser.contexts()[0];
+            if (!context)
+                throw new Error("专用浏览器没有可连接的默认上下文");
+            this.connectedBrowser = browser;
+            this.connectedContext = context;
+            this.connectedMetadata = metadata;
+            browser.on("disconnected", () => {
+                if (this.connectedBrowser === browser) {
+                    this.connectedBrowser = undefined;
+                    this.connectedContext = undefined;
+                    this.connectedMetadata = undefined;
+                }
+            });
+        }
+        return { browser, context };
+    }
+    async readPageName(page) {
+        return page.evaluate(() => window.name).catch(() => "");
+    }
+    isChatGptPage(page) {
+        try {
+            return new URL(page.url()).hostname.endsWith("chatgpt.com");
+        }
+        catch {
+            return false;
+        }
+    }
+    async createBackgroundPage(browser, context) {
+        const existing = new Set(context.pages());
+        try {
+            const session = await browser.newBrowserCDPSession();
+            try {
+                await session.send("Target.createTarget", { url: "about:blank", background: true });
+                const deadline = Date.now() + 10_000;
+                while (Date.now() < deadline) {
+                    const created = context.pages().find((page) => !existing.has(page));
+                    if (created)
+                        return created;
+                    await sleep(100);
+                }
+            }
+            finally {
+                await session.detach().catch(() => undefined);
+            }
+        }
+        catch {
+            // Older Chromium variants may not support browser-level CDP sessions.
+        }
+        return context.newPage();
+    }
+    async pageForAgent(browser, context, agentId, navigateToChatGpt) {
+        return this.withDirectoryLock(this.tabLockPath, 30_000, async () => {
+            const tabName = this.tabName(agentId);
+            const pages = context.pages();
+            for (const candidate of pages) {
+                if ((await this.readPageName(candidate)) === tabName)
+                    return { page: candidate, tabName };
+            }
+            let page;
+            for (const candidate of pages) {
+                const name = await this.readPageName(candidate);
+                if (this.isChatGptPage(candidate) && !name.startsWith(AGENT_TAB_PREFIX)) {
+                    page = candidate;
+                    break;
+                }
+            }
+            page ||= await this.createBackgroundPage(browser, context);
+            await page.evaluate((name) => { window.name = name; }, tabName);
+            if (navigateToChatGpt && !this.isChatGptPage(page)) {
+                await page.goto(CHATGPT_URL, { waitUntil: "domcontentloaded", timeout: 60_000 });
+                await page.evaluate((name) => { window.name = name; }, tabName);
+            }
+            return { page, tabName };
+        });
+    }
+    async connect(options = {}) {
+        const agentId = options.agentId || "default";
+        const metadata = await this.ensureRunning();
+        const { browser, context } = await this.browserConnection(metadata);
+        const { page, tabName } = await this.pageForAgent(browser, context, agentId, options.navigateToChatGpt !== false);
+        if (options.bringToFront)
+            await page.bringToFront();
+        return { browser, context, page, metadata, agentId, tabName };
+    }
+    async acquireJobLock(agentId = "default") {
+        return this.withJobAdmissionLock(async () => {
+            if (fs.existsSync(this.maintenanceLockPath)) {
+                if (!this.removeStaleLock(this.maintenanceLockPath)) {
+                    const owner = this.lockOwner(this.maintenanceLockPath);
+                    throw new Error(`浏览器正在进行维护操作（${owner?.action || "unknown"}），暂时不能开始Agent任务。`);
+                }
+            }
+            const legacy = this.activeJobOwners().find((owner) => owner.agentId === "legacy-v0.2-global-lock");
+            if (legacy) {
+                throw new Error(`检测到旧版本图片任务锁（pid: ${legacy.pid}）。请让所有已打开的Agent执行/reload，或等待旧任务结束后再使用多标签并行。`);
+            }
+            const agentKey = this.agentKey(agentId);
+            const agentLockPath = path.join(this.jobLocksDir, agentKey);
+            try {
+                fs.mkdirSync(agentLockPath, { mode: 0o700 });
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+                if (this.removeStaleLock(agentLockPath)) {
+                    fs.mkdirSync(agentLockPath, { mode: 0o700 });
+                }
+                else {
+                    const owner = this.lockOwner(agentLockPath);
+                    throw new Error(`Agent ${agentId} 已有任务运行中（owner pid: ${owner?.pid ?? "unknown"}）。`);
+                }
+            }
+            let slotPath;
+            let slotNumber;
+            for (let slot = 1; slot <= this.maxParallelTabs; slot += 1) {
+                const candidate = path.join(this.slotLocksDir, `slot-${slot}`);
+                this.removeStaleLock(candidate);
+                try {
+                    fs.mkdirSync(candidate, { mode: 0o700 });
+                    slotPath = candidate;
+                    slotNumber = slot;
+                    break;
+                }
+                catch (error) {
+                    if (error.code !== "EEXIST") {
+                        fs.rmSync(agentLockPath, { recursive: true, force: true });
+                        throw error;
+                    }
+                }
+            }
+            if (!slotPath || !slotNumber) {
+                fs.rmSync(agentLockPath, { recursive: true, force: true });
+                throw new Error(`已有${this.maxParallelTabs}个Agent并行生成，已达到安全上限。请稍后重试。`);
+            }
+            const owner = {
+                pid: process.pid,
+                agentId,
+                startedAt: new Date().toISOString(),
+                slot: slotNumber,
+            };
+            atomicWriteJson(path.join(agentLockPath, "owner.json"), owner);
+            atomicWriteJson(path.join(slotPath, "owner.json"), owner);
+            let released = false;
+            return () => {
+                if (released)
+                    return;
+                released = true;
+                fs.rmSync(slotPath, { recursive: true, force: true });
+                fs.rmSync(agentLockPath, { recursive: true, force: true });
+            };
+        });
+    }
+    async closeAgentTab(agentId) {
+        const release = await this.acquireJobLock(agentId);
+        try {
+            const status = await this.status();
+            if (!status.running)
+                return false;
+            if (!status.metadata) {
+                throw new Error("专用浏览器正在运行，但缺少连接元数据；为避免启动第二个浏览器，本次不会关闭标签页。");
+            }
+            const { context } = await this.browserConnection(status.metadata);
+            const expected = this.tabName(agentId);
+            for (const page of context.pages()) {
+                if ((await this.readPageName(page)) === expected) {
+                    await page.close();
+                    return true;
+                }
+            }
+            return false;
+        }
+        finally {
+            release();
+        }
+    }
+    hasPendingPreparedJobs() {
+        const directory = path.join(this.stateDir, "prepared-jobs");
+        if (!fs.existsSync(directory))
+            return false;
+        for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+            if (!entry.isFile() || !entry.name.endsWith(".json"))
+                continue;
+            const prepared = readJsonFile(path.join(directory, entry.name));
+            if (!prepared || prepared.state !== "completed")
+                return true;
+        }
+        return false;
+    }
+    async closeDedicatedBrowser(options = {}) {
+        return this.withExclusiveMaintenance("关闭专用浏览器", async () => {
+            if (options.preservePreparedJobs && this.hasPendingPreparedJobs())
+                return false;
+            const metadata = this.readMetadata();
+            const loginMetadata = this.readLoginMetadata();
+            const livePids = [metadata?.pid, loginMetadata?.pid]
+                .filter((pid) => processIsAlive(pid));
+            const wasRunning = livePids.length > 0;
+            for (const pid of livePids) {
+                try {
+                    process.kill(pid, "SIGTERM");
+                }
+                catch {
+                    // Process may have exited between checks.
+                }
+            }
+            const deadline = Date.now() + 8_000;
+            while (livePids.some((pid) => processIsAlive(pid)) && Date.now() < deadline) {
+                await sleep(200);
+            }
+            const remainingPids = livePids.filter((pid) => processIsAlive(pid));
+            if (remainingPids.length > 0) {
+                throw new Error(`专用浏览器未能在8秒内关闭（pid: ${remainingPids.join(", ")}）；状态文件已保留，请人工检查。`);
+            }
+            this.connectedBrowser = undefined;
+            this.connectedContext = undefined;
+            this.connectedMetadata = undefined;
+            fs.rmSync(this.metadataPath, { force: true });
+            fs.rmSync(this.loginMetadataPath, { force: true });
+            fs.rmSync(this.activePortPath, { force: true });
+            return wasRunning;
+        });
+    }
+}
+//# sourceMappingURL=browser-manager.js.map