codex-chatgpt-control 0.5.1-alpha.1 → 0.5.1-alpha.2

package/dist/src/commands/messages.d.ts

@@ -1,5 +1,5 @@
 import { type AssistantGenerationState } from "../dom/generation-state.js";
-import type { AskArgs, AskReadData, CommandResult, ComposeArgs, ComposeData, MessageStatusArgs, MessageStatusData, ReadLatestArgs, ReadLatestData, RuntimeEnv, SubmitArgs, SubmitData, WaitAndReadArgs, WaitArgs, WaitData } from "../types.js";
+import type { AskArgs, AskReadData, CommandResult, ComposeArgs, ComposeData, MessageStatusArgs, MessageStatusData, ReadLatestArgs, ReadLatestData, RuntimeEnv, SubmitArgs, SubmitData, StopGenerationArgs, StopGenerationData, WaitAndReadArgs, WaitArgs, WaitData } from "../types.js";
 export type CompletionSnapshot = {
     textStableForMs: number;
     stableMs: number;
@@ -10,6 +10,7 @@ export type CompletionSnapshot = {
 export declare function isResponseComplete(snapshot: CompletionSnapshot): boolean;
 export declare function composeMessage(env: RuntimeEnv, args: ComposeArgs): Promise<CommandResult<ComposeData>>;
 export declare function submitMessage(env: RuntimeEnv, args?: SubmitArgs): Promise<CommandResult<SubmitData>>;
+export declare function stopGeneration(env: RuntimeEnv, args?: StopGenerationArgs): Promise<CommandResult<StopGenerationData>>;
 export declare function waitForMessage(env: RuntimeEnv, args?: WaitArgs): Promise<CommandResult<WaitData>>;
 export declare function readLatest(env: RuntimeEnv, args?: ReadLatestArgs): Promise<CommandResult<ReadLatestData>>;
 export declare function messageStatus(env: RuntimeEnv, args?: MessageStatusArgs): Promise<CommandResult<MessageStatusData>>;

package/dist/src/commands/messages.js

@@ -3,18 +3,20 @@ import { readPageState } from "../browser/page-state.js";
 import { resultError, resultOk } from "../errors.js";
 import { EMPTY_GENERATION_STATE, latestAssistantTurnHasResponseActions, readAssistantGenerationState } from "../dom/generation-state.js";
 import { countPageMessages, isTransientAssistantText, readLatestMessage, readLatestMessageText, readLatestMessageTextSnapshot, readMessages } from "../dom/messages.js";
-import { composerTextbox, copyResponseButtons, sendButton } from "../dom/selectors.js";
+import { composerTextbox, copyResponseButtons, sendButton, stopGenerationButton } from "../dom/selectors.js";
 import { readWaitDomSnapshot, waitTextMetadata } from "../dom/wait-snapshot.js";
 import { normalizeLineBreaks, normalizeWhitespace } from "../dom/visible-text.js";
 import { contextFromPage } from "./context.js";
-import { createDeadline } from "./deadline.js";
+import { createDeadline, remainingMs } from "./deadline.js";
 import { withCommandOutputText } from "./output.js";
 import { createSingleFlightProbe } from "./probes.js";
 import { ensurePage } from "./session.js";
+import { withTimeout } from "./timeouts.js";
 export function isResponseComplete(snapshot) {
     return snapshot.latestText.trim().length > 0
         && !isTransientAssistantText(snapshot.latestText)
         && snapshot.textStableForMs >= snapshot.stableMs
+        && snapshot.generation.observed
         && !snapshot.generation.active
         && !snapshot.generation.stopped
         && snapshot.hasResponseActions;
@@ -125,6 +127,311 @@ export async function submitMessage(env, args = {}) {
         return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
     }
 }
+export async function stopGeneration(env, args = {}) {
+    const timeoutMs = Math.max(1, args.timeoutMs ?? 5_000);
+    const deadline = createDeadline(timeoutMs);
+    if (args.confirmStop !== true) {
+        return {
+            ok: false,
+            status: "needs_confirmation",
+            warnings: [],
+            blocker: {
+                kind: "confirmation",
+                code: "stop_generation_confirmation_required",
+                fieldPath: "confirmStop",
+                message: "Stopping the visible ChatGPT response requires an explicit caller decision.",
+                resumable: true
+            },
+            context: env.page === undefined
+                ? { timestamp: new Date().toISOString() }
+                : await stopContext(env.page, deadline)
+        };
+    }
+    let boot;
+    try {
+        boot = await withinStopDeadline(deadline, () => ensurePage(env, { minimalContext: true }), "ChatGPT page verification");
+    }
+    catch (error) {
+        return stopDeadlineResult(error);
+    }
+    if (!boot.ok)
+        return boot;
+    const page = env.page;
+    const warnings = new Set();
+    let stopActivationStarted = false;
+    let beforeActivation;
+    try {
+        const beforeProbeTimeoutMs = Math.min(1_000, Math.max(1, remainingMs(deadline)));
+        const beforeResult = await readStopGenerationState(page, deadline, beforeProbeTimeoutMs);
+        addWarnings(warnings, beforeResult.warnings);
+        if (!beforeResult.ok || !beforeResult.value.observed) {
+            if (remainingMs(deadline) <= 0) {
+                return stopDeadlineResult(undefined, undefined, [...warnings]);
+            }
+            return {
+                ok: false,
+                status: "blocked",
+                warnings: [...warnings],
+                blocker: {
+                    kind: "selector_drift",
+                    code: "stop_generation_state_unavailable",
+                    message: "ChatGPT generation state could not be inspected safely, so no control was clicked.",
+                    resumable: true
+                },
+                context: await stopContext(page, deadline)
+            };
+        }
+        const before = beforeResult.value;
+        beforeActivation = before;
+        if (!before.active) {
+            return resultOk({
+                wasGenerating: false,
+                stopped: false,
+                signalsBefore: before.signals,
+                signalsAfter: before.signals
+            }, await stopContext(page, deadline), [...warnings]);
+        }
+        const resolution = await resolveStopControl(page, deadline);
+        if (!resolution.ok) {
+            return {
+                ok: false,
+                status: "blocked",
+                data: { wasGenerating: true, stopped: false, signalsBefore: before.signals, signalsAfter: before.signals },
+                warnings: [...warnings],
+                blocker: {
+                    kind: "selector_drift",
+                    code: resolution.code,
+                    message: resolution.message,
+                    resumable: true
+                },
+                context: await stopContext(page, deadline)
+            };
+        }
+        stopActivationStarted = true;
+        await withinNativeStopDeadline(deadline, timeoutMs => resolution.control.click?.({ timeoutMs })
+            ?? Promise.reject(new Error("The resolved Stop control does not support click().")), "Stop control click");
+        let after = EMPTY_GENERATION_STATE;
+        while (remainingMs(deadline) > 0) {
+            const afterProbeTimeoutMs = Math.min(1_000, Math.max(1, remainingMs(deadline)));
+            const afterResult = await readStopGenerationState(page, deadline, afterProbeTimeoutMs);
+            addWarnings(warnings, afterResult.warnings);
+            if (afterResult.ok) {
+                after = afterResult.value;
+                if (after.observed && !after.active) {
+                    return resultOk({
+                        wasGenerating: true,
+                        stopped: true,
+                        signalsBefore: before.signals,
+                        signalsAfter: after.signals
+                    }, await stopContext(page, deadline), [...warnings]);
+                }
+            }
+            await sleepWithinDeadline(page, deadline, 100);
+        }
+        const data = {
+            wasGenerating: true,
+            stopped: false,
+            signalsBefore: before.signals,
+            signalsAfter: after.signals
+        };
+        return stopDeadlineResult(undefined, data, [...warnings]);
+    }
+    catch (error) {
+        if (remainingMs(deadline) <= 0 || error instanceof StopDeadlineError) {
+            const data = stopActivationStarted && beforeActivation !== undefined
+                ? {
+                    wasGenerating: true,
+                    stopped: false,
+                    signalsBefore: beforeActivation.signals,
+                    signalsAfter: beforeActivation.signals
+                }
+                : undefined;
+            return stopDeadlineResult(error, data, [...warnings]);
+        }
+        return resultError(error instanceof Error ? error : new Error(String(error)), await stopContext(page, deadline));
+    }
+}
+async function readStopGenerationState(page, deadline, capMs) {
+    const timeoutMs = Math.min(capMs, remainingMs(deadline));
+    if (timeoutMs <= 0) {
+        return {
+            ok: false,
+            timedOut: true,
+            warnings: ["Skipped generation state DOM probe because no deadline budget remained."]
+        };
+    }
+    try {
+        // readAssistantGenerationState propagates this one budget through its
+        // evaluate/content fallbacks. Await it directly so no browser request is
+        // abandoned behind an SDK-side Promise.race.
+        const value = await readAssistantGenerationState(page, { timeoutMs });
+        return { ok: true, value, warnings: [] };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            warnings: [`generation state DOM probe failed: ${error instanceof Error ? error.message : String(error)}`]
+        };
+    }
+}
+async function resolveStopControl(page, deadline) {
+    const candidates = stopGenerationButton(page);
+    if (typeof candidates.count !== "function") {
+        return {
+            ok: false,
+            code: "stop_generation_control_unavailable",
+            message: "ChatGPT is generating, but the Stop-control candidate set could not be enumerated safely."
+        };
+    }
+    const count = await stopControlCount(candidates, deadline);
+    if (count === 0) {
+        return {
+            ok: false,
+            code: "stop_generation_control_unavailable",
+            message: "ChatGPT is generating, but no visible Stop control was found."
+        };
+    }
+    if (count > 8) {
+        return {
+            ok: false,
+            code: "stop_generation_control_ambiguous",
+            message: `ChatGPT exposed ${count} Stop-control candidates; refusing to choose among an unexpectedly broad set.`
+        };
+    }
+    const eligible = [];
+    for (let index = 0; index < count; index += 1) {
+        const control = count === 1
+            ? candidates
+            : typeof candidates.nth === "function"
+                ? candidates.nth(index)
+                : undefined;
+        if (control === undefined || typeof control.evaluate !== "function") {
+            continue;
+        }
+        const evaluationTimeoutMs = Math.min(1_000, Math.max(1, remainingMs(deadline)));
+        const scoped = await withinNativeStopDeadline(deadline, timeoutMs => control.evaluate((element) => {
+            const button = element;
+            if (button.closest("[hidden], [inert], [aria-hidden='true']") !== null)
+                return false;
+            if (button.disabled || button.getAttribute("aria-disabled") === "true")
+                return false;
+            const visible = (node) => {
+                if (node.hidden || node.closest("[hidden], [inert], [aria-hidden='true']") !== null)
+                    return false;
+                const style = window.getComputedStyle(node);
+                const rect = node.getBoundingClientRect();
+                return style.display !== "none"
+                    && style.visibility !== "hidden"
+                    && style.opacity !== "0"
+                    && style.pointerEvents !== "none"
+                    && (rect.width > 0 || rect.height > 0);
+            };
+            const textboxes = Array.from(document.querySelectorAll("textarea, [contenteditable='true'], [role='textbox']")).filter(visible);
+            const activeComposers = [...new Set(textboxes
+                    .map(textbox => textbox.closest("form")
+                    ?? textbox.closest("[data-testid*='composer' i]")
+                    ?? textbox.closest("[aria-label*='composer' i]")
+                    ?? textbox.closest("[class*='composer' i]"))
+                    .filter((value) => value !== null))];
+            return activeComposers.length === 1 && activeComposers[0].contains(button);
+        }, undefined, { timeoutMs }), `Stop control ${index + 1} visibility and scope check`, evaluationTimeoutMs);
+        if (scoped)
+            eligible.push(control);
+    }
+    if (eligible.length === 1) {
+        return { ok: true, control: eligible[0] };
+    }
+    if (eligible.length > 1) {
+        return {
+            ok: false,
+            code: "stop_generation_control_ambiguous",
+            message: `ChatGPT exposed ${eligible.length} visible Stop controls in active composer regions; no control was clicked.`
+        };
+    }
+    return {
+        ok: false,
+        code: "stop_generation_control_unavailable",
+        message: "ChatGPT is generating, but no uniquely scoped visible Stop control could be activated."
+    };
+}
+async function stopControlCount(candidates, deadline) {
+    if (typeof candidates.allTextContents === "function") {
+        const values = await withinNativeStopDeadline(deadline, timeoutMs => candidates.allTextContents({ timeoutMs }), "Stop control enumeration", 1_000);
+        return values.length;
+    }
+    return withinStopDeadline(deadline, () => candidates.count(), "Stop control enumeration");
+}
+async function withinStopDeadline(deadline, operation, label) {
+    const budget = remainingMs(deadline);
+    if (budget <= 0)
+        throw new StopDeadlineError(label);
+    try {
+        return await withTimeout(operation(), budget, `${label} exceeded the messages.stop deadline.`);
+    }
+    catch (error) {
+        if (remainingMs(deadline) <= 0)
+            throw new StopDeadlineError(label);
+        throw error;
+    }
+}
+async function withinNativeStopDeadline(deadline, operation, label, capMs = 2_000) {
+    const timeoutMs = Math.min(capMs, remainingMs(deadline));
+    if (timeoutMs <= 0)
+        throw new StopDeadlineError(label);
+    try {
+        // The Chrome bridge owns this timeout. Unlike Promise.race, a native
+        // timeout terminates the browser request instead of abandoning it in flight.
+        return await operation(timeoutMs);
+    }
+    catch (error) {
+        if (remainingMs(deadline) <= 0 || isNativeBrowserTimeout(error)) {
+            throw new StopDeadlineError(label);
+        }
+        throw error;
+    }
+}
+function isNativeBrowserTimeout(error) {
+    return error instanceof Error && /timed?\s*out|timeout/i.test(error.message);
+}
+async function sleepWithinDeadline(_page, deadline, requestedMs) {
+    const waitMs = Math.min(requestedMs, Math.max(0, remainingMs(deadline) - 1));
+    if (waitMs <= 0)
+        return;
+    // Polling does not require a browser round trip. A host timer cannot leave a
+    // bridge request stranded after the Stop deadline.
+    await new Promise(resolve => setTimeout(resolve, waitMs));
+}
+async function stopContext(page, _deadline) {
+    return contextFromPage(page, {}, { minimal: true });
+}
+function stopDeadlineResult(error, data, warnings = []) {
+    const message = data?.wasGenerating === true
+        ? "Stop activation reached its browser-native deadline and was terminated, but the click may already have taken effect. Inspect the visible generation state and do not retry automatically."
+        : "ChatGPT generation could not be inspected and stopped before the single operation deadline.";
+    const result = {
+        ok: false,
+        status: "timeout",
+        warnings: error === undefined
+            ? warnings
+            : [...warnings, error instanceof Error ? error.message : String(error)],
+        blocker: {
+            kind: "selector_drift",
+            code: data?.wasGenerating === true ? "stop_generation_unverified" : "stop_generation_deadline_exhausted",
+            message,
+            resumable: data?.wasGenerating !== true
+        },
+        context: { timestamp: new Date().toISOString() }
+    };
+    if (data !== undefined)
+        result.data = data;
+    return result;
+}
+class StopDeadlineError extends Error {
+    constructor(label) {
+        super(`${label} could not complete before the messages.stop deadline.`);
+        this.name = "StopDeadlineError";
+    }
+}
 async function clickSendControl(page) {
     try {
         await sendButton(page).click?.();
@@ -355,6 +662,7 @@ export async function waitForMessage(env, args = {}) {
             && snapshot.text.length > 0
             && !snapshot.text.transient
             && Date.now() - lastChangedAt >= stableMs
+            && snapshot.generation.observed
             && !snapshot.generation.active
             && !snapshot.generation.stopped
             && hasResponseActions;