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

package/dist/src/commands/modes.js

@@ -1,11 +1,16 @@
 import { resultError, resultOk } from "../errors.js";
 import { enumerateVisibleMenuItems, findUniqueMenuItem } from "../dom/menus.js";
 import { localeLabels } from "../dom/locale-labels.js";
+import { isShortLatinToken, normalizeForLabelMatch, visibleLabelMatches } from "../dom/label-match.js";
 import { normalizeLabel, normalizeWhitespace } from "../dom/visible-text.js";
 import { contextFromPage } from "./context.js";
-import { bootstrap } from "./session.js";
+import { ensurePage } from "./session.js";
 const DEFAULT_MODE_EFFORT = "Thinking";
-const CURRENT_MODE_LABELS = [...localeLabels.modeLabels];
+const CURRENT_MODE_LABELS = dedupeLabels([
+    ...localeLabels.modeLabels,
+    ...Object.values(localeLabels.modeOptions).flat(),
+    ...Object.values(localeLabels.configurationOptions).flat(),
+]);
 const MODE_OPENER_LABELS = [...CURRENT_MODE_LABELS.filter(label => label !== "Pro"), ...localeLabels.modeOpenerExtra];
 const MODEL_VERSION_FAMILY_PATTERN = /^gpt[\s-]/i;
 const MODEL_VERSION_LABEL_PATTERN = /^(?:o\d+|\d+(?:\.\d+)?)$/i;
@@ -13,9 +18,33 @@ const CANONICAL_INTELLIGENCE_ORDER = new Map([
     ["instant", 0],
     ["medium", 1],
     ["high", 2],
-    ["extra high", 3],
+    ["extraHigh", 3],
     ["pro", 4],
 ]);
+const MODE_OPTION_IDS = [
+    "latest",
+    "instant",
+    "thinking",
+    "extended",
+    "medium",
+    "high",
+    "extraHigh",
+    "pro",
+];
+const MODE_ID_ALIASES = {
+    latest: ["latest"],
+    instant: ["instant"],
+    thinking: ["thinking"],
+    extended: ["extended"],
+    medium: ["medium"],
+    high: ["high"],
+    extraHigh: ["extra high", "extra-high", "extra_high", "extrahigh"],
+    pro: ["pro"],
+};
+const THREAD_ACTION_MENU_LABELS = new Set(localeLabels.threadActionMenuItems.map(normalizeForLabelMatch));
+const THREAD_ACTION_PREFIXES = localeLabels.threadActionPrefixes
+    .map(normalizeForLabelMatch)
+    .filter(prefix => prefix.length > 0);
 export async function setMode(env, args) {
     const boot = await ensurePage(env);
     if (!boot.ok) {
@@ -23,9 +52,9 @@ export async function setMode(env, args) {
     }
     const page = env.page;
     try {
-        const requested = requestedModeLabels(args);
+        const requested = requestedModeSelections(args);
         const requestedVersion = requestedModelVersion(args);
-        const requestedForOpening = requestedVersion === undefined ? requested : [...requested, requestedVersion];
+        const requestedForOpening = requestedVersion === undefined ? requested : [...requested, requestedModeSelection(requestedVersion)];
         const opened = await waitForModeMenu(page, requestedForOpening, args.timeoutMs ?? 30000);
         if (requestedVersion === undefined && opened.alreadySelected.length === requested.length) {
             return resultOk({ selected: opened.alreadySelected, candidates: opened.modeButtons }, await contextFromPage(page));
@@ -36,15 +65,25 @@ export async function setMode(env, args) {
         await page.waitForTimeout?.(250);
         const candidates = await enumerateVisibleMenuItems(page);
         const selected = [];
-        for (const item of requested) {
-            const match = findModeMenuItem(candidates, item);
+        if (requested.length > 0 && shouldRejectAsWrongModeMenu(candidates)) {
+            const candidateLabels = candidates.map(candidate => candidate.label);
+            return {
+                ok: false,
+                status: "unsupported",
+                warnings: [],
+                blocker: selectorDriftBlocker("Visible menu appears to be a thread/action menu, not the ChatGPT mode menu.", candidateLabels),
+                context: await contextFromPage(page)
+            };
+        }
+        for (const request of requested) {
+            const match = findModeMenuItem(candidates, request);
             if (match === undefined) {
                 const candidateLabels = candidates.map(candidate => candidate.label);
                 return {
                     ok: false,
                     status: "unsupported",
                     warnings: [],
-                    blocker: selectorDriftBlocker(`Mode option "${item}" was not found or was ambiguous.`, candidateLabels),
+                    blocker: selectorDriftBlocker(`Mode option "${request.requested}" was not found or was ambiguous.`, candidateLabels),
                     context: await contextFromPage(page)
                 };
             }
@@ -68,7 +107,53 @@ export async function setMode(env, args) {
             }
             selected.push(versionResult.selected);
         }
-        return resultOk({ selected, candidates: candidateLabels }, await contextFromPage(page));
+        const verificationWarnings = await modeVerificationWarnings(page, requested, selected);
+        return resultOk({ selected, candidates: candidateLabels }, await contextFromPage(page), verificationWarnings);
+    }
+    catch (error) {
+        return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
+    }
+}
+/**
+ * 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
+ * ChatGPT surfaces do not echo every mode — but it must be visible to callers so a
+ * modes.set "ok" is never silently treated as a verified mode (the "Pin ... Pro ..."
+ * incident shape). Model-version selections are not verified because versions are
+ * usually not echoed on the composer.
+ */
+async function modeVerificationWarnings(page, requested, selected) {
+    if (requested.length === 0) {
+        return [];
+    }
+    await page.waitForTimeout?.(250);
+    const visibleButtons = await visibleModeButtonLabelList(page);
+    if (visibleButtons.length === 0) {
+        return [
+            `Mode selection is unverified: no mode-labelled composer control was visible after selecting ${selected.map(label => JSON.stringify(label)).join(", ")}. Use modes.get or inspect modeStep before treating this as a verified mode.`
+        ];
+    }
+    const unverified = requested.filter(request => findUniqueVisibleLabelForRequest(visibleButtons, request) === undefined);
+    if (unverified.length === 0) {
+        return [];
+    }
+    return [
+        `Mode selection is unverified: requested ${unverified.map(request => JSON.stringify(request.requested)).join(", ")} is not reflected by the visible mode controls (${visibleButtons.join(", ")}). Use modes.get or inspect modeStep before treating this as a verified mode.`
+    ];
+}
+export async function getMode(env, args = {}) {
+    void args;
+    const boot = await ensurePage(env);
+    if (!boot.ok) {
+        return boot;
+    }
+    const page = env.page;
+    try {
+        const modes = await visibleModeButtonLabelList(page);
+        const warnings = modes.length === 0
+            ? ["No mode-labelled composer control is currently visible, so the active ChatGPT mode could not be read."]
+            : [];
+        return resultOk({ modes }, await contextFromPage(page), warnings);
     }
     catch (error) {
         return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
@@ -84,7 +169,7 @@ async function waitForModeMenu(page, requested, timeoutMs) {
             return { opened: false, alreadySelected, modeButtons };
         }
         const openMenuItems = await enumerateVisibleMenuItems(page);
-        if (looksLikeModeMenu(openMenuItems.map(item => item.label))) {
+        if (looksLikeModeMenu(openMenuItems)) {
             return { opened: true, alreadySelected: [], modeButtons };
         }
         if (await clickModeOpener(page, modeButtons)) {
@@ -140,12 +225,6 @@ export async function selectTool(env, args) {
         return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
     }
 }
-async function ensurePage(env) {
-    if (env.page !== undefined) {
-        return resultOk({}, await contextFromPage(env.page));
-    }
-    return bootstrap(env, { preferExistingTab: true });
-}
 async function clickFirstUniqueButton(page, labels) {
     for (const label of labels) {
         const roleLocator = page.getByRole?.("button", { name: label, exact: true });
@@ -165,12 +244,57 @@ async function clickModeOpener(page, modeButtons) {
     }
     return clickFirstUniqueButton(page, MODE_OPENER_LABELS);
 }
-function looksLikeModeMenu(labels) {
-    return labels.some(label => {
-        const normalized = normalizeLabel(label);
-        return CURRENT_MODE_LABELS.some(modeLabel => visibleLabelMatches(normalized, normalizeLabel(modeLabel)));
+function isThreadActionLabel(label) {
+    const normalized = normalizeForLabelMatch(label);
+    if (THREAD_ACTION_MENU_LABELS.has(normalized)) {
+        return true;
+    }
+    return THREAD_ACTION_PREFIXES.some(prefix => normalized.startsWith(`${prefix} `));
+}
+function hasStructuralModeEvidence(item) {
+    if (item.testId?.startsWith("model-switcher-") === true) {
+        return true;
+    }
+    return MODEL_VERSION_FAMILY_PATTERN.test(item.label) || MODEL_VERSION_LABEL_PATTERN.test(item.label);
+}
+/**
+ * Whether a single menu item is evidence that the visible menu is the ChatGPT mode menu.
+ *
+ * A fuzzy token hit on a short mode word such as "Pro" is NOT evidence: thread titles
+ * inside sidebar action menus can contain it ("Pin CopyBench Pro Consultation"), which is
+ * exactly the false positive that let modes.set select a pin action as the Pro mode.
+ * Thread-action rows can never be evidence, even when their title embeds a full mode word.
+ * Exact matching uses normalizeForLabelMatch (NFKC) so the evidence set and the veto set
+ * share identical Unicode folding — fullwidth/compatibility-form labels match both sides.
+ */
+function isModeMenuEvidence(item) {
+    if (hasStructuralModeEvidence(item)) {
+        return true;
+    }
+    if (isThreadActionLabel(item.label)) {
+        return false;
+    }
+    const normalized = normalizeForLabelMatch(item.label);
+    return CURRENT_MODE_LABELS.some(modeLabel => {
+        const normalizedMode = normalizeForLabelMatch(modeLabel);
+        if (normalized === normalizedMode) {
+            return true;
+        }
+        return !isShortLatinToken(normalizedMode) && visibleLabelMatches(normalized, normalizedMode);
     });
 }
+function looksLikeModeMenu(items) {
+    return items.some(item => isModeMenuEvidence(item));
+}
+function shouldRejectAsWrongModeMenu(items) {
+    if (items.length === 0) {
+        return false;
+    }
+    if (items.some(item => isModeMenuEvidence(item))) {
+        return false;
+    }
+    return items.some(item => isThreadActionLabel(item.label));
+}
 async function clickMenuItem(page, label) {
     if (await clickModelSwitcherMenuItem(page, label)) {
         return true;
@@ -262,28 +386,81 @@ function toolLabels(tool) {
     const known = localeLabels.tools[tool];
     return known !== undefined ? [...known] : [tool];
 }
-function findModeMenuItem(candidates, wanted) {
-    const exact = findUniqueMenuItem(candidates, wanted);
-    if (exact !== undefined) {
-        return exact;
+function findModeMenuItem(candidates, request) {
+    const selectable = candidates.filter(candidate => !isThreadActionLabel(candidate.label));
+    for (const wanted of request.labels) {
+        const match = findUniqueModeMenuItem(selectable, wanted);
+        if (match !== undefined) {
+            return match;
+        }
     }
-    const wantedIndex = CANONICAL_INTELLIGENCE_ORDER.get(normalizeLabel(wanted));
+    const wantedIndex = request.modeId === undefined ? undefined : CANONICAL_INTELLIGENCE_ORDER.get(request.modeId);
     if (wantedIndex === undefined) {
         return undefined;
     }
-    const intelligenceItems = candidates.filter(candidate => candidate.role === "menuitemradio"
+    const intelligenceItems = selectable.filter(candidate => candidate.role === "menuitemradio"
         && !MODEL_VERSION_LABEL_PATTERN.test(candidate.label)
         && !MODEL_VERSION_FAMILY_PATTERN.test(candidate.label));
     return intelligenceItems.length >= CANONICAL_INTELLIGENCE_ORDER.size
         ? intelligenceItems[wantedIndex]
         : undefined;
 }
-function requestedModeLabels(args) {
+/**
+ * Unique-match a wanted mode label. Exact normalized equality is always accepted; a
+ * fuzzy token hit on a short mode word such as "Pro" additionally requires structural
+ * mode-row evidence (a model-switcher test id or a menuitemradio role), so an arbitrary
+ * unique menu row whose text merely contains "Pro" cannot be selected as the mode.
+ * Exact matching uses normalizeForLabelMatch (NFKC), consistent with isModeMenuEvidence.
+ */
+function findUniqueModeMenuItem(items, wanted) {
+    const normalizedWanted = normalizeForLabelMatch(wanted);
+    const exact = items.filter(item => normalizeForLabelMatch(item.label) === normalizedWanted);
+    if (exact.length === 1) {
+        return exact[0];
+    }
+    const fuzzy = items.filter(item => visibleLabelMatches(item.label, wanted));
+    if (fuzzy.length !== 1) {
+        return undefined;
+    }
+    const match = fuzzy[0];
+    if (!isShortLatinToken(normalizedWanted)) {
+        return match;
+    }
+    return hasStructuralModeEvidence(match) || match.role === "menuitemradio" ? match : undefined;
+}
+function requestedModeSelections(args) {
     const requested = [args.model, args.intelligence, args.effort].filter((value) => value !== undefined);
     if (requestedModelVersion(args) !== undefined && requested.length === 0) {
         return [];
     }
-    return requested.length > 0 ? requested : [DEFAULT_MODE_EFFORT];
+    return (requested.length > 0 ? requested : [DEFAULT_MODE_EFFORT]).map(requestedModeSelection);
+}
+function requestedModeSelection(requested) {
+    const modeId = modeOptionIdFor(requested);
+    const labels = modeId === undefined ? [requested] : localeLabels.modeOptions[modeId];
+    const request = {
+        requested,
+        labels: labels.length > 0 ? [...labels] : [requested],
+    };
+    if (modeId !== undefined) {
+        request.modeId = modeId;
+    }
+    return request;
+}
+function modeOptionIdFor(value) {
+    const normalized = normalizeModeLookupKey(value);
+    for (const id of MODE_OPTION_IDS) {
+        if (MODE_ID_ALIASES[id].some(alias => normalizeModeLookupKey(alias) === normalized)) {
+            return id;
+        }
+        if (localeLabels.modeOptions[id].some(label => normalizeModeLookupKey(label) === normalized)) {
+            return id;
+        }
+    }
+    return undefined;
+}
+function normalizeModeLookupKey(value) {
+    return normalizeForLabelMatch(value).replace(/[_-]+/g, " ");
 }
 function requestedModelVersion(args) {
     return args.modelVersion ?? args.version;
@@ -297,12 +474,6 @@ function findUniqueVisibleLabel(labels, wanted) {
     const fuzzy = labels.filter(label => visibleLabelMatches(normalizeLabel(label), normalized));
     return fuzzy.length === 1 ? fuzzy[0] : undefined;
 }
-function visibleLabelMatches(label, wanted) {
-    if (wanted.length <= 3) {
-        return new RegExp(`(^|[^a-z0-9])${escapeRegExp(wanted)}([^a-z0-9]|$)`, "i").test(label);
-    }
-    return label.includes(wanted);
-}
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -311,34 +482,56 @@ function escapeAttributeValue(value) {
 }
 function findAlreadySelectedModes(visibleButtons, requested) {
     return requested
-        .map(label => findUniqueVisibleLabel(visibleButtons, label))
+        .map(request => findUniqueVisibleLabelForRequest(visibleButtons, request))
         .filter((label) => label !== undefined);
 }
+function findUniqueVisibleLabelForRequest(labels, request) {
+    for (const label of request.labels) {
+        const found = findUniqueVisibleLabel(labels, label);
+        if (found !== undefined) {
+            return found;
+        }
+    }
+    return undefined;
+}
 async function selectModelVersion(page, requestedVersion, currentCandidates, timeoutMs) {
     let candidates = await enumerateVisibleMenuItems(page);
-    if (!looksLikeModeMenu(candidates.map(candidate => candidate.label))) {
-        const opened = await waitForModeMenu(page, [requestedVersion], timeoutMs);
+    if (!looksLikeModeMenu(candidates)) {
+        const opened = await waitForModeMenu(page, [{ requested: requestedVersion, labels: [requestedVersion] }], timeoutMs);
         if (opened.opened) {
             await page.waitForTimeout?.(250);
             candidates = await enumerateVisibleMenuItems(page);
         }
     }
-    let exact = findExactMenuItem(candidates, requestedVersion);
+    let exact = findExactSelectableMenuItem(candidates, requestedVersion);
     if (exact !== undefined) {
-        return await clickMenuItem(page, exact.label)
+        return await clickResolvedMenuItem(page, exact)
             ? { selected: exact.label, candidates: candidates.map(candidate => candidate.label) }
             : { candidates: candidates.map(candidate => candidate.label) };
     }
     const opened = await openModelVersionSubmenu(page, currentCandidates);
     candidates = await enumerateVisibleMenuItems(page);
-    exact = findExactMenuItem(candidates, requestedVersion);
+    exact = findExactSelectableMenuItem(candidates, requestedVersion);
     if (!opened || exact === undefined) {
         return { candidates: candidates.map(candidate => candidate.label) };
     }
-    return await clickMenuItem(page, exact.label)
+    return await clickResolvedMenuItem(page, exact)
         ? { selected: exact.label, candidates: candidates.map(candidate => candidate.label) }
         : { candidates: candidates.map(candidate => candidate.label) };
 }
+function isModelVersionSubmenuOpener(item) {
+    return item.hasPopup === true
+        || (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)}"]`))) {
+        return true;
+    }
+    if (item.role !== undefined && await clickIfUnique(page.getByRole?.(item.role, { name: item.label, exact: true }))) {
+        return true;
+    }
+    return clickMenuItem(page, item.label);
+}
 async function openModelVersionSubmenu(page, candidates) {
     const submenuOpeners = candidates.filter(item => item.hasPopup === true || MODEL_VERSION_FAMILY_PATTERN.test(item.label));
     if (submenuOpeners.length === 0) {
@@ -419,9 +612,10 @@ async function modelVersionMenuItemsAreVisible(page) {
     return (await enumerateVisibleMenuItems(page))
         .some(candidate => candidate.role === "menuitemradio" && MODEL_VERSION_LABEL_PATTERN.test(candidate.label));
 }
-function findExactMenuItem(items, wanted) {
+function findExactSelectableMenuItem(items, wanted) {
     const normalized = normalizeLabel(wanted);
-    const matches = items.filter(item => item.normalized === normalized);
+    const matches = items.filter(item => item.normalized === normalized
+        && !isModelVersionSubmenuOpener(item));
     return matches.length === 1 ? matches[0] : undefined;
 }
 function dedupeLabels(labels) {
@@ -481,9 +675,12 @@ async function visibleModeButtonLabelList(page) {
             }
             return text.includes(token);
         };
+        const scopedRoots = Array.from(document.querySelectorAll("main form, main [data-testid*='composer' i], main [class*='composer' i]"));
         return Array.from(document.querySelectorAll("button, [role='button']"))
             .map(node => {
             const element = node;
+            if (scopedRoots.length > 0 && !scopedRoots.some(root => root.contains(node)))
+                return "";
             const visibleText = (element.innerText ?? element.textContent ?? "").replace(/\s+/g, " ").trim();
             const ariaLabel = (element.getAttribute("aria-label") ?? "").replace(/\s+/g, " ").trim();
             const label = visibleText.length > 0 ? visibleText : ariaLabel;
@@ -495,7 +692,9 @@ async function visibleModeButtonLabelList(page) {
             if (visibleText.length === 0 && /feedback|conversation options|dismiss/i.test(ariaLabel))
                 return "";
             const normalized = label.toLowerCase();
-            if (!normalizedModeLabels.some(modeLabel => tokenMatches(normalized, modeLabel)))
+            const structuralModelControl = /model-switcher|model-selector|mode-selector/i.test(testId)
+                || /\b(?:gpt|sol|luna|terra)\b/i.test(label);
+            if (!structuralModelControl && !normalizedModeLabels.some(modeLabel => tokenMatches(normalized, modeLabel)))
                 return "";
             return label;
         })

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

@@ -0,0 +1,15 @@
+import { type Deadline } from "./deadline.js";
+export type ProbeResult<T> = {
+    ok: true;
+    value: T;
+    warnings: string[];
+} | {
+    ok: false;
+    timedOut?: boolean;
+    skipped?: boolean;
+    warnings: string[];
+};
+export type ProbeOptions = {
+    timeoutMs: number;
+};
+export declare function createSingleFlightProbe<A, T>(name: string, probe: (arg: A) => Promise<T>): (arg: A, deadline: Deadline, options: ProbeOptions) => Promise<ProbeResult<T>>;

package/dist/src/commands/probes.js

@@ -0,0 +1,64 @@
+import { childTimeoutMs } from "./deadline.js";
+export function createSingleFlightProbe(name, probe) {
+    let inFlight;
+    return async (arg, deadline, options) => {
+        if (inFlight !== undefined) {
+            return {
+                ok: false,
+                skipped: true,
+                warnings: [`Skipped ${name} DOM probe because previous browser-side work is still in flight.`]
+            };
+        }
+        const timeoutMs = childTimeoutMs(deadline, options.timeoutMs);
+        if (timeoutMs <= 0) {
+            return {
+                ok: false,
+                timedOut: true,
+                warnings: [`Skipped ${name} DOM probe because no deadline budget remained.`]
+            };
+        }
+        const current = probe(arg);
+        inFlight = current;
+        current.finally(() => {
+            if (inFlight === current) {
+                inFlight = undefined;
+            }
+        }).catch(() => undefined);
+        let timeout;
+        try {
+            const value = await Promise.race([
+                current,
+                new Promise((_resolve, reject) => {
+                    timeout = setTimeout(() => reject(new ProbeTimeoutError(timeoutMs)), timeoutMs);
+                })
+            ]);
+            return { ok: true, value, warnings: [] };
+        }
+        catch (error) {
+            if (error instanceof ProbeTimeoutError) {
+                return {
+                    ok: false,
+                    timedOut: true,
+                    warnings: [`Timed out waiting ${timeoutMs}ms for ${name} DOM probe; this stopped SDK waiting but did not cancel browser-side work.`]
+                };
+            }
+            return {
+                ok: false,
+                warnings: [`${name} DOM probe failed: ${error instanceof Error ? error.message : String(error)}`]
+            };
+        }
+        finally {
+            if (timeout !== undefined) {
+                clearTimeout(timeout);
+            }
+        }
+    };
+}
+class ProbeTimeoutError extends Error {
+    timeoutMs;
+    constructor(timeoutMs) {
+        super(`Probe timed out after ${timeoutMs}ms.`);
+        this.timeoutMs = timeoutMs;
+        this.name = "ProbeTimeoutError";
+    }
+}