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

package/dist/src/diagnostics/blockers.js

@@ -0,0 +1,299 @@
+import { augmentCommandBlocker, resumeDecisionForBlocker } from "../runner/resume.js";
+const PROFILES = {
+    browser_bridge_unavailable: {
+        title: "Browser bridge unavailable",
+        category: "environment",
+        severity: "blocked",
+        userActionRequired: false,
+        defaultRetryReason: "Retry only after changing the execution environment or bootstrapping the Codex Chrome bridge."
+    },
+    login_required: {
+        title: "Login required",
+        category: "auth",
+        severity: "action_required",
+        userActionRequired: true,
+        defaultRetryReason: "Retry after the user signs in to ChatGPT; do not auto-submit a prompt."
+    },
+    captcha: {
+        title: "Captcha or human verification required",
+        category: "auth",
+        severity: "action_required",
+        userActionRequired: true,
+        defaultRetryReason: "Retry after the user completes the visible verification; do not auto-submit a prompt."
+    },
+    rate_limit: {
+        title: "Rate limited",
+        category: "auth",
+        severity: "action_required",
+        userActionRequired: true,
+        defaultRetryReason: "Retry only after the usage window resets or the user selects a different safe path."
+    },
+    modal: {
+        title: "Modal is blocking the page",
+        category: "runtime",
+        severity: "action_required",
+        userActionRequired: true,
+        defaultRetryReason: "Retry after the blocking modal is dismissed or handled."
+    },
+    permission: {
+        title: "Permission required",
+        category: "permission",
+        severity: "action_required",
+        userActionRequired: true,
+        defaultRetryReason: "Retry after the reported permission setting changes and only if the command is safe to resume."
+    },
+    confirmation: {
+        title: "Confirmation required",
+        category: "user_confirmation",
+        severity: "action_required",
+        userActionRequired: true,
+        defaultRetryReason: "Retry only after the user approves the exact bounded action."
+    },
+    selector_drift: {
+        title: "Selector drift",
+        category: "ui_drift",
+        severity: "blocked",
+        userActionRequired: false,
+        defaultRetryReason: "Do not retry blindly; update selectors/localization or move the visible UI to a supported state."
+    },
+    artifact_unavailable: {
+        title: "Artifact unavailable",
+        category: "artifact",
+        severity: "warning",
+        userActionRequired: false,
+        defaultRetryReason: "Retry only after the artifact appears or the command can safely re-check without resubmitting a prompt."
+    },
+    artifact_selector_drift: {
+        title: "Artifact selector drift",
+        category: "ui_drift",
+        severity: "blocked",
+        userActionRequired: false,
+        defaultRetryReason: "Do not retry blindly; update artifact selectors before resuming."
+    },
+    artifact_download_unavailable: {
+        title: "Artifact download unavailable",
+        category: "download",
+        severity: "warning",
+        userActionRequired: false,
+        defaultRetryReason: "Retry only after a download control appears, or use a safe visible asset fallback if the caller requested it."
+    },
+    download_unavailable: {
+        title: "Download unavailable",
+        category: "download",
+        severity: "warning",
+        userActionRequired: false,
+        defaultRetryReason: "Retry only after a downloadable affordance appears; do not resubmit the prompt just to create one."
+    },
+    upload_failed: {
+        title: "Upload failed",
+        category: "upload",
+        severity: "action_required",
+        userActionRequired: true,
+        defaultRetryReason: "Retry after the upload blocker is fixed and only if the prompt has not already been submitted."
+    },
+    not_found: {
+        title: "Target not found",
+        category: "not_found",
+        severity: "warning",
+        userActionRequired: false,
+        defaultRetryReason: "Retry only after the target changes or the caller relaxes the targeting policy."
+    },
+    unknown: {
+        title: "Unknown blocker",
+        category: "unknown",
+        severity: "blocked",
+        userActionRequired: false,
+        defaultRetryReason: "Inspect the structured blocker and retry only after the cause is understood."
+    }
+};
+export function explainCommandBlocker(resultOrBlocker, options = {}) {
+    const result = isCommandResult(resultOrBlocker) ? resultOrBlocker : undefined;
+    const rawBlocker = result?.blocker ?? (isBlocker(resultOrBlocker) ? resultOrBlocker : undefined);
+    const blocker = rawBlocker === undefined ? undefined : augmentCommandBlocker(rawBlocker);
+    const context = explanationContext(result?.context ?? options.context, options.command);
+    if (blocker === undefined) {
+        const explanation = {
+            kind: "none",
+            title: "No blocker",
+            summary: "The command result does not include a browser-control blocker.",
+            severity: "info",
+            category: "unknown",
+            userActionRequired: false,
+            retry: { safe: false, reason: "There is no blocker-specific retry guidance." },
+            resume: { supported: false, reason: "This result has no resumable browser-control blocker." },
+            remediation: [],
+            nextCommands: options.nextCommands ?? []
+        };
+        if (context !== undefined)
+            explanation.context = context;
+        return { ...explanation, markdown: renderMarkdown(explanation) };
+    }
+    const profile = PROFILES[blocker.kind] ?? PROFILES.unknown;
+    const resume = toResumeGuidance(resumeDecisionForBlocker(blocker, options.stateId), options.command);
+    const retry = retryGuidance(blocker, profile, resume, options.command);
+    const remediation = blocker.remediation ?? profile.defaultRemediation ?? [];
+    const summary = summaryForBlocker(blocker);
+    const base = {
+        kind: blocker.kind,
+        title: profile.title,
+        summary,
+        severity: profile.severity,
+        category: categoryForBlocker(blocker, profile),
+        userActionRequired: profile.userActionRequired || remediation.some(step => step.userActionRequired),
+        retry,
+        resume,
+        remediation,
+        nextCommands: options.nextCommands ?? defaultNextCommands(blocker, options.command, resume)
+    };
+    if (blocker.code !== undefined)
+        base.code = blocker.code;
+    if (context !== undefined)
+        base.context = context;
+    if (blocker.candidates !== undefined)
+        base.candidates = blocker.candidates;
+    if (blocker.diagnostics !== undefined)
+        base.diagnostics = blocker.diagnostics;
+    return { ...base, markdown: renderMarkdown(base) };
+}
+function isCommandResult(value) {
+    return typeof value === "object"
+        && value !== null
+        && "ok" in value
+        && "status" in value
+        && "context" in value;
+}
+function isBlocker(value) {
+    return typeof value === "object"
+        && value !== null
+        && "kind" in value
+        && "message" in value;
+}
+function explanationContext(source, command) {
+    const context = {};
+    if (command !== undefined)
+        context.command = command;
+    if (source?.url !== undefined)
+        context.url = source.url;
+    if (source?.conversationId !== undefined)
+        context.conversationId = source.conversationId;
+    if (source?.tabId !== undefined)
+        context.tabId = source.tabId;
+    return Object.keys(context).length === 0 ? undefined : context;
+}
+function summaryForBlocker(blocker) {
+    const code = blocker.code === undefined ? "" : ` (${blocker.code})`;
+    return `${blocker.kind}${code}: ${blocker.message}`;
+}
+function categoryForBlocker(blocker, profile) {
+    if (blocker.kind === "not_found" && blocker.code?.startsWith("existing_tab_") === true) {
+        return "targeting";
+    }
+    return profile.category;
+}
+function retryGuidance(blocker, profile, resume, command) {
+    if (resume.supported) {
+        const guidance = {
+            safe: true,
+            when: retryWhen(blocker)
+        };
+        if (command !== undefined)
+            guidance.command = command;
+        return guidance;
+    }
+    return { safe: false, reason: profile.defaultRetryReason };
+}
+function retryWhen(blocker) {
+    switch (blocker.kind) {
+        case "permission":
+        case "upload_failed":
+            return "After the reported permission/upload issue is fixed and before any duplicate prompt submission.";
+        case "confirmation":
+            return "After the user approves the exact bounded action.";
+        case "download_unavailable":
+        case "artifact_download_unavailable":
+            return "After the download affordance appears without resubmitting the prompt.";
+        default:
+            return "After the blocker is resolved and the command remains safe to resume.";
+    }
+}
+function toResumeGuidance(decision, command) {
+    if (!decision.supported) {
+        return decision;
+    }
+    const supported = { supported: true };
+    if (decision.stateId !== undefined)
+        supported.stateId = decision.stateId;
+    if (command !== undefined)
+        supported.command = command;
+    return supported;
+}
+function defaultNextCommands(blocker, command, resume) {
+    if (blocker.kind === "browser_bridge_unavailable")
+        return ["session.bootstrap"];
+    if (blocker.kind === "not_found" && blocker.code?.startsWith("existing_tab_") === true) {
+        return command === undefined ? [] : [command];
+    }
+    if (resume.supported && command !== undefined)
+        return [command];
+    return [];
+}
+function renderMarkdown(explanation) {
+    const lines = [
+        `### ${explanation.title}`,
+        "",
+        explanation.summary,
+        "",
+        `- Kind: \`${explanation.kind}\``
+    ];
+    if (explanation.code !== undefined)
+        lines.push(`- Code: \`${explanation.code}\``);
+    lines.push(`- Category: \`${explanation.category}\``);
+    lines.push(`- Severity: \`${explanation.severity}\``);
+    if (explanation.context?.command !== undefined)
+        lines.push(`- Command: \`${explanation.context.command}\``);
+    if (explanation.context?.url !== undefined)
+        lines.push(`- URL: ${explanation.context.url}`);
+    if (explanation.context?.conversationId !== undefined)
+        lines.push(`- Conversation: \`${explanation.context.conversationId}\``);
+    if (explanation.context?.tabId !== undefined)
+        lines.push(`- Tab: \`${explanation.context.tabId}\``);
+    lines.push("");
+    if (explanation.retry.safe) {
+        lines.push(`Retry: safe only ${explanation.retry.when}`);
+    }
+    else {
+        lines.push(`Retry: ${explanation.retry.reason}`);
+    }
+    if (explanation.resume.supported) {
+        const state = explanation.resume.stateId === undefined ? "" : ` with state \`${explanation.resume.stateId}\``;
+        lines.push(`Resume: supported${state}.`);
+    }
+    else {
+        lines.push(`Resume: ${explanation.resume.reason}`);
+    }
+    if (explanation.remediation.length > 0) {
+        lines.push("", "Remediation:");
+        for (const step of explanation.remediation) {
+            lines.push(`- ${step.label}: ${step.instruction}`);
+        }
+    }
+    if ((explanation.candidates?.length ?? 0) > 0) {
+        lines.push("", "Candidates:");
+        for (const candidate of explanation.candidates ?? []) {
+            const role = candidate.role === undefined ? "" : ` (${candidate.role})`;
+            lines.push(`- ${candidate.label}${role}`);
+        }
+    }
+    const existingTab = explanation.diagnostics?.existingTab;
+    if (existingTab !== undefined) {
+        lines.push("", "Existing-tab diagnostics:");
+        lines.push(`- Target: \`${existingTab.requestedTarget.type}\``);
+        lines.push(`- Mismatch: \`${existingTab.mismatchReason}\``);
+        lines.push(`- User-open tab enumeration: \`${existingTab.userOpenTabsAvailable ? "available" : "unavailable"}\``);
+        lines.push(`- ChatGPT tabs seen: \`${existingTab.chatgptTabCount}\``);
+        for (const tab of existingTab.candidateTabs) {
+            lines.push(`- Candidate tab ${tab.id}: ${tab.title ?? "Untitled"} - ${tab.url ?? "unknown URL"}`);
+        }
+    }
+    return lines.join("\n");
+}

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

@@ -0,0 +1,7 @@
+import type { GeneratedArtifact, ListArtifactsArgs, PageLike } from "../types.js";
+export declare function listPageArtifacts(page: PageLike, args?: ListArtifactsArgs): Promise<GeneratedArtifact[]>;
+export declare function countPageArtifacts(page: PageLike, args?: ListArtifactsArgs): Promise<number>;
+export declare function readLatestImageDataUrl(page: PageLike, timeoutMs: number | undefined): Promise<{
+    dataUrl: string;
+    alt?: string;
+} | undefined>;

package/dist/src/dom/artifacts.js

@@ -0,0 +1,198 @@
+import { withTimeout, localGuardTimeout } from "../commands/timeouts.js";
+export async function listPageArtifacts(page, args = {}) {
+    const timeoutMs = localGuardTimeout(args.timeoutMs, 5000);
+    let artifacts;
+    let evaluateError;
+    if (typeof page.evaluate === "function") {
+        artifacts = await withTimeout(page.evaluate(() => {
+            const images = Array.from(document.querySelectorAll("main img"));
+            return images
+                .map((image, index) => {
+                const rect = image.getBoundingClientRect();
+                const style = window.getComputedStyle(image);
+                const width = Math.round(rect.width || image.naturalWidth || image.width || 0);
+                const height = Math.round(rect.height || image.naturalHeight || image.height || 0);
+                const alt = image.getAttribute("alt") ?? undefined;
+                const src = image.currentSrc || image.src || undefined;
+                const ariaLabel = image.getAttribute("aria-label") ?? image.closest("[aria-label]")?.getAttribute("aria-label") ?? undefined;
+                const visible = width > 0
+                    && height > 0
+                    && style.display !== "none"
+                    && style.visibility !== "hidden"
+                    && Number(style.opacity || "1") > 0;
+                const likelyGenerated = visible
+                    && !image.closest("nav, aside, header, footer, form, [contenteditable='true'], textarea")
+                    && (width >= 96
+                        || height >= 96
+                        || /^data:image\//i.test(src ?? "")
+                        || /^blob:/i.test(src ?? "")
+                        || /\b(generated|image|photo|picture)\b/i.test(`${alt ?? ""} ${ariaLabel ?? ""}`));
+                if (!likelyGenerated)
+                    return undefined;
+                const container = image.closest("figure, [data-testid*='image' i], [aria-label*='image' i], [role='group'], [data-testid^='conversation-turn']") ?? image.parentElement;
+                const scopedDownload = container?.querySelector("a[download], button[aria-label*='Download' i], a[aria-label*='Download' i]");
+                const globalDownload = document.querySelector("main button[aria-label*='Download image' i], main a[aria-label*='Download image' i]");
+                const turnNode = image.closest("[data-testid^='conversation-turn']");
+                const artifact = {
+                    kind: "image",
+                    index,
+                    visible,
+                    width,
+                    height,
+                    downloadAvailable: Boolean(scopedDownload ?? globalDownload),
+                    selectorProvenance: "main generated image"
+                };
+                if (alt !== undefined)
+                    artifact.alt = alt;
+                if (ariaLabel !== undefined)
+                    artifact.ariaLabel = ariaLabel;
+                const safeSrc = safeArtifactSrc(src);
+                if (safeSrc !== undefined)
+                    artifact.src = safeSrc;
+                const turnId = turnNode?.getAttribute("data-testid") ?? undefined;
+                if (turnId !== undefined)
+                    artifact.turnId = turnId;
+                return artifact;
+            })
+                .filter((artifact) => artifact !== undefined);
+        }), timeoutMs, "Timed out while inspecting visible ChatGPT artifacts.").catch(error => {
+            evaluateError = error;
+            return undefined;
+        });
+    }
+    if (artifacts === undefined && typeof page.content !== "function" && evaluateError !== undefined) {
+        throw evaluateError;
+    }
+    const filtered = filterArtifacts(artifacts ?? await listArtifactsFromContent(page, timeoutMs), args);
+    return filtered.map((artifact, index) => ({ ...artifact, index }));
+}
+export async function countPageArtifacts(page, args = {}) {
+    return listPageArtifacts(page, args).then(artifacts => artifacts.length);
+}
+export async function readLatestImageDataUrl(page, timeoutMs) {
+    const guardMs = localGuardTimeout(timeoutMs, 5000);
+    if (typeof page.evaluate === "function") {
+        const fromDom = await withTimeout(page.evaluate(async () => {
+            const images = Array.from(document.querySelectorAll("main img"));
+            const candidates = images.filter(image => {
+                const rect = image.getBoundingClientRect();
+                const width = rect.width || image.naturalWidth || image.width || 0;
+                const height = rect.height || image.naturalHeight || image.height || 0;
+                const src = image.currentSrc || image.src || "";
+                const label = `${image.getAttribute("alt") ?? ""} ${image.closest("[aria-label]")?.getAttribute("aria-label") ?? ""}`;
+                return !image.closest("nav, aside, header, footer, form, [contenteditable='true'], textarea")
+                    && (width >= 96 || height >= 96 || /^data:image\//i.test(src) || /^blob:/i.test(src) || /\b(generated|image|photo|picture)\b/i.test(label));
+            });
+            const image = candidates.at(-1);
+            if (image === undefined)
+                return undefined;
+            const src = image.currentSrc || image.src;
+            if (/^data:image\//i.test(src)) {
+                const alt = image.getAttribute("alt") ?? undefined;
+                return alt === undefined ? { dataUrl: src } : { dataUrl: src, alt };
+            }
+            if (/^(blob:|https?:)/i.test(src)) {
+                const response = await fetch(src);
+                const blob = await response.blob();
+                const dataUrl = await new Promise((resolve, reject) => {
+                    const reader = new FileReader();
+                    reader.onload = () => resolve(String(reader.result));
+                    reader.onerror = () => reject(reader.error ?? new Error("FileReader failed."));
+                    reader.readAsDataURL(blob);
+                });
+                const alt = image.getAttribute("alt") ?? undefined;
+                return alt === undefined ? { dataUrl } : { dataUrl, alt };
+            }
+            return undefined;
+        }), guardMs, "Timed out while reading the visible generated image source.").catch(() => undefined);
+        if (fromDom !== undefined)
+            return fromDom;
+    }
+    const html = await readContentWithTimeout(page, guardMs).catch(() => undefined);
+    if (html === undefined)
+        return undefined;
+    const artifact = parseArtifactsFromHtml(html).at(-1);
+    if (artifact?.src === undefined || !/^data:image\//i.test(artifact.src))
+        return undefined;
+    return artifact.alt === undefined
+        ? { dataUrl: artifact.src }
+        : { dataUrl: artifact.src, alt: artifact.alt };
+}
+async function listArtifactsFromContent(page, timeoutMs) {
+    const html = await readContentWithTimeout(page, timeoutMs).catch(() => undefined);
+    return html === undefined ? [] : parseArtifactsFromHtml(html);
+}
+function parseArtifactsFromHtml(html) {
+    const hasDownload = /<a\b[^>]*\sdownload(?:\s|=|>)/i.test(html)
+        || /\baria-label=["'][^"']*download[^"']*["']/i.test(html);
+    const artifacts = [];
+    const imagePattern = /<img\b[^>]*>/gi;
+    let match;
+    while ((match = imagePattern.exec(html)) !== null) {
+        const tag = match[0] ?? "";
+        const src = attr(tag, "src");
+        const alt = attr(tag, "alt");
+        const ariaLabel = attr(tag, "aria-label");
+        const width = numberAttr(tag, "width");
+        const height = numberAttr(tag, "height");
+        const label = `${alt ?? ""} ${ariaLabel ?? ""}`;
+        const likelyGenerated = (width ?? 0) >= 96
+            || (height ?? 0) >= 96
+            || /^data:image\//i.test(src ?? "")
+            || /^blob:/i.test(src ?? "")
+            || /\b(generated|image|photo|picture)\b/i.test(label);
+        if (!likelyGenerated)
+            continue;
+        const artifact = {
+            kind: "image",
+            index: artifacts.length,
+            visible: true,
+            downloadAvailable: hasDownload,
+            selectorProvenance: "main generated image"
+        };
+        const safeSrc = safeArtifactSrc(src);
+        if (safeSrc !== undefined)
+            artifact.src = safeSrc;
+        if (alt !== undefined)
+            artifact.alt = alt;
+        if (ariaLabel !== undefined)
+            artifact.ariaLabel = ariaLabel;
+        if (width !== undefined)
+            artifact.width = width;
+        if (height !== undefined)
+            artifact.height = height;
+        artifacts.push(artifact);
+    }
+    return artifacts;
+}
+function filterArtifacts(artifacts, args) {
+    const kind = args.kind ?? "image";
+    const max = args.max ?? artifacts.length;
+    return artifacts
+        .filter(artifact => artifact.kind === kind)
+        .slice(-max);
+}
+async function readContentWithTimeout(page, timeoutMs) {
+    if (typeof page.content !== "function")
+        return "";
+    return withTimeout(page.content(), timeoutMs, "Timed out while reading ChatGPT page content.");
+}
+function attr(tag, name) {
+    const match = new RegExp(`\\b${name}=(["'])(.*?)\\1`, "i").exec(tag);
+    return match?.[2];
+}
+function numberAttr(tag, name) {
+    const value = attr(tag, name);
+    if (value === undefined)
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function safeArtifactSrc(src) {
+    if (src === undefined)
+        return undefined;
+    if (/^https:\/\/chatgpt\.com\/backend-api\/estuary\/content\b/i.test(src)) {
+        return undefined;
+    }
+    return src;
+}

package/dist/src/dom/generation-state.d.ts

@@ -0,0 +1,8 @@
+import type { PageLike } from "../types.js";
+export type AssistantGenerationState = {
+    active: boolean;
+    stopped: boolean;
+    signals: string[];
+};
+export declare function readAssistantGenerationState(page: PageLike): Promise<AssistantGenerationState>;
+export declare function latestAssistantTurnHasResponseActions(page: PageLike): Promise<boolean>;

package/dist/src/dom/generation-state.js

@@ -0,0 +1,103 @@
+import { copyResponseButtons } from "./selectors.js";
+import { localeLabels } from "./locale-labels.js";
+const EMPTY_GENERATION_STATE = {
+    active: false,
+    stopped: false,
+    signals: []
+};
+export async function readAssistantGenerationState(page) {
+    if (typeof page.evaluate === "function") {
+        return page.evaluate((args) => {
+            const normalize = (value) => (value ?? "").trim().toLowerCase();
+            const isVisible = (element) => {
+                const style = window.getComputedStyle(element);
+                return style.display !== "none"
+                    && style.visibility !== "hidden"
+                    && style.opacity !== "0"
+                    && element.getAttribute("aria-hidden") !== "true";
+            };
+            const visibleButtons = Array.from(document.querySelectorAll("button"))
+                .filter((button) => isVisible(button)
+                && button.disabled !== true
+                && button.getAttribute("aria-disabled") !== "true");
+            const buttonTexts = visibleButtons
+                .map(button => [
+                button.innerText,
+                button.textContent,
+                button.getAttribute("aria-label"),
+                button.getAttribute("title")
+            ].map(normalize).filter(Boolean).join(" "))
+                .filter(Boolean);
+            const bodyText = normalize(document.body?.innerText);
+            const haystacks = [bodyText, ...buttonTexts];
+            const matchingSignals = (phrases) => haystacks.flatMap(text => phrases
+                .map(phrase => phrase.toLowerCase())
+                .filter(phrase => text.includes(phrase)));
+            const activeSignals = matchingSignals(args.stop);
+            const stoppedSignals = matchingSignals(args.stopped);
+            return {
+                active: activeSignals.length > 0,
+                stopped: stoppedSignals.length > 0,
+                signals: [...new Set([...activeSignals, ...stoppedSignals, ...buttonTexts.filter(text => /stop|cancel|stopped|answering|thinking/i.test(text))])].slice(0, 5)
+            };
+        }, {
+            stop: [...localeLabels.stopControl],
+            stopped: [...localeLabels.stoppedAssistant]
+        }).catch(() => EMPTY_GENERATION_STATE);
+    }
+    if (typeof page.content === "function") {
+        const html = await page.content().catch(() => "");
+        return generationStateFromText(html);
+    }
+    return EMPTY_GENERATION_STATE;
+}
+export async function latestAssistantTurnHasResponseActions(page) {
+    if (typeof page.evaluate === "function") {
+        const scoped = await page.evaluate((phrases) => {
+            const turns = Array.from(document.querySelectorAll("[data-testid^='conversation-turn']"));
+            if (turns.length === 0)
+                return undefined;
+            const latestTurn = turns.reverse().find(turn => turn.querySelector("[data-message-author-role='assistant']") !== null);
+            if (latestTurn === undefined)
+                return false;
+            const actionText = Array.from(latestTurn.querySelectorAll("button"))
+                .map(button => [
+                button.innerText,
+                button.textContent,
+                button.getAttribute("aria-label"),
+                button.getAttribute("title")
+            ].filter(Boolean).join(" "))
+                .join(" ")
+                .toLowerCase();
+            return phrases.some(phrase => actionText.includes(phrase.toLowerCase()));
+        }, [...localeLabels.responseActions]).catch(() => undefined);
+        if (scoped !== undefined) {
+            return scoped;
+        }
+    }
+    try {
+        const copyButtons = copyResponseButtons(page);
+        const count = await copyButtons.count?.();
+        if (count !== undefined) {
+            return count > 0;
+        }
+        return await copyButtons.isVisible?.() === true;
+    }
+    catch {
+        if (typeof page.content === "function") {
+            const html = await page.content().catch(() => "");
+            return localeLabels.responseActions.some(phrase => html.toLowerCase().includes(phrase.toLowerCase()));
+        }
+        return true;
+    }
+}
+function generationStateFromText(text) {
+    const normalized = text.toLowerCase();
+    const activeSignals = localeLabels.stopControl.filter(phrase => normalized.includes(phrase.toLowerCase()));
+    const stoppedSignals = localeLabels.stoppedAssistant.filter(phrase => normalized.includes(phrase.toLowerCase()));
+    return {
+        active: activeSignals.length > 0,
+        stopped: stoppedSignals.length > 0,
+        signals: [...activeSignals, ...stoppedSignals].slice(0, 5)
+    };
+}

package/dist/src/dom/locale/am.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Amharic (am). Captured 2026-06-09 against a live chatgpt.com session
+ * (html lang=am, Google Translate confirmed off).
+ *
+ * Some non-Intelligence surfaces may still fall back to English + `selector_drift`.
+ *
+ * Intelligence picker labels updated 2026-06-10 from a visible ChatGPT Pro session.
+ */
+export declare const am: {
+    composerTextbox: string[];
+    sendButton: string[];
+    searchChatsButton: string[];
+    searchChatsPlaceholder: string[];
+    newChat: string[];
+    addFilesButton: string[];
+    addFilesOpenerCandidates: string[];
+    addPhotosFilesMenuItem: string[];
+    copyResponse: string[];
+    modeLabels: string[];
+    modeOpenerExtra: string[];
+    tools: {
+        web_search: string[];
+        deep_research: string[];
+        create_image: string[];
+    };
+    signedInMarkers: string[];
+    responseActions: string[];
+};

package/dist/src/dom/locale/am.js

@@ -0,0 +1,28 @@
+/**
+ * Amharic (am). Captured 2026-06-09 against a live chatgpt.com session
+ * (html lang=am, Google Translate confirmed off).
+ *
+ * Some non-Intelligence surfaces may still fall back to English + `selector_drift`.
+ *
+ * Intelligence picker labels updated 2026-06-10 from a visible ChatGPT Pro session.
+ */
+export const am = {
+    composerTextbox: ["ከChatGPT ጋር ይወያዩ"],
+    sendButton: ["ጥያቄ ላክ"],
+    searchChatsButton: ["ውይይቶችን ፈልግ"],
+    searchChatsPlaceholder: ["ውይይቶችን ፈልግ..."],
+    newChat: ["አዲስ ውይይት"],
+    addFilesButton: ["ፋይሎችን ያክሉ እና ሌሎችም"],
+    addFilesOpenerCandidates: ["ፋይሎችን ያክሉ እና ሌሎችም"],
+    addPhotosFilesMenuItem: ["ፎቶዎችን እና ፋይሎችን ያክሉ"],
+    copyResponse: ["ምላሹን ይቅዱ"],
+    modeLabels: ["ፈጣን", "መካከለኛ", "ከፍተኛ", "እጅግ ከፍተኛ"],
+    modeOpenerExtra: ["ያዋቅሩ"],
+    tools: {
+        web_search: ["የድር ፍለጋ"],
+        deep_research: ["ጥልቅ ምርምር"],
+        create_image: ["ምስል ፍጠር"],
+    },
+    signedInMarkers: ["አዲስ ውይይት", "ውይይቶችን ፈልግ", "የቅርብ ጊዜዎች", "ላይብረሪ", "ፕሮጀክቶች", "ከChatGPT ጋር ይወያዩ"],
+    responseActions: ["ምላሹን ይቅዱ"],
+};