codex-chatgpt-control 0.1.0-alpha.1

package/dist/src/commands/threads.js

@@ -0,0 +1,300 @@
+import { parseConversationId, readPageState } from "../browser/page-state.js";
+import { resultError, resultOk } from "../errors.js";
+import { countPageMessages, readLatestMessageText } from "../dom/messages.js";
+import { requiredLocator, searchChatsButton, searchChatsInput, newChatButton } from "../dom/selectors.js";
+import { normalizeWhitespace, stripTags } from "../dom/visible-text.js";
+import { contextFromPage } from "./context.js";
+import { bootstrap } from "./session.js";
+const CHATGPT_HOME = "https://chatgpt.com/";
+export function extractThreadSearchResultsFromHtml(html) {
+    const anchors = html.matchAll(/<a\b(?<attrs>[^>]*\bhref=["'](?<href>\/c\/[^"']+)["'][^>]*)>(?<body>[\s\S]*?)<\/a>/gi);
+    const results = [];
+    for (const anchor of anchors) {
+        const href = anchor.groups?.href;
+        const body = anchor.groups?.body ?? "";
+        if (href === undefined) {
+            continue;
+        }
+        const lines = extractBlockTexts(body);
+        const fallback = normalizeWhitespace(stripTags(body));
+        const title = lines[0] ?? fallback;
+        if (title.length === 0) {
+            continue;
+        }
+        const result = { title, href };
+        const conversationId = parseConversationId(href);
+        if (conversationId !== undefined) {
+            result.conversationId = conversationId;
+        }
+        const snippet = lines.slice(1).join(" ");
+        if (snippet.length > 0) {
+            result.snippet = snippet;
+        }
+        results.push(result);
+    }
+    return dedupeResults(results);
+}
+export async function searchThreads(env, args) {
+    const boot = await ensurePage(env);
+    if (!boot.ok) {
+        return boot;
+    }
+    const page = env.page;
+    try {
+        const warnings = [];
+        try {
+            await openSearchUI(page);
+            await fillSearchQuery(page, args.query);
+            await page.waitForTimeout?.(350);
+        }
+        catch (error) {
+            warnings.push(`Search modal was not usable; fell back to visible sidebar links. ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const results = filterResultsByQuery(await extractThreadSearchResultsFromPage(page), args.query);
+        const limited = results.slice(0, args.limit ?? results.length);
+        return resultOk({ query: args.query, results: limited }, await contextFromPage(page), warnings);
+    }
+    catch (error) {
+        return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
+    }
+}
+export async function newThread(env, args = {}) {
+    const boot = await ensurePage(env);
+    if (!boot.ok) {
+        return boot;
+    }
+    const page = env.page;
+    try {
+        try {
+            await newChatButton(page).click?.();
+        }
+        catch {
+            await page.goto?.(CHATGPT_HOME, { waitUntil: "domcontentloaded", timeout: args.timeoutMs ?? 30000 });
+        }
+        await page.waitForTimeout?.(500);
+        const state = await readPageState(page);
+        return resultOk(openThreadData(state.url, state.conversationId, state.title), await contextFromPage(page));
+    }
+    catch (error) {
+        return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
+    }
+}
+export async function openThread(env, args, previousResults) {
+    const boot = await ensurePage(env);
+    if (!boot.ok) {
+        return boot;
+    }
+    const page = env.page;
+    try {
+        const target = await resolveOpenTarget(env, args, previousResults);
+        if (target === undefined) {
+            return {
+                ok: false,
+                status: "not_found",
+                warnings: [],
+                blocker: {
+                    kind: "not_found",
+                    message: "No thread target could be resolved from the provided arguments."
+                },
+                context: await contextFromPage(page)
+            };
+        }
+        if (target.href !== undefined && target.href.startsWith("/")) {
+            await page.goto?.(new URL(target.href, CHATGPT_HOME).toString(), { waitUntil: "domcontentloaded", timeout: args.timeoutMs ?? 30000 });
+        }
+        else {
+            await page.goto?.(target.href ?? target.url, { waitUntil: "domcontentloaded", timeout: args.timeoutMs ?? 30000 });
+        }
+        await waitForThreadHydrated(page, args.timeoutMs ?? 30000, parseConversationId(target.url));
+        const state = await readPageState(page);
+        return resultOk(openThreadData(state.url, state.conversationId, state.title ?? target.title), await contextFromPage(page));
+    }
+    catch (error) {
+        return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
+    }
+}
+async function ensurePage(env) {
+    if (env.page !== undefined) {
+        return resultOk({}, await contextFromPage(env.page));
+    }
+    return bootstrap(env, { preferExistingTab: true });
+}
+async function resolveOpenTarget(env, args, previousResults) {
+    if (args.url !== undefined) {
+        return { url: args.url };
+    }
+    if (args.conversationId !== undefined) {
+        return { url: new URL(`/c/${args.conversationId}`, CHATGPT_HOME).toString() };
+    }
+    if (args.fromStep !== undefined && previousResults !== undefined) {
+        const previous = previousResults.get(args.fromStep);
+        const data = previous?.data;
+        const selected = selectSearchResult(data?.results ?? [], args.select ?? "first");
+        if (selected !== undefined) {
+            return { href: selected.href, url: new URL(selected.href, CHATGPT_HOME).toString(), title: selected.title };
+        }
+    }
+    if (args.title !== undefined) {
+        const search = await searchThreads(env, { query: args.title, limit: 10 });
+        const selected = selectSearchResult(search.data?.results ?? [], { title: args.title }) ?? search.data?.results[0];
+        if (selected !== undefined) {
+            return { href: selected.href, url: new URL(selected.href, CHATGPT_HOME).toString(), title: selected.title };
+        }
+    }
+    return undefined;
+}
+export function selectSearchResult(results, select = "first") {
+    if (select === "first") {
+        return results[0];
+    }
+    if (select !== undefined && "index" in select) {
+        return results[select.index];
+    }
+    if (select !== undefined && "title" in select) {
+        const wanted = normalizeForMatch(select.title);
+        return results.find(result => normalizeForMatch(result.title) === wanted)
+            ?? results.find(result => normalizeForMatch(result.title).includes(wanted));
+    }
+    return undefined;
+}
+async function extractThreadSearchResultsFromPage(page) {
+    if (page === undefined) {
+        return [];
+    }
+    if (typeof page.evaluate === "function") {
+        const raw = await page.evaluate(() => {
+            return Array.from(document.querySelectorAll("a[href^='/c/']"))
+                .map(anchor => ({
+                href: anchor.getAttribute("href") ?? "",
+                text: anchor.innerText ?? anchor.textContent ?? ""
+            }))
+                .filter(item => item.href.length > 0 && item.text.trim().length > 0);
+        });
+        return dedupeResults(raw.map(item => {
+            const lines = item.text.split(/\n+/).map(line => normalizeWhitespace(line)).filter(Boolean);
+            const result = {
+                title: lines[0] ?? normalizeWhitespace(item.text),
+                href: item.href
+            };
+            const conversationId = parseConversationId(item.href);
+            if (conversationId !== undefined) {
+                result.conversationId = conversationId;
+            }
+            const snippet = lines.slice(1).join(" ");
+            if (snippet.length > 0) {
+                result.snippet = snippet;
+            }
+            return result;
+        }));
+    }
+    if (typeof page.content === "function") {
+        return extractThreadSearchResultsFromHtml(await page.content());
+    }
+    return [];
+}
+function dedupeResults(results) {
+    const seen = new Set();
+    const deduped = [];
+    for (const result of results) {
+        const key = result.conversationId ?? result.href;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(result);
+    }
+    return deduped;
+}
+function normalizeForMatch(text) {
+    return normalizeWhitespace(text).toLowerCase();
+}
+async function openSearchUI(page) {
+    try {
+        await searchChatsButton(page).click?.();
+        await page.waitForTimeout?.(250);
+        return;
+    }
+    catch {
+        // Fall through to DOM click.
+    }
+    if (typeof page.evaluate === "function") {
+        try {
+            await page.evaluate(() => {
+                const button = Array.from(document.querySelectorAll("button"))
+                    .find(candidate => /Search chats/i.test(candidate.innerText ?? candidate.textContent ?? ""));
+                button?.click();
+            });
+            await page.waitForTimeout?.(250);
+            return;
+        }
+        catch {
+            // Fall through to keyboard shortcut.
+        }
+    }
+    await page.keyboard?.press?.("Meta+K");
+    await page.waitForTimeout?.(250);
+}
+async function fillSearchQuery(page, query) {
+    const attempts = [
+        async () => searchChatsInput(page).fill?.(query),
+        async () => page.getByRole?.("textbox", { name: "Search chats" }).fill?.(query),
+        async () => page.getByRole?.("textbox", { name: /Search chats/i }).fill?.(query),
+        async () => requiredLocator(page, "input[placeholder*='Search'], [role='dialog'] input").fill?.(query)
+    ];
+    let lastError;
+    for (const attempt of attempts) {
+        try {
+            await attempt();
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            await page.keyboard?.press?.("Meta+K");
+            await page.waitForTimeout?.(250);
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error("Unable to fill ChatGPT search input.");
+}
+function openThreadData(url, conversationId, title) {
+    const data = { url };
+    if (conversationId !== undefined) {
+        data.conversationId = conversationId;
+    }
+    if (title !== undefined) {
+        data.title = title;
+    }
+    return data;
+}
+function extractBlockTexts(html) {
+    const chunks = Array.from(html.matchAll(/<(?:div|span|p|h[1-6])\b[^>]*>([\s\S]*?)<\/(?:div|span|p|h[1-6])>/gi))
+        .map(match => stripTags(match[1] ?? ""))
+        .filter(Boolean);
+    if (chunks.length > 0) {
+        return chunks;
+    }
+    const fallback = stripTags(html);
+    return fallback.length > 0 ? [fallback] : [];
+}
+function filterResultsByQuery(results, query) {
+    const wanted = normalizeForMatch(query);
+    return results.filter(result => {
+        const haystack = normalizeForMatch(`${result.title} ${result.snippet ?? ""}`);
+        return haystack.includes(wanted) || wanted.includes(normalizeForMatch(result.title));
+    });
+}
+async function waitForThreadHydrated(page, timeoutMs, expectedConversationId) {
+    const started = Date.now();
+    await page.waitForTimeout?.(1000);
+    while (Date.now() - started < timeoutMs) {
+        const url = typeof page.url === "function" ? await Promise.resolve(page.url()).catch(() => "") : "";
+        const urlMatches = expectedConversationId === undefined || url.includes(expectedConversationId);
+        const count = await countPageMessages(page).catch(() => 0);
+        const latestAssistantText = await readLatestMessageText(page, "assistant").catch(() => undefined);
+        const title = typeof page.title === "function" ? await page.title().catch(() => "") : "";
+        if (urlMatches && ((latestAssistantText?.trim().length ?? 0) > 0 || (count > 0 && title.length > 0 && title !== "ChatGPT"))) {
+            await page.waitForTimeout?.(250);
+            return;
+        }
+        await page.waitForTimeout?.(500);
+    }
+}

package/dist/src/dom/fixtures.d.ts

@@ -0,0 +1 @@
+export declare function readFixture(name: string): Promise<string>;

package/dist/src/dom/fixtures.js

@@ -0,0 +1,8 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+export async function readFixture(name) {
+    if (name.includes("..") || name.startsWith("/")) {
+        throw new Error(`Unsafe fixture name: ${name}`);
+    }
+    return readFile(resolve("tests/fixtures", name), "utf8");
+}

package/dist/src/dom/menus.d.ts

@@ -0,0 +1,8 @@
+import type { PageLike } from "../types.js";
+export type MenuItem = {
+    label: string;
+    normalized: string;
+};
+export declare function extractMenuItemsFromText(text: string): MenuItem[];
+export declare function enumerateVisibleMenuItems(page: PageLike): Promise<MenuItem[]>;
+export declare function findUniqueMenuItem(items: MenuItem[], wanted: string): MenuItem | undefined;

package/dist/src/dom/menus.js

@@ -0,0 +1,40 @@
+import { normalizeLabel, normalizeWhitespace } from "./visible-text.js";
+export function extractMenuItemsFromText(text) {
+    return text
+        .split(/\n| {2,}| • /)
+        .map(label => normalizeWhitespace(label))
+        .filter(Boolean)
+        .map(label => ({ label, normalized: normalizeLabel(label) }));
+}
+export async function enumerateVisibleMenuItems(page) {
+    if (typeof page.evaluate === "function") {
+        const labels = await page.evaluate(() => {
+            const roleItems = Array.from(document.querySelectorAll("[role='menuitem'], [role='menuitemradio'], [role='option']"))
+                .map(node => node.innerText ?? node.textContent ?? "")
+                .filter(Boolean);
+            if (roleItems.length > 0) {
+                return { labels: roleItems, split: false };
+            }
+            const menus = Array.from(document.querySelectorAll("[role='menu'], [role='listbox'], [data-radix-popper-content-wrapper]"))
+                .map(node => node.innerText ?? node.textContent ?? "")
+                .filter(Boolean);
+            return { labels: menus, split: true };
+        });
+        return labels.split
+            ? labels.labels.flatMap(label => extractMenuItemsFromText(label))
+            : labels.labels
+                .map(label => normalizeWhitespace(label))
+                .filter(Boolean)
+                .map(label => ({ label, normalized: normalizeLabel(label) }));
+    }
+    return [];
+}
+export function findUniqueMenuItem(items, wanted) {
+    const normalized = normalizeLabel(wanted);
+    const exact = items.filter(item => item.normalized === normalized);
+    if (exact.length === 1) {
+        return exact[0];
+    }
+    const fuzzy = items.filter(item => item.normalized.includes(normalized));
+    return fuzzy.length === 1 ? fuzzy[0] : undefined;
+}

package/dist/src/dom/message-format.d.ts

@@ -0,0 +1,30 @@
+import type { ResponseAction, ResponseBlock, ResponseBranchState, ResponseCaptureFidelity, ResponseCaptureSource, ResponseCitation, ResponseCodeBlock, ResponseFormat, ResponseTable } from "../types.js";
+export type NormalizedResponseFormat = Exclude<ResponseFormat, "text">;
+export type FormattedMessageContent = {
+    text: string;
+    format: NormalizedResponseFormat;
+    source?: ResponseCaptureSource;
+    fidelity?: ResponseCaptureFidelity;
+    warnings?: string[];
+    markdown?: string;
+    visibleText?: string;
+    normalizedText?: string;
+    html?: string;
+    blocks?: ResponseBlock[];
+    citations?: ResponseCitation[];
+    codeBlocks?: ResponseCodeBlock[];
+    tables?: ResponseTable[];
+    branch?: ResponseBranchState;
+    actions?: ResponseAction[];
+    thoughtDurationText?: string;
+    sourcesAvailable?: boolean;
+};
+export type RoleMessageHtml = {
+    role: "user" | "assistant";
+    html: string;
+    metadataHtml?: string;
+};
+export declare function normalizeResponseFormat(format: ResponseFormat | undefined): NormalizedResponseFormat;
+export declare function extractRoleMessageHtml(html: string): RoleMessageHtml[];
+export declare function formatMessageHtml(html: string, requestedFormat?: ResponseFormat | undefined, maxChars?: number, metadataHtml?: string): FormattedMessageContent;
+export declare function formatClipboardMarkdown(text: string, maxChars?: number, requestedFormat?: ResponseFormat | undefined): FormattedMessageContent;