codex-chatgpt-control 0.1.0-alpha.1

package/dist/src/browser/attach.js

@@ -0,0 +1,456 @@
+import { BrowserBridgeUnavailableError, ChatGPTControlError, LoginRequiredError } from "../errors.js";
+import { parseConversationId, readPageState } from "./page-state.js";
+const CHATGPT_HOME = "https://chatgpt.com/";
+const CHATGPT_HOSTS = new Set(["chatgpt.com", "www.chatgpt.com", "chat.openai.com"]);
+export async function attachChatGPTBrowser(env, args = {}) {
+    const browser = await getBrowser(env);
+    const page = await getOrCreateChatGPTPage(browser, env, args);
+    const state = await readPageState(page);
+    if (state.blocker?.kind === "login_required") {
+        throw new LoginRequiredError(state.blocker.visibleText);
+    }
+    const attached = {
+        browser,
+        page,
+        browserName: browser.name ?? "chrome"
+    };
+    const tabId = getTabId(page);
+    if (tabId !== undefined) {
+        attached.tabId = tabId;
+    }
+    return attached;
+}
+async function getBrowser(env) {
+    if (env.browser !== undefined) {
+        return env.browser;
+    }
+    const anyEnv = env;
+    const agent = env.agent ?? anyEnv.agent ?? globalThis.agent;
+    const browsers = agent?.browsers;
+    if (browsers !== undefined && typeof browsers === "object") {
+        const maybeBrowser = await tryBrowserGetPreferredListed(browsers)
+            ?? await tryBrowserGet(browsers, "extension")
+            ?? await tryBrowserGet(browsers, "chrome");
+        if (maybeBrowser !== undefined) {
+            return maybeBrowser;
+        }
+    }
+    throw new BrowserBridgeUnavailableError();
+}
+async function tryBrowserGet(browsers, name) {
+    const get = browsers.get;
+    if (typeof get !== "function") {
+        return undefined;
+    }
+    try {
+        const browser = await get.call(browsers, name);
+        return normalizeBrowser(browser);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function tryBrowserGetFirst(browsers) {
+    const list = browsers.list;
+    const get = browsers.get;
+    if (typeof list !== "function" || typeof get !== "function") {
+        return undefined;
+    }
+    try {
+        const names = await list.call(browsers);
+        const first = names.find(name => typeof name === "string");
+        if (first === undefined) {
+            return undefined;
+        }
+        const browser = await get.call(browsers, first);
+        return normalizeBrowser(browser);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function tryBrowserGetPreferredListed(browsers) {
+    const list = browsers.list;
+    const get = browsers.get;
+    if (typeof list !== "function" || typeof get !== "function") {
+        return undefined;
+    }
+    try {
+        const available = await list.call(browsers);
+        const preferred = available.find(browser => browser.type === "extension")
+            ?? available.find(browser => typeof browser.name === "string" && /chrome/i.test(browser.name))
+            ?? available[0];
+        const id = preferred?.id;
+        if (typeof id !== "string") {
+            return undefined;
+        }
+        const browser = await get.call(browsers, id);
+        return normalizeBrowser(browser);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function getOrCreateChatGPTPage(browser, env, args) {
+    const targetUrl = args.url ?? CHATGPT_HOME;
+    const explicitExistingPolicy = normalizeExplicitExistingTabPolicy(args);
+    if (env.page !== undefined) {
+        const cached = normalizePage(env.page);
+        if (await cachedPageMatchesBootstrapArgs(cached, args, explicitExistingPolicy)) {
+            return cached;
+        }
+    }
+    if (explicitExistingPolicy !== undefined) {
+        const existing = await selectExistingTab(browser, explicitExistingPolicy);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const ifMissing = explicitExistingPolicy.ifMissing ?? "block";
+        if (ifMissing === "block") {
+            throw new ExistingTabSelectionError("No already-open ChatGPT tab matched the requested existing-tab target.", "existing_tab_not_found");
+        }
+        const missingUrl = ifMissing === "open"
+            ? urlFromExistingTarget(explicitExistingPolicy.target) ?? targetUrl
+            : targetUrl;
+        const created = await createTab(browser, missingUrl);
+        if (created !== undefined) {
+            return created;
+        }
+        throw new BrowserBridgeUnavailableError("Codex can access a browser object, but no tab creation API was found.");
+    }
+    if (args.preferExistingTab !== false) {
+        const existing = await findExistingChatGPTTab(browser);
+        if (existing !== undefined) {
+            return existing;
+        }
+    }
+    const created = await createTab(browser, targetUrl);
+    if (created !== undefined) {
+        return created;
+    }
+    throw new BrowserBridgeUnavailableError("Codex can access a browser object, but no tab creation API was found.");
+}
+async function cachedPageMatchesBootstrapArgs(page, args, explicitExistingPolicy) {
+    if (explicitExistingPolicy !== undefined) {
+        return pageMatchesExistingTarget(page, explicitExistingPolicy);
+    }
+    if (args.url !== undefined) {
+        const currentUrl = await Promise.resolve(page.url?.()).catch(() => undefined);
+        return urlMatches(currentUrl, args.url);
+    }
+    return true;
+}
+function normalizeExplicitExistingTabPolicy(args) {
+    if (args.existingTab === undefined) {
+        return undefined;
+    }
+    if (args.existingTab === true) {
+        return {
+            target: { type: "selected", host: "chatgpt" },
+            ifMissing: "create",
+            ifMultiple: "first",
+            requireChatGPT: true
+        };
+    }
+    if (args.existingTab === false) {
+        return undefined;
+    }
+    return {
+        requireChatGPT: true,
+        ifMissing: "block",
+        ifMultiple: args.existingTab.target?.type === "selected" ? "first" : "block",
+        ...args.existingTab
+    };
+}
+async function selectExistingTab(browser, policy) {
+    const userMatch = await selectExistingUserTab(browser, policy);
+    if (userMatch !== undefined) {
+        return userMatch;
+    }
+    if (policy.target?.type === "selected" && typeof browser.tabs?.selected === "function") {
+        const selected = await Promise.resolve(browser.tabs.selected.call(browser.tabs)).catch(() => undefined);
+        if (selected !== undefined) {
+            const normalized = normalizePage(selected);
+            if (await pageMatchesExistingTarget(normalized, policy)) {
+                return normalized;
+            }
+        }
+    }
+    if (policy.target?.type === "tabId" && typeof browser.tabs?.get === "function") {
+        const tab = await Promise.resolve(browser.tabs.get.call(browser.tabs, policy.target.tabId)).catch(() => undefined);
+        if (tab !== undefined) {
+            const normalized = normalizePage(tab);
+            if (await pageMatchesExistingTarget(normalized, policy)) {
+                return normalized;
+            }
+        }
+    }
+    return undefined;
+}
+async function selectExistingUserTab(browser, policy) {
+    const openTabs = browser.user?.openTabs;
+    const claimTab = browser.user?.claimTab;
+    if (typeof openTabs !== "function" || typeof claimTab !== "function") {
+        return undefined;
+    }
+    const tabs = await Promise.resolve(openTabs.call(browser.user)).catch(() => []);
+    const matches = tabs.filter(tab => userTabMatchesTarget(tab, policy));
+    if (matches.length === 0) {
+        return undefined;
+    }
+    if (matches.length > 1 && (policy.ifMultiple ?? "block") !== "first") {
+        throw new ExistingTabSelectionError("Multiple already-open ChatGPT tabs matched the requested existing-tab target.", "existing_tab_ambiguous", matches);
+    }
+    const selected = matches[0];
+    return normalizePage(await claimTab.call(browser.user, selected));
+}
+function userTabMatchesTarget(tab, policy) {
+    const target = policy.target ?? { type: "selected", host: "chatgpt" };
+    const requireChatGPT = policy.requireChatGPT ?? targetRequiresChatGPT(target);
+    if (requireChatGPT && !isChatGPTUrl(tab.url)) {
+        return false;
+    }
+    switch (target.type) {
+        case "selected":
+            return target.host === undefined || target.host === "chatgpt" ? isChatGPTUrl(tab.url) : true;
+        case "tabId":
+            return tab.id === target.tabId;
+        case "conversationId":
+        case "conversation_id":
+            return parseConversationId(tab.url ?? "") === target.conversationId;
+        case "url":
+            return urlMatches(tab.url, target.url);
+        case "title":
+            return titleMatches(tab.title, target.title, target.exact ?? true);
+    }
+}
+async function pageMatchesExistingTarget(page, policy) {
+    const url = await Promise.resolve(page.url?.()).catch(() => undefined);
+    const title = await Promise.resolve(page.title?.()).catch(() => undefined);
+    const tab = { id: getTabId(page) ?? "" };
+    if (url !== undefined)
+        tab.url = url;
+    if (title !== undefined)
+        tab.title = title;
+    return userTabMatchesTarget(tab, policy);
+}
+async function findExistingChatGPTTab(browser) {
+    const userTab = await selectExistingUserTab(browser, {
+        target: { type: "selected", host: "chatgpt" },
+        ifMultiple: "first",
+        requireChatGPT: true
+    });
+    if (userTab !== undefined) {
+        return userTab;
+    }
+    const selected = browser.tabs?.selected;
+    if (typeof selected === "function") {
+        try {
+            const current = await selected.call(browser.tabs);
+            if (current !== undefined) {
+                const normalized = normalizePage(current);
+                try {
+                    if ((await normalized.url?.())?.includes("chatgpt.com") === true) {
+                        return normalized;
+                    }
+                }
+                catch {
+                    // Continue to full tab list.
+                }
+            }
+        }
+        catch {
+            // No selected tab is a normal fresh-browser state.
+        }
+    }
+    const list = browser.tabs?.list;
+    if (typeof list !== "function") {
+        return undefined;
+    }
+    const tabs = await list.call(browser.tabs);
+    const normalized = await Promise.all(tabs.map(tab => hydrateTab(browser, tab)));
+    for (const tab of normalized) {
+        try {
+            if ((await tab.url?.())?.includes("chatgpt.com") === true) {
+                return tab;
+            }
+        }
+        catch {
+            // Keep looking.
+        }
+    }
+    return undefined;
+}
+class ExistingTabSelectionError extends ChatGPTControlError {
+    constructor(message, code, candidates = []) {
+        super(message, "not_found", true, undefined, {
+            code,
+            candidates: candidates.map(tab => ({ label: userTabCandidateLabel(tab) })),
+            remediation: [
+                {
+                    label: "Choose an exact tab",
+                    instruction: "Use the selected tab, a ChatGPT conversation URL, conversation ID, or a tab id returned by openTabs().",
+                    userActionRequired: false
+                },
+                {
+                    label: "Allow opening",
+                    instruction: "Rerun with open-if-missing only if it is acceptable to open or create a ChatGPT tab instead of reusing an already-open one.",
+                    userActionRequired: false
+                }
+            ]
+        });
+    }
+}
+function targetRequiresChatGPT(target) {
+    switch (target.type) {
+        case "selected":
+            return target.host === "chatgpt";
+        case "tabId":
+        case "title":
+            return true;
+        case "conversationId":
+        case "conversation_id":
+        case "url":
+            return true;
+    }
+}
+function isChatGPTUrl(url) {
+    if (url === undefined) {
+        return false;
+    }
+    try {
+        return CHATGPT_HOSTS.has(new URL(url).hostname);
+    }
+    catch {
+        return false;
+    }
+}
+function urlMatches(actual, expected) {
+    if (actual === undefined) {
+        return false;
+    }
+    const actualConversationId = parseConversationId(actual);
+    const expectedConversationId = parseConversationId(expected);
+    if (actualConversationId !== undefined || expectedConversationId !== undefined) {
+        return actualConversationId !== undefined && actualConversationId === expectedConversationId;
+    }
+    return normalizeUrl(actual) === normalizeUrl(expected);
+}
+function normalizeUrl(value) {
+    try {
+        const url = new URL(value);
+        url.hash = "";
+        return url.toString().replace(/\/$/, "");
+    }
+    catch {
+        return value.trim().replace(/\/$/, "");
+    }
+}
+function titleMatches(actual, expected, exact) {
+    if (actual === undefined) {
+        return false;
+    }
+    const normalizedActual = normalizeText(actual);
+    const normalizedExpected = normalizeText(expected);
+    return exact ? normalizedActual === normalizedExpected : normalizedActual.includes(normalizedExpected);
+}
+function normalizeText(value) {
+    return value.replace(/\s+/g, " ").trim().toLowerCase();
+}
+function urlFromExistingTarget(target) {
+    if (target === undefined) {
+        return undefined;
+    }
+    switch (target.type) {
+        case "url":
+            return target.url;
+        case "conversationId":
+        case "conversation_id":
+            return new URL(`/c/${target.conversationId}`, CHATGPT_HOME).toString();
+        case "selected":
+        case "tabId":
+        case "title":
+            return undefined;
+    }
+}
+function userTabCandidateLabel(tab) {
+    return `tab ${tab.id} - ${tab.title ?? "Untitled"} - ${tab.url ?? "unknown URL"}`;
+}
+async function createTab(browser, url) {
+    if (typeof browser.tabs?.create === "function") {
+        const tab = await browser.tabs.create(url);
+        const page = await hydrateTab(browser, tab);
+        await ensurePageAt(page, url);
+        return page;
+    }
+    if (typeof browser.tabs?.new === "function") {
+        const tab = await browser.tabs.new(url);
+        const page = await hydrateTab(browser, tab);
+        await ensurePageAt(page, url);
+        return page;
+    }
+    if (typeof browser.newPage === "function") {
+        const page = normalizePage(await browser.newPage());
+        if (typeof page.goto === "function") {
+            await page.goto(url);
+        }
+        return page;
+    }
+    return undefined;
+}
+async function ensurePageAt(page, url) {
+    const currentUrl = await Promise.resolve(page.url?.()).catch(() => "");
+    if (currentUrl?.includes("chatgpt.com") === true) {
+        return;
+    }
+    if (typeof page.goto === "function") {
+        await page.goto(url);
+    }
+}
+function normalizeBrowser(browser) {
+    if (browser === undefined || browser === null || typeof browser !== "object") {
+        return undefined;
+    }
+    return browser;
+}
+async function hydrateTab(browser, pageOrTab) {
+    const maybe = pageOrTab;
+    if (maybe.playwright === undefined && typeof maybe.id === "string" && typeof browser.tabs?.get === "function") {
+        try {
+            return normalizePage(await browser.tabs.get(maybe.id));
+        }
+        catch {
+            return normalizePage(pageOrTab);
+        }
+    }
+    return normalizePage(pageOrTab);
+}
+function normalizePage(pageOrTab) {
+    const maybe = pageOrTab;
+    const playwright = maybe.playwright ?? maybe.page;
+    if (playwright !== undefined && typeof playwright === "object") {
+        return new Proxy(playwright, {
+            get(target, prop) {
+                if (prop in target) {
+                    const value = target[prop];
+                    return typeof value === "function" ? value.bind(target) : value;
+                }
+                const value = maybe[prop];
+                return typeof value === "function" ? value.bind(maybe) : value;
+            }
+        });
+    }
+    if (typeof maybe.url === "string") {
+        return {
+            ...maybe,
+            url: () => maybe.url,
+            title: async () => typeof maybe.title === "string" ? maybe.title : ""
+        };
+    }
+    return pageOrTab;
+}
+function getTabId(page) {
+    const maybe = page;
+    const id = maybe.id ?? maybe.tabId;
+    return typeof id === "string" ? id : undefined;
+}

package/dist/src/browser/clipboard.d.ts

@@ -0,0 +1,2 @@
+export declare function readSystemClipboard(): Promise<string | undefined>;
+export declare function waitForClipboardChange(before: string | undefined, timeoutMs: number, pollMs?: number): Promise<string | undefined>;

package/dist/src/browser/clipboard.js

@@ -0,0 +1,26 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+export async function readSystemClipboard() {
+    if (typeof process === "undefined" || process.platform !== "darwin") {
+        return undefined;
+    }
+    try {
+        const { stdout } = await execFileAsync("pbpaste", [], { timeout: 2000, maxBuffer: 10 * 1024 * 1024 });
+        return stdout;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function waitForClipboardChange(before, timeoutMs, pollMs = 150) {
+    const started = Date.now();
+    while (Date.now() - started < timeoutMs) {
+        const current = await readSystemClipboard();
+        if (current !== undefined && current.length > 0 && current !== before) {
+            return current;
+        }
+        await new Promise(resolve => setTimeout(resolve, pollMs));
+    }
+    return undefined;
+}

package/dist/src/browser/downloads.d.ts

@@ -0,0 +1,7 @@
+import type { DownloadedFile, PageLike } from "../types.js";
+export type DownloadLike = {
+    suggestedFilename?: () => string;
+    saveAs?: (path: string) => Promise<void>;
+    path?: () => Promise<string | null>;
+};
+export declare function waitForDownloadFromClick(page: PageLike, click: () => Promise<void>, destDir: string, timeoutMs: number): Promise<DownloadedFile>;

package/dist/src/browser/downloads.js

@@ -0,0 +1,29 @@
+import { mkdir, stat } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+export async function waitForDownloadFromClick(page, click, destDir, timeoutMs) {
+    const absoluteDest = resolve(destDir);
+    await mkdir(absoluteDest, { recursive: true });
+    const downloadPromise = page.waitForEvent?.("download", { timeout: timeoutMs, timeoutMs });
+    if (downloadPromise === undefined) {
+        throw new Error("The active browser page does not expose download events.");
+    }
+    await click();
+    const download = await downloadPromise;
+    const suggestedFilename = download.suggestedFilename?.() ?? `chatgpt-download-${Date.now()}`;
+    const targetPath = join(absoluteDest, basename(suggestedFilename));
+    if (typeof download.saveAs === "function") {
+        await download.saveAs(targetPath);
+    }
+    else {
+        throw new Error("The browser download object does not expose saveAs().");
+    }
+    const saved = await stat(targetPath);
+    if (saved.size <= 0) {
+        throw new Error(`Downloaded file is empty: ${targetPath}`);
+    }
+    return {
+        path: targetPath,
+        suggestedFilename,
+        bytes: saved.size
+    };
+}

package/dist/src/browser/page-state.d.ts

@@ -0,0 +1,17 @@
+import type { BlockerKind, PageLike } from "../types.js";
+export type PageState = {
+    url: string;
+    conversationId?: string;
+    title?: string;
+    visibleText: string;
+    signedIn: boolean;
+    blocker?: {
+        kind: BlockerKind;
+        message: string;
+        visibleText?: string;
+    };
+};
+export declare function parseConversationId(url: string): string | undefined;
+export declare function readPageState(page: PageLike): Promise<PageState>;
+export declare function readVisibleText(page: PageLike): Promise<string>;
+export declare function htmlToText(html: string): string;

package/dist/src/browser/page-state.js

@@ -0,0 +1,66 @@
+import { classifyVisibleText } from "../safety/blockers.js";
+import { compactVisibleText } from "../safety/redaction.js";
+export function parseConversationId(url) {
+    const match = /\/c\/([A-Za-z0-9-]+)/.exec(url);
+    return match?.[1];
+}
+export async function readPageState(page) {
+    const rawUrl = typeof page.url === "function" ? await Promise.resolve(page.url()).catch(() => "") : "";
+    const url = typeof rawUrl === "string" ? rawUrl : "";
+    const rawTitle = typeof page.title === "function" ? await page.title().catch(() => undefined) : undefined;
+    const title = typeof rawTitle === "string" ? rawTitle : undefined;
+    const visibleText = await readVisibleText(page);
+    const blocker = classifyVisibleText(visibleText);
+    const signedIn = isLikelySignedIn(visibleText) && blocker?.kind !== "login_required";
+    const conversationId = parseConversationId(url);
+    const state = {
+        url,
+        visibleText: compactVisibleText(visibleText),
+        signedIn
+    };
+    if (conversationId !== undefined) {
+        state.conversationId = conversationId;
+    }
+    if (title !== undefined) {
+        state.title = title;
+    }
+    if (blocker !== undefined) {
+        state.blocker = blocker;
+    }
+    return state;
+}
+export async function readVisibleText(page) {
+    if (typeof page.evaluate === "function") {
+        try {
+            return await page.evaluate(() => document.body?.innerText ?? "");
+        }
+        catch {
+            // Fall back to content parsing below.
+        }
+    }
+    if (typeof page.content === "function") {
+        try {
+            const html = await page.content();
+            return htmlToText(html);
+        }
+        catch {
+            return "";
+        }
+    }
+    return "";
+}
+export function htmlToText(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, " ")
+        .replace(/<style[\s\S]*?<\/style>/gi, " ")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&nbsp;/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function isLikelySignedIn(visibleText) {
+    return /\b(New chat|Search chats|Chat with ChatGPT|Recents|Projects)\b/i.test(visibleText);
+}