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

package/dist/src/commands/modes.js

@@ -63,7 +63,8 @@ export async function setMode(env, args) {
             return selectorDrift(page, "No unique ChatGPT mode menu opener was found.");
         }
         await page.waitForTimeout?.(250);
-        const candidates = await enumerateVisibleMenuItems(page);
+        let candidates = await enumerateVisibleMenuItems(page);
+        const observedCandidates = [...candidates];
         const selected = [];
         if (requested.length > 0 && shouldRejectAsWrongModeMenu(candidates)) {
             const candidateLabels = candidates.map(candidate => candidate.label);
@@ -76,9 +77,20 @@ export async function setMode(env, args) {
             };
         }
         for (const request of requested) {
-            const match = findModeMenuItem(candidates, request);
+            let match = findModeMenuItem(candidates, request);
+            if (match === undefined) {
+                const sliderSelection = await selectModeWithPowerSlider(page, request);
+                if (sliderSelection !== undefined) {
+                    selected.push(sliderSelection);
+                    continue;
+                }
+                const nested = await openEffortSubmenu(page, candidates, request);
+                observedCandidates.push(...nested);
+                candidates = nested;
+                match = findModeMenuItem(candidates, request);
+            }
             if (match === undefined) {
-                const candidateLabels = candidates.map(candidate => candidate.label);
+                const candidateLabels = dedupeLabels(observedCandidates.map(candidate => candidate.label));
                 return {
                     ok: false,
                     status: "unsupported",
@@ -87,12 +99,12 @@ export async function setMode(env, args) {
                     context: await contextFromPage(page)
                 };
             }
-            if (!await clickMenuItem(page, match.label)) {
+            if (!await clickResolvedMenuItem(page, match)) {
                 return selectorDrift(page, `Mode option "${match.label}" was visible but could not be clicked.`, candidates.map(candidate => candidate.label));
             }
             selected.push(match.label);
         }
-        let candidateLabels = candidates.map(candidate => candidate.label);
+        let candidateLabels = dedupeLabels(observedCandidates.map(candidate => candidate.label));
         if (requestedVersion !== undefined) {
             const versionResult = await selectModelVersion(page, requestedVersion, candidates, args.timeoutMs ?? 30000);
             candidateLabels = dedupeLabels([...candidateLabels, ...versionResult.candidates]);
@@ -114,6 +126,87 @@ export async function setMode(env, args) {
         return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
     }
 }
+/**
+ * Chat's compact picker exposes the five canonical intelligence levels as an
+ * ARIA slider. Use it only when its visible min/max/current metadata exactly
+ * matches that five-step scale, and accept the move only when the composer
+ * visibly echoes the requested label. The Advanced submenu remains the
+ * fallback for every unrecognized shape.
+ */
+async function selectModeWithPowerSlider(page, request) {
+    const wanted = request.modeId === undefined
+        ? undefined
+        : CANONICAL_INTELLIGENCE_ORDER.get(request.modeId);
+    const slider = page.locator?.("[role='slider'][aria-valuemin='0'][aria-valuemax='4']");
+    if (wanted === undefined
+        || slider?.count === undefined
+        || slider.evaluate === undefined
+        || slider.press === undefined
+        || slider.isVisible === undefined
+        || !await slider.isVisible().catch(() => false)
+        || await slider.count().catch(() => 0) !== 1) {
+        return undefined;
+    }
+    const state = await slider.evaluate(element => ({
+        min: Number(element.getAttribute("aria-valuemin")),
+        max: Number(element.getAttribute("aria-valuemax")),
+        now: Number(element.getAttribute("aria-valuenow"))
+    })).catch(() => undefined);
+    if (state === undefined
+        || state.min !== 0
+        || state.max !== CANONICAL_INTELLIGENCE_ORDER.size - 1
+        || !Number.isInteger(state.now)
+        || state.now < state.min
+        || state.now > state.max) {
+        return undefined;
+    }
+    const key = wanted > state.now ? "ArrowRight" : "ArrowLeft";
+    for (let step = 0; step < Math.abs(wanted - state.now); step += 1) {
+        await slider.press(key);
+    }
+    await page.waitForTimeout?.(150);
+    return findUniqueVisibleLabelForRequest(await visibleModeButtonLabelList(page), request);
+}
+/**
+ * Current Chat exposes the intelligence choices inside an Advanced "Effort <value>"
+ * submenu.  Only traverse a uniquely labelled visible Effort/Intelligence row and
+ * only accept the submenu when it contains the exact requested mode.  This keeps the
+ * legacy flat picker working while avoiding any inference from the five-position
+ * power slider.
+ */
+async function openEffortSubmenu(page, rootItems, request) {
+    const axisLabels = [
+        ...localeLabels.configurationAxes.effort,
+        ...localeLabels.configurationAxes.intelligence,
+    ].map(normalizeForLabelMatch);
+    const effortRows = (items) => items.filter(item => {
+        if (item.role === "menuitemradio")
+            return false;
+        const normalized = normalizeForLabelMatch(item.label);
+        return axisLabels.some(axis => normalized === axis || normalized.startsWith(`${axis} `));
+    });
+    let visibleRootItems = rootItems;
+    let rows = effortRows(visibleRootItems);
+    if (rows.length === 0) {
+        const advancedLabels = localeLabels.configurationAxes.advanced.map(normalizeForLabelMatch);
+        const advancedRows = visibleRootItems.filter(item => {
+            const normalized = normalizeForLabelMatch(item.label);
+            return advancedLabels.some(label => normalized === label || visibleLabelMatches(item.label, label));
+        });
+        if (advancedRows.length !== 1 || !await clickResolvedMenuItem(page, advancedRows[0])) {
+            return [];
+        }
+        await page.waitForTimeout?.(250);
+        visibleRootItems = await enumerateVisibleMenuItems(page);
+        rows = effortRows(visibleRootItems);
+    }
+    if (rows.length !== 1 || !await clickResolvedMenuItem(page, rows[0])) {
+        return [];
+    }
+    await page.waitForTimeout?.(250);
+    const nested = await enumerateVisibleMenuItems(page);
+    return findModeMenuItem(nested, request) === undefined ? [] : nested;
+}
 /**
  * Post-condition check: after clicking mode rows, the composer's mode-labelled controls
  * should reflect the requested selection. A mismatch does not fail the command — some
@@ -216,7 +309,7 @@ export async function selectTool(env, args) {
                 context: await contextFromPage(page)
             };
         }
-        if (!await clickMenuItem(page, match.label)) {
+        if (!await clickMenuItem(page, match)) {
             return selectorDrift(page, `Tool "${match.label}" was visible but could not be clicked.`, candidates.map(candidate => candidate.label));
         }
         return resultOk({ selected: match.label, candidates: candidates.map(candidate => candidate.label) }, await contextFromPage(page));
@@ -295,25 +388,24 @@ function shouldRejectAsWrongModeMenu(items) {
     }
     return items.some(item => isThreadActionLabel(item.label));
 }
-async function clickMenuItem(page, label) {
-    if (await clickModelSwitcherMenuItem(page, label)) {
+async function clickMenuItem(page, item) {
+    if (await clickModelSwitcherMenuItem(page, item)) {
         return true;
     }
-    if (await clickMenuItemByPointer(page, label)) {
+    if (await clickMenuItemByPointer(page, item)) {
         return true;
     }
-    if (await clickMenuItemByDom(page, label)) {
-        return true;
-    }
-    const roleLocator = page.locator?.("[role='menuitem'], [role='menuitemradio'], [role='option']")?.filter?.({ hasText: label });
-    if (await clickIfUnique(roleLocator)) {
-        return true;
+    if (item.role !== undefined) {
+        const accessibleName = item.ariaLabel ?? item.label;
+        if (await clickIfUniqueMenuControl(page.getByRole?.(item.role, { name: accessibleName, exact: true }), item))
+            return true;
     }
-    const textLocator = page.getByText?.(label, { exact: true });
-    return clickIfUnique(textLocator);
+    const roleLocator = page.locator?.("[role='menuitem'], [role='menuitemradio'], [role='option']")
+        ?.filter?.({ hasText: new RegExp(`^\\s*${escapeRegExp(item.label)}\\s*$`, "i") });
+    return clickIfUniqueMenuControl(roleLocator, item);
 }
-async function clickMenuItemByPointer(page, label) {
-    const point = await menuItemCenter(page, { label });
+async function clickMenuItemByPointer(page, item) {
+    const point = await menuItemCenter(page, item);
     if (point === undefined) {
         return false;
     }
@@ -328,12 +420,12 @@ async function clickMenuItemByPointer(page, label) {
     }
     return false;
 }
-async function clickModelSwitcherMenuItem(page, label) {
+async function clickModelSwitcherMenuItem(page, item) {
     if (typeof page.evaluate !== "function" || typeof page.locator !== "function") {
         return false;
     }
     const testId = await page.evaluate((wanted) => {
-        const normalizedWanted = wanted.replace(/\s+/g, " ").trim().toLowerCase();
+        const normalizedWanted = wanted.label.replace(/\s+/g, " ").trim().toLowerCase();
         const candidates = Array.from(document.querySelectorAll("[data-testid^='model-switcher-']"));
         const matches = candidates
             .filter(node => {
@@ -341,35 +433,19 @@ async function clickModelSwitcherMenuItem(page, label) {
             const candidateTestId = element.getAttribute("data-testid") ?? "";
             if (candidateTestId.endsWith("-effort"))
                 return false;
+            if (wanted.testId !== undefined && candidateTestId !== wanted.testId)
+                return false;
             const text = (element.innerText ?? element.textContent ?? "").replace(/\s+/g, " ").trim().toLowerCase();
             return text === normalizedWanted;
         })
             .map(node => node.getAttribute("data-testid"))
             .filter((value) => value !== null);
         return matches.length === 1 ? matches[0] : undefined;
-    }, label).catch(() => undefined);
+    }, item.testId === undefined ? { label: item.label } : { label: item.label, testId: item.testId }).catch(() => undefined);
     if (testId === undefined) {
         return false;
     }
-    return clickIfUnique(page.locator(`[data-testid="${escapeAttributeValue(testId)}"]`));
-}
-async function clickMenuItemByDom(page, label) {
-    if (typeof page.evaluate !== "function") {
-        return false;
-    }
-    return page.evaluate((wanted) => {
-        const normalizedWanted = wanted.replace(/\s+/g, " ").trim().toLowerCase();
-        const candidates = Array.from(document.querySelectorAll("[role='menuitem'], [role='menuitemradio'], [role='option']"));
-        const matches = candidates.filter(node => {
-            const element = node;
-            const text = (element.innerText ?? element.textContent ?? "").replace(/\s+/g, " ").trim().toLowerCase();
-            return text === normalizedWanted;
-        });
-        if (matches.length !== 1)
-            return false;
-        matches[0].click();
-        return true;
-    }, label).catch(() => false);
+    return clickIfUniqueMenuControl(page.locator(`[data-testid="${escapeAttributeValue(testId)}"]`), item);
 }
 async function clickIfUnique(locator) {
     if (locator === undefined || typeof locator.count !== "function" || typeof locator.click !== "function") {
@@ -382,6 +458,46 @@ async function clickIfUnique(locator) {
     await locator.click();
     return true;
 }
+async function clickIfUniqueMenuControl(locator, item) {
+    if (locator === undefined
+        || typeof locator.count !== "function"
+        || typeof locator.evaluate !== "function"
+        || typeof locator.click !== "function") {
+        return false;
+    }
+    if (await locator.count().catch(() => 0) !== 1)
+        return false;
+    const safe = await locator.evaluate((element) => {
+        const control = element;
+        if (control.disabled || control.getAttribute("aria-disabled") === "true")
+            return false;
+        if (control.hidden || control.closest("[hidden], [inert], [aria-hidden='true']") !== null)
+            return false;
+        const style = window.getComputedStyle(control);
+        const rect = control.getBoundingClientRect();
+        if (rect.width <= 0 || rect.height <= 0
+            || style.display === "none"
+            || style.visibility === "hidden"
+            || style.opacity === "0"
+            || style.pointerEvents === "none")
+            return false;
+        const containers = Array.from(document.querySelectorAll("[role='menu'], [role='listbox'], [data-radix-popper-content-wrapper]")).filter(container => {
+            if (container.hidden || container.closest("[hidden], [inert], [aria-hidden='true']") !== null)
+                return false;
+            const containerStyle = window.getComputedStyle(container);
+            const containerRect = container.getBoundingClientRect();
+            return containerRect.width > 0 && containerRect.height > 0
+                && containerStyle.display !== "none"
+                && containerStyle.visibility !== "hidden"
+                && containerStyle.opacity !== "0";
+        });
+        return containers.length > 0 && containers.some(container => container.contains(control));
+    }).catch(() => false);
+    if (!safe)
+        return false;
+    await locator.click();
+    return true;
+}
 function toolLabels(tool) {
     const known = localeLabels.tools[tool];
     return known !== undefined ? [...known] : [tool];
@@ -524,13 +640,13 @@ function isModelVersionSubmenuOpener(item) {
         || (item.role !== "menuitemradio" && MODEL_VERSION_FAMILY_PATTERN.test(item.label));
 }
 async function clickResolvedMenuItem(page, item) {
-    if (item.testId !== undefined && await clickIfUnique(page.locator?.(`[data-testid="${escapeAttributeValue(item.testId)}"]`))) {
+    if (item.testId !== undefined && await clickIfUniqueMenuControl(page.locator?.(`[data-testid="${escapeAttributeValue(item.testId)}"]`), item)) {
         return true;
     }
-    if (item.role !== undefined && await clickIfUnique(page.getByRole?.(item.role, { name: item.label, exact: true }))) {
+    if (item.role !== undefined && await clickIfUniqueMenuControl(page.getByRole?.(item.role, { name: item.ariaLabel ?? item.label, exact: true }), item)) {
         return true;
     }
-    return clickMenuItem(page, item.label);
+    return clickMenuItem(page, item);
 }
 async function openModelVersionSubmenu(page, candidates) {
     const submenuOpeners = candidates.filter(item => item.hasPopup === true || MODEL_VERSION_FAMILY_PATTERN.test(item.label));
@@ -544,7 +660,7 @@ async function openModelVersionSubmenu(page, candidates) {
                 return true;
             }
         }
-        if (await clickMenuItem(page, candidate.label)) {
+        if (await clickMenuItem(page, candidate)) {
             await page.waitForTimeout?.(250);
             if (await modelVersionMenuItemsAreVisible(page)) {
                 return true;
@@ -581,23 +697,34 @@ async function menuItemCenter(page, item, roles = ["menuitem", "menuitemradio",
         const normalize = (value) => value.replace(/\s+/g, " ").trim().toLowerCase();
         const normalizedLabel = normalize(target.label);
         const roleSelector = target.roles.map(role => `[role='${role}']`).join(",");
+        const visible = (element) => {
+            if (element.hidden || element.closest("[hidden], [inert], [aria-hidden='true']") !== null)
+                return false;
+            const rect = element.getBoundingClientRect();
+            const style = window.getComputedStyle(element);
+            return rect.width > 0
+                && rect.height > 0
+                && style.visibility !== "hidden"
+                && style.display !== "none"
+                && style.opacity !== "0"
+                && style.pointerEvents !== "none";
+        };
+        const containers = Array.from(document.querySelectorAll("[role='menu'], [role='listbox'], [data-radix-popper-content-wrapper]")).filter(visible);
         const matches = Array.from(document.querySelectorAll(roleSelector))
             .filter(node => {
             const element = node;
             if (target.testId !== undefined && element.getAttribute("data-testid") !== target.testId) {
                 return false;
             }
+            if (element.disabled || element.getAttribute("aria-disabled") === "true")
+                return false;
             const label = normalize(element.innerText ?? element.textContent ?? "");
             if (label !== normalizedLabel) {
                 return false;
             }
-            const rect = element.getBoundingClientRect();
-            const style = window.getComputedStyle(element);
-            return rect.width > 0
-                && rect.height > 0
-                && style.visibility !== "hidden"
-                && style.display !== "none"
-                && style.opacity !== "0";
+            return visible(element)
+                && containers.length > 0
+                && containers.some(container => container.contains(element));
         });
         if (matches.length !== 1)
             return undefined;
@@ -679,6 +806,24 @@ async function visibleModeButtonLabelList(page) {
         return Array.from(document.querySelectorAll("button, [role='button']"))
             .map(node => {
             const element = node;
+            if (element.hidden
+                || element.getAttribute("aria-hidden") === "true"
+                || (typeof element.closest === "function"
+                    && element.closest("[hidden], [inert], [aria-hidden='true']") !== null))
+                return "";
+            const style = typeof window?.getComputedStyle === "function"
+                ? window.getComputedStyle(element)
+                : undefined;
+            if (style?.display === "none"
+                || style?.visibility === "hidden"
+                || style?.opacity === "0"
+                || style?.pointerEvents === "none")
+                return "";
+            const rect = typeof element.getBoundingClientRect === "function"
+                ? element.getBoundingClientRect()
+                : { width: 1, height: 1 };
+            if (rect.width <= 0 && rect.height <= 0)
+                return "";
             if (scopedRoots.length > 0 && !scopedRoots.some(root => root.contains(node)))
                 return "";
             const visibleText = (element.innerText ?? element.textContent ?? "").replace(/\s+/g, " ").trim();

package/dist/src/commands/registry.js

@@ -84,6 +84,7 @@ const descriptors = [
     primitive("messages.wait", "Wait for the latest assistant response to stabilize.", 120000),
     primitive("messages.readLatest", "Read the latest message as Markdown, normalized text, blocks, or HTML.", 30000),
     primitive("messages.status", "Read a compact latest-assistant progress snapshot without treating partial text as complete.", 5000),
+    primitive("messages.stop", "Stop the current visible ChatGPT response after explicit confirmation and verify generation became inactive.", 5000),
     primitive("messages.waitAndRead", "Wait for completion and read the latest message.", 120000),
     primitive("artifacts.listLatest", "Detect the latest visible generated ChatGPT artifact, such as an image-only result.", 30000),
     primitive("artifacts.wait", "Wait for a visible generated ChatGPT artifact to appear and stabilize.", 120000),
@@ -273,6 +274,8 @@ function primitiveArgs(name) {
         return { role: "assistant or user", format: "markdown, normalized_text, visible_text, html, blocks, or all" };
     if (name === "messages.status")
         return { maxPreviewChars: "maximum latest-assistant preview characters to return; defaults to 240" };
+    if (name === "messages.stop")
+        return { confirmStop: "must be true to stop a visible response", timeoutMs: "maximum time to verify generation became inactive" };
     if (name === "experience.detect")
         return { timeoutMs: "optional timeout for attaching to the ChatGPT page" };
     if (name === "experience.open")

package/dist/src/commands/sequence.js

@@ -3,7 +3,7 @@ import { applyConfiguration, inspectConfiguration } from "./configuration.js";
 import { detectExperience, openExperience } from "./experience.js";
 import { attachFiles, downloadLatestFile } from "./files.js";
 import { addProjectSources, buildProjectSourceAddPlan, listProjectSources } from "./project-sources.js";
-import { askMessage, composeMessage, messageStatus, readLatest, submitMessage, waitAndRead, waitForMessage } from "./messages.js";
+import { askMessage, composeMessage, messageStatus, readLatest, stopGeneration, submitMessage, waitAndRead, waitForMessage } from "./messages.js";
 import { copyResponse } from "./response-actions.js";
 import { bootstrap } from "./session.js";
 import { newThread, openThread, searchThreads } from "./threads.js";
@@ -82,6 +82,8 @@ export async function executeStep(step, env, previousResults) {
             return readLatest(env, step.args);
         case "messages.status":
             return messageStatus(env, step.args);
+        case "messages.stop":
+            return stopGeneration(env, step.args);
         case "messages.waitAndRead":
             return waitAndRead(env, step.args);
         case "artifacts.listLatest":

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

@@ -1,4 +1,7 @@
 import type { BootstrapArgs, BootstrapData, CommandResult, RuntimeEnv } from "../types.js";
+export type EnsurePageOptions = {
+    minimalContext?: boolean;
+};
 export declare function bootstrap(env: RuntimeEnv, args?: BootstrapArgs): Promise<CommandResult<BootstrapData>>;
-export declare function ensurePage(env: RuntimeEnv): Promise<CommandResult<unknown>>;
+export declare function ensurePage(env: RuntimeEnv, options?: EnsurePageOptions): Promise<CommandResult<unknown>>;
 export declare function verifyTabAffinity(env: RuntimeEnv): Promise<CommandResult<unknown> | undefined>;

package/dist/src/commands/session.js

@@ -1,4 +1,4 @@
-import { attachChatGPTBrowser, tabIdFromPage } from "../browser/attach.js";
+import { attachChatGPTBrowser, isChatGPTUrl, tabIdFromPage } from "../browser/attach.js";
 import { readPageState } from "../browser/page-state.js";
 import { resultError, resultOk } from "../errors.js";
 import { contextFromPage } from "./context.js";
@@ -26,7 +26,7 @@ export async function bootstrap(env, args = {}) {
         return resultError(error instanceof Error ? error : new Error(String(error)));
     }
 }
-export async function ensurePage(env) {
+export async function ensurePage(env, options = {}) {
     if (env.page === undefined) {
         return bootstrap(env, { preferExistingTab: true });
     }
@@ -34,7 +34,38 @@ export async function ensurePage(env) {
     if (affinity !== undefined) {
         return affinity;
     }
-    return resultOk({}, await contextFromPage(env.page, tabContext(env)));
+    const origin = await verifyChatGPTOrigin(env);
+    if (origin !== undefined) {
+        return origin;
+    }
+    return resultOk({}, await contextFromPage(env.page, tabContext(env), { minimal: options.minimalContext === true }));
+}
+async function verifyChatGPTOrigin(env) {
+    if (env.page === undefined)
+        return undefined;
+    const actualUrl = await Promise.resolve(env.page.url?.()).catch(() => undefined);
+    if (isChatGPTUrl(actualUrl))
+        return undefined;
+    return {
+        ok: false,
+        status: "blocked",
+        warnings: [],
+        blocker: {
+            kind: "selector_drift",
+            code: "unsafe_chatgpt_origin",
+            message: "ChatGPT command refused to operate because the controlled tab is not on an allowlisted ChatGPT origin.",
+            visibleText: actualUrl ?? "The current tab URL could not be verified.",
+            remediation: [
+                {
+                    label: "Reopen ChatGPT",
+                    instruction: "Run session.bootstrap against https://chatgpt.com or claim an exact supported ChatGPT tab before retrying.",
+                    userActionRequired: false
+                }
+            ],
+            resumable: false
+        },
+        context: await contextFromPage(env.page, tabContext(env))
+    };
 }
 export async function verifyTabAffinity(env) {
     if (env.expectedTabId === undefined || env.page === undefined) {

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

@@ -1,5 +1,10 @@
 import type { PageLike } from "../types.js";
+export type GenerationStateReadOptions = {
+    timeoutMs?: number;
+};
 export type AssistantGenerationState = {
+    /** True only when the page DOM was inspected successfully. */
+    observed: boolean;
     active: boolean;
     stopped: boolean;
     signals: string[];
@@ -11,5 +16,5 @@ export type AssistantGenerationState = {
  * response is complete.
  */
 export declare const EMPTY_GENERATION_STATE: AssistantGenerationState;
-export declare function readAssistantGenerationState(page: PageLike): Promise<AssistantGenerationState>;
+export declare function readAssistantGenerationState(page: PageLike, options?: GenerationStateReadOptions): Promise<AssistantGenerationState>;
 export declare function latestAssistantTurnHasResponseActions(page: PageLike): Promise<boolean>;