codex-chatgpt-control 0.2.0-alpha.1 → 0.5.0-alpha.1

package/dist/src/scripts/capture-intelligence-locales.js

@@ -11,6 +11,11 @@ const CHATGPT_HOME = "https://chatgpt.com/";
 const DEFAULT_SWITCH_TIMEOUT_MS = 15_000;
 const DEFAULT_SETTLE_MS = 1_500;
 const DEFAULT_LIMIT = 25;
+const DEFAULT_GENERATION_CAPTURE_TIMEOUT_MS = 8_000;
+const DEFAULT_GENERATION_PROMPT = [
+    "Localization probe: count upward from 1 to 2000, one number per line.",
+    "Do not explain. Keep going until I stop you."
+].join(" ");
 class CaptureUsageError extends Error {
     exitCode;
     constructor(message, exitCode = 2) {
@@ -38,6 +43,10 @@ const USAGE = [
     "  --locales                      Comma-separated BCP47 ids to sweep instead of first --limit languages.",
     "  --open-version-submenu         Capture GPT-* model version submenu labels. Default: true.",
     "  --no-open-version-submenu      Do not open the model-version submenu.",
+    "  --capture-generation-state     Submit one bounded probe per locale to capture localized running/stopped generation labels. Default: false.",
+    "  --no-capture-generation-state  Disable generation-state capture.",
+    "  --generation-prompt            Override the redacted probe prompt used only for generation-state capture.",
+    "  --generation-timeout-ms        Wait for generation controls after submit. Default: 8000.",
     "  --restore                      Restore the initially selected language after a sweep. Default with --auto-switch.",
     "  --no-restore                   Leave ChatGPT on the last swept language.",
     "  --settle-ms                    Wait after language switches and menu opens. Default: 1500.",
@@ -114,6 +123,9 @@ export function parseArgs(argv) {
     let limit;
     let locales;
     let openVersionSubmenu = true;
+    let captureGenerationState = false;
+    let generationPrompt = DEFAULT_GENERATION_PROMPT;
+    let generationCaptureTimeoutMs = DEFAULT_GENERATION_CAPTURE_TIMEOUT_MS;
     let restore;
     let settleMs = DEFAULT_SETTLE_MS;
     let switchTimeoutMs = DEFAULT_SWITCH_TIMEOUT_MS;
@@ -158,6 +170,18 @@ export function parseArgs(argv) {
             case "--no-open-version-submenu":
                 openVersionSubmenu = false;
                 break;
+            case "--capture-generation-state":
+                captureGenerationState = true;
+                break;
+            case "--no-capture-generation-state":
+                captureGenerationState = false;
+                break;
+            case "--generation-prompt":
+                generationPrompt = requiredValue(argv, ++index, arg);
+                break;
+            case "--generation-timeout-ms":
+                generationCaptureTimeoutMs = parsePositiveInteger(requiredValue(argv, ++index, arg), arg);
+                break;
             case "--restore":
                 restore = true;
                 break;
@@ -197,6 +221,9 @@ export function parseArgs(argv) {
         limit,
         locales,
         openVersionSubmenu,
+        captureGenerationState,
+        generationPrompt,
+        generationCaptureTimeoutMs,
         restore: restore ?? autoSwitch,
         settleMs,
         switchTimeoutMs,
@@ -260,8 +287,15 @@ async function captureOne(page, language, options) {
             }
         }
         await closeSettingsIfOpen(page);
+        await returnToChatSurface(page, options);
         const picker = await captureIntelligencePicker(page, options);
-        return {
+        const generation = options.captureGenerationState
+            ? await captureGenerationStateLabels(page, options)
+            : undefined;
+        if (generation !== undefined) {
+            warnings.push(...generation.warnings);
+        }
+        const record = {
             schemaVersion: SCHEMA_VERSION,
             status: "ok",
             capturedAt: new Date().toISOString(),
@@ -276,6 +310,12 @@ async function captureOne(page, language, options) {
             modelVersionLabels: picker.modelVersionLabels,
             warnings
         };
+        if (generation !== undefined) {
+            record.generationStopLabels = generation.stopLabels;
+            record.generationStoppedLabels = generation.stoppedLabels;
+            record.generationSignals = generation.signals;
+        }
+        return record;
     }
     catch (error) {
         const proof = await renderedProof(page).catch(() => ({}));
@@ -378,6 +418,18 @@ async function closeSettingsIfOpen(page) {
         throw new Error("Settings modal did not close.");
     }
 }
+async function returnToChatSurface(page, options) {
+    const proof = await renderedProof(page).catch(() => ({}));
+    if (proof.url?.includes("#settings") !== true)
+        return;
+    if (page.goto !== undefined) {
+        await page.goto(CHATGPT_HOME).catch(() => undefined);
+        await wait(options.settleMs);
+        return;
+    }
+    await page.keyboard?.press?.("Escape").catch(() => undefined);
+    await wait(options.settleMs);
+}
 async function closeFloatingMenus(page) {
     await page.locator?.("body")?.click?.({ position: { x: 12, y: 12 } }).catch(() => undefined);
     await wait(250);
@@ -544,6 +596,323 @@ async function openVersionSubmenu(page) {
             return;
     }
 }
+async function captureGenerationStateLabels(page, options) {
+    const warnings = [];
+    const before = await readGenerationUiSnapshot(page).catch(() => ({ controls: [], shortLatestAssistantTexts: [] }));
+    let submitted = false;
+    let stopped = false;
+    let active = before;
+    let stopLabels = [];
+    try {
+        if (snapshotLooksActive(before)) {
+            warnings.push("Generation controls were already visible before the probe; capturing existing controls without submitting another prompt.");
+        }
+        else {
+            submitted = await submitGenerationProbePrompt(page, options.generationPrompt);
+        }
+        active = await waitForGenerationUiSnapshot(page, before, options.generationCaptureTimeoutMs).catch(error => {
+            warnings.push(`Generation control capture timed out: ${error instanceof Error ? error.message : String(error)}`);
+            return before;
+        });
+        stopLabels = generationStopLabels(before, active);
+        if (stopLabels.length === 0) {
+            warnings.push("No generation stop labels were observed; leaving stopControl unchanged for this locale.");
+        }
+    }
+    catch (error) {
+        warnings.push(`Generation probe failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    finally {
+        if (submitted || stopLabels.length > 0 || snapshotLooksActive(active)) {
+            stopped = await stopGenerationIfVisible(page, stopLabels).catch(error => {
+                warnings.push(`Unable to stop generation after probe: ${error instanceof Error ? error.message : String(error)}`);
+                return false;
+            });
+            await wait(options.settleMs);
+        }
+    }
+    const afterStop = await readGenerationUiSnapshot(page).catch(() => ({ controls: [], shortLatestAssistantTexts: [] }));
+    const stoppedLabels = stopped ? generationStoppedLabels(before, active, afterStop) : [];
+    if (submitted && !stopped) {
+        warnings.push("Generation probe was submitted but no stop action was confirmed.");
+    }
+    return {
+        stopLabels,
+        stoppedLabels,
+        signals: dedupeStrings([
+            ...stopLabels,
+            ...stoppedLabels,
+            ...active.controls.map(control => control.label)
+        ]).slice(0, 20),
+        warnings,
+        submitted,
+        stopped
+    };
+}
+async function submitGenerationProbePrompt(page, prompt) {
+    await closeFloatingMenus(page);
+    const textbox = page.locator?.("textarea, [contenteditable='true']")?.last?.()
+        ?? page.getByRole?.("textbox")?.last?.();
+    if (textbox?.click === undefined || textbox.fill === undefined) {
+        throw new Error("Composer textbox was not available for generation probe.");
+    }
+    await textbox.click();
+    await textbox.fill(prompt);
+    if (page.keyboard?.press !== undefined) {
+        await page.keyboard.press("Enter");
+        return true;
+    }
+    const clicked = await clickSubmitControlByDom(page);
+    if (!clicked) {
+        throw new Error("No structural submit control was available for generation probe.");
+    }
+    return true;
+}
+async function clickSubmitControlByDom(page) {
+    const structuralSelectors = [
+        "form button[data-testid='send-button']",
+        "form button#composer-submit-button",
+        "button[data-testid='send-button']",
+        "button#composer-submit-button"
+    ];
+    for (const selector of structuralSelectors) {
+        const button = page.locator?.(selector)?.last?.();
+        if (button?.click === undefined)
+            continue;
+        const clicked = await button.click().then(() => true, () => false);
+        if (clicked)
+            return true;
+    }
+    if (typeof page.evaluate !== "function")
+        return false;
+    return page.evaluate(() => {
+        const isButtonElement = (element) => element.tagName.toLowerCase() === "button";
+        const visible = (element) => {
+            const rect = element.getBoundingClientRect();
+            const style = window.getComputedStyle(element);
+            return rect.width > 0
+                && rect.height > 0
+                && style.display !== "none"
+                && style.visibility !== "hidden"
+                && style.opacity !== "0";
+        };
+        const buttons = Array.from(document.querySelectorAll("form button, button"))
+            .filter((button) => {
+            if (!isButtonElement(button))
+                return false;
+            if (button.disabled || button.getAttribute("aria-disabled") === "true")
+                return false;
+            if (!visible(button))
+                return false;
+            const text = [
+                button.textContent,
+                button.getAttribute("aria-label"),
+                button.getAttribute("title"),
+                button.getAttribute("data-testid")
+            ].filter(Boolean).join(" ");
+            return /send|submit|composer-submit|arrow-up/i.test(text);
+        });
+        let button = buttons.at(-1);
+        if (button === undefined) {
+            const structural = Array.from(document.querySelectorAll("form button"))
+                .filter((candidate) => {
+                if (!isButtonElement(candidate))
+                    return false;
+                if (candidate.disabled || candidate.getAttribute("aria-disabled") === "true")
+                    return false;
+                if (!visible(candidate))
+                    return false;
+                const text = [
+                    candidate.textContent,
+                    candidate.getAttribute("aria-label"),
+                    candidate.getAttribute("title"),
+                    candidate.getAttribute("data-testid"),
+                    candidate.id
+                ].filter(Boolean).join(" ");
+                return !/composer-plus|plus|attach|file|microphone|mic|dictat|voice|audio|intelligence|model|tool/i.test(text);
+            })
+                .sort((left, right) => {
+                const leftRect = left.getBoundingClientRect();
+                const rightRect = right.getBoundingClientRect();
+                return (rightRect.bottom + rightRect.right / 10) - (leftRect.bottom + leftRect.right / 10);
+            });
+            button = structural[0];
+        }
+        if (button === undefined)
+            return false;
+        button.click();
+        return true;
+    }).catch(() => false);
+}
+async function waitForGenerationUiSnapshot(page, before, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const current = await readGenerationUiSnapshot(page);
+        if (generationStopLabels(before, current).length > 0 || snapshotLooksActive(current)) {
+            return current;
+        }
+        if (Date.now() >= deadline) {
+            throw new Error("Timed out waiting for generation controls.");
+        }
+        await wait(500);
+    }
+}
+async function readGenerationUiSnapshot(page) {
+    if (typeof page.evaluate !== "function") {
+        return { controls: [], shortLatestAssistantTexts: [] };
+    }
+    return page.evaluate(() => {
+        const normalize = (value) => (value ?? "").replace(/\s+/g, " ").trim();
+        const visible = (element) => {
+            if (typeof element.getBoundingClientRect !== "function")
+                return false;
+            const rect = element.getBoundingClientRect();
+            const style = window.getComputedStyle(element);
+            return rect.width > 0
+                && rect.height > 0
+                && style.display !== "none"
+                && style.visibility !== "hidden"
+                && style.opacity !== "0"
+                && element.getAttribute("aria-hidden") !== "true";
+        };
+        const relevantSurface = (element) => element.closest("main, form") !== null
+            && element.closest("nav, aside") === null;
+        const controls = Array.from(document.querySelectorAll("main button, main [role='button'], form button, form [role='button']"))
+            .filter(visible)
+            .filter(relevantSurface)
+            .map(element => {
+            const html = element;
+            const text = normalize(html.innerText || html.textContent);
+            const ariaLabel = normalize(html.getAttribute("aria-label"));
+            const title = normalize(html.getAttribute("title"));
+            const testId = normalize(html.getAttribute("data-testid"));
+            const label = ariaLabel || title || text || testId;
+            return {
+                label,
+                text: text || undefined,
+                ariaLabel: ariaLabel || undefined,
+                title: title || undefined,
+                testId: testId || undefined,
+                role: html.getAttribute("role") ?? undefined
+            };
+        })
+            .filter(control => control.label.length > 0);
+        const turns = Array.from(document.querySelectorAll("main [data-testid^='conversation-turn']"));
+        const latestAssistant = turns.reverse().find(turn => turn.querySelector("[data-message-author-role='assistant']") !== null);
+        const shortLatestAssistantTexts = latestAssistant === undefined
+            ? []
+            : Array.from(latestAssistant.querySelectorAll("[data-message-author-role='assistant'] *"))
+                .map(element => normalize(element.innerText || element.textContent))
+                .filter(text => text.length > 0 && text.length <= 80);
+        return { controls, shortLatestAssistantTexts };
+    }).catch(() => ({ controls: [], shortLatestAssistantTexts: [] }));
+}
+function generationStopLabels(before, active) {
+    const beforeLabels = new Set(before.controls.map(control => normalizedControlKey(control.label)));
+    const candidates = active.controls
+        .filter(control => !beforeLabels.has(normalizedControlKey(control.label)) || looksLikeStopControl(control))
+        .map(control => control.label)
+        .filter(isUsefulGenerationLabel);
+    return dedupeStrings(candidates);
+}
+function generationStoppedLabels(before, active, afterStop) {
+    const previous = new Set([...before.shortLatestAssistantTexts, ...active.shortLatestAssistantTexts].map(normalizedControlKey));
+    const candidates = afterStop.shortLatestAssistantTexts
+        .filter(text => !previous.has(normalizedControlKey(text)))
+        .filter(isUsefulStoppedText);
+    return dedupeStrings(candidates);
+}
+function snapshotLooksActive(snapshot) {
+    return snapshot.controls.some(looksLikeStopControl);
+}
+function looksLikeStopControl(control) {
+    return /stop|cancel|abort|interromp|unterbrech|gestoppt|arr[eê]t|detener|parar|interrumpir/i.test([
+        control.label,
+        control.text,
+        control.ariaLabel,
+        control.title,
+        control.testId
+    ].filter(Boolean).join(" "));
+}
+function isUsefulGenerationLabel(label) {
+    const normalized = normalizedControlKey(label);
+    if (normalized.length < 2 || normalized.length > 80)
+        return false;
+    if (/^(send|send prompt|voice|dictate|start dictation|attach|add files|new chat|copy response|more actions|pro|instant|thinking|extended thinking)$/i.test(normalized))
+        return false;
+    return true;
+}
+function isUsefulStoppedText(text) {
+    const normalized = normalizedControlKey(text);
+    if (normalized.length < 2 || normalized.length > 80)
+        return false;
+    if (/^[\d\s.,:;!?()[\]-]+$/.test(normalized))
+        return false;
+    if (/^localization probe/i.test(normalized))
+        return false;
+    return true;
+}
+async function stopGenerationIfVisible(page, labels) {
+    for (const label of labels) {
+        const roleButton = page.getByRole?.("button", { name: label, exact: true })?.last?.();
+        if (roleButton?.click !== undefined) {
+            await roleButton.click().catch(() => undefined);
+            await wait(500);
+            return true;
+        }
+    }
+    if (typeof page.evaluate !== "function")
+        return false;
+    return page.evaluate((wantedLabels) => {
+        const normalize = (value) => (value ?? "").replace(/\s+/g, " ").trim().toLowerCase();
+        const wanted = new Set(wantedLabels.map(label => label.toLowerCase()));
+        const relevantSurface = (element) => element.closest("main, form") !== null
+            && element.closest("nav, aside") === null;
+        const visible = (element) => {
+            const rect = element.getBoundingClientRect();
+            const style = window.getComputedStyle(element);
+            return rect.width > 0
+                && rect.height > 0
+                && style.display !== "none"
+                && style.visibility !== "hidden"
+                && style.opacity !== "0";
+        };
+        const buttons = Array.from(document.querySelectorAll("main button, main [role='button'], form button, form [role='button']"))
+            .filter((button) => typeof button.getBoundingClientRect === "function" && visible(button))
+            .filter(relevantSurface);
+        const match = buttons.find(button => {
+            const label = [
+                button.getAttribute("aria-label"),
+                button.getAttribute("title"),
+                button.innerText,
+                button.textContent,
+                button.getAttribute("data-testid")
+            ].map(normalize).filter(Boolean).join(" ");
+            return wanted.has(label)
+                || /stop|cancel|abort|interromp|unterbrech|gestoppt|arr[eê]t|detener|parar|interrumpir/i.test(label);
+        });
+        if (match === undefined)
+            return false;
+        match.click();
+        return true;
+    }, [...labels]).catch(() => false);
+}
+function normalizedControlKey(label) {
+    return label.replace(/\s+/g, " ").trim().toLowerCase();
+}
+function dedupeStrings(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        const trimmed = value.replace(/\s+/g, " ").trim();
+        const key = trimmed.toLowerCase();
+        if (trimmed.length === 0 || seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(trimmed);
+    }
+    return result;
+}
 async function renderedProof(page) {
     return page.evaluate?.(() => ({
         htmlLang: document.documentElement.lang,
@@ -588,7 +957,7 @@ async function appendRecord(path, record) {
 }
 function printCaptureRecord(record, out) {
     if (record.status === "ok") {
-        console.log(`captured ${record.requestedLocale} htmlLang=${record.htmlLang ?? "unknown"} intelligence=${record.intelligenceLabels?.length ?? 0} versions=${record.modelVersionLabels?.length ?? 0} out=${out}`);
+        console.log(`captured ${record.requestedLocale} htmlLang=${record.htmlLang ?? "unknown"} intelligence=${record.intelligenceLabels?.length ?? 0} versions=${record.modelVersionLabels?.length ?? 0} generationStop=${record.generationStopLabels?.length ?? 0} generationStopped=${record.generationStoppedLabels?.length ?? 0} out=${out}`);
     }
     else {
         console.log(`blocked ${record.requestedLocale} htmlLang=${record.htmlLang ?? "unknown"} code=${record.blocker?.code ?? "unknown"} out=${out}`);
@@ -663,7 +1032,7 @@ function wait(ms) {
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
+if (typeof process !== "undefined" && process.argv[1] === fileURLToPath(import.meta.url)) {
     const exitCode = await main();
     process.exitCode = exitCode;
 }

package/dist/src/scripts/capture-surface-profile.d.ts

@@ -0,0 +1,23 @@
+import { detectExperienceFromSnapshot, readSurfaceSnapshot } from "../commands/experience.js";
+import type { BrowserLike, ConfigurationInspectionData, ExistingTabPolicy, SurfaceProfileFixture, SurfaceProfileSupportState } from "../types.js";
+type CaptureRuntime = {
+    agent?: unknown;
+    browser?: BrowserLike;
+};
+type CaptureOptions = {
+    id: string;
+    out: string;
+    locale?: string;
+    region: string;
+    accountScope: string;
+    planScope: string;
+    workspaceScope: string;
+    supportState: SurfaceProfileSupportState;
+    provenance: string;
+    tabId?: string;
+    ifMissing: NonNullable<ExistingTabPolicy["ifMissing"]>;
+};
+export declare function main(argv?: string[], runtime?: CaptureRuntime): Promise<number>;
+export declare function buildSurfaceProfileDraft(options: Pick<CaptureOptions, "id" | "region" | "accountScope" | "planScope" | "workspaceScope" | "supportState" | "provenance">, locale: string, snapshot: Awaited<ReturnType<typeof readSurfaceSnapshot>>, detected: ReturnType<typeof detectExperienceFromSnapshot>, inspection: ConfigurationInspectionData, observedAt?: string): SurfaceProfileFixture;
+export declare function parseArgs(argv: readonly string[]): CaptureOptions;
+export {};