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

package/dist/src/commands/configuration.js

@@ -10,6 +10,8 @@ import { ensurePage } from "./session.js";
 const WORK_AXES = ["model", "effort", "speed"];
 const CONFIGURATION_CONTROL_DISCOVERY_TIMEOUT_MS = 5_000;
 const CONFIGURATION_CONTROL_POLL_MS = 250;
+const CONFIGURATION_SELECTION_MAX_ATTEMPTS = 6;
+const CONFIGURATION_SELECTION_RETRY_MS = 400;
 const CONFIGURATION_AXIS_ORDER = [
     "model",
     "intelligence",
@@ -158,7 +160,7 @@ export async function applyConfiguration(env, args) {
                 continue;
             }
             const selection = before.experience === "work"
-                ? await selectWorkAxis(env, axis, requested)
+                ? await selectWorkAxis(env, axis, requested, args.timeoutMs)
                 : await selectChatAxis(env, axis, requested, args.timeoutMs);
             if (selection === undefined) {
                 return configurationFailure(page, before, desired, selected, `Configuration option "${requested}" for ${axis} was not found or was ambiguous on the ${before.experience} surface.`, "configuration_option_not_found", before.options[axis]?.map(option => option.label));
@@ -261,24 +263,28 @@ async function inspectWorkAxisOptions(env, axis) {
     await closeConfigurationSubmenu(page);
     return dedupeOptions(options);
 }
-async function selectWorkAxis(env, axis, requested) {
+async function selectWorkAxis(env, axis, requested, timeoutMs) {
     const page = env.page;
     if (!WORK_AXES.includes(axis)) {
         return undefined;
     }
-    for (let attempt = 0; attempt < 2; attempt += 1) {
+    const retryWindowMs = Math.min(timeoutMs ?? CONFIGURATION_CONTROL_DISCOVERY_TIMEOUT_MS, CONFIGURATION_CONTROL_DISCOVERY_TIMEOUT_MS);
+    const attempts = Math.max(2, Math.min(CONFIGURATION_SELECTION_MAX_ATTEMPTS, Math.ceil(Math.max(0, retryWindowMs) / CONFIGURATION_SELECTION_RETRY_MS) + 1));
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
         const candidates = await openWorkAxisOptions(env, axis);
         const match = findConfigurationOption(candidates, requested);
         if (match !== undefined && await clickVisibleMenuItem(page, match)) {
             await page.waitForTimeout?.(150);
             return match.label;
         }
-        if (attempt === 0) {
+        if (attempt + 1 < attempts) {
             // The submenu can disappear between enumeration and the visible click
-            // when ChatGPT's pointer-grace timer fires. Reopen once and click from a
-            // fresh DOM instance instead of treating that transient race as drift.
+            // when ChatGPT's pointer-grace timer fires, and Work may briefly retain
+            // the previous submenu immediately after a selection. Reopen from a
+            // fresh DOM instance for a small bounded window instead of treating the
+            // transient state as permanent selector drift.
             await closeConfigurationMenus(page);
-            await page.waitForTimeout?.(200);
+            await page.waitForTimeout?.(CONFIGURATION_SELECTION_RETRY_MS);
         }
     }
     return undefined;

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

@@ -1,6 +1,6 @@
 import type { BootstrapArgs, CommandResult, RuntimeEnv } from "../types.js";
 import type { RunReportOptions } from "./reports.js";
-export type DoctorCheckName = "bridge" | "login" | "upload" | "download" | "clipboard" | "modes" | "tools" | "selectors" | "existing_tab" | "artifacts" | "file_preflight" | "localization" | "reports";
+export type DoctorCheckName = "compatibility" | "bridge" | "login" | "upload" | "download" | "clipboard" | "modes" | "tools" | "selectors" | "existing_tab" | "artifacts" | "file_preflight" | "localization" | "reports";
 export type CapabilityStatus = "ok" | "blocked" | "unsupported" | "unknown";
 export type CapabilityCheck = {
     status: CapabilityStatus;

package/dist/src/commands/doctor.js

@@ -4,12 +4,12 @@ import { readSystemClipboard } from "../browser/clipboard.js";
 import { readPageState } from "../browser/page-state.js";
 import { localeLabels } from "../dom/locale-labels.js";
 import { localeCoverageSummary } from "../dom/locale/index.js";
-import { BROWSER_BRIDGE_REMEDIATION, resultOk } from "../errors.js";
+import { BROWSER_BRIDGE_REMEDIATION, nodeErrorCode, resultOk } from "../errors.js";
 import { explainCommandBlocker } from "../diagnostics/blockers.js";
 import { preflightFiles } from "./files.js";
 import { contextFromPage } from "./context.js";
 import { bootstrap } from "./session.js";
-const DEFAULT_CHECKS = ["bridge", "login", "upload", "download", "clipboard", "modes", "tools", "selectors"];
+const DEFAULT_CHECKS = ["compatibility", "bridge", "login", "upload", "download", "clipboard", "modes", "tools", "selectors"];
 const BOOTSTRAP_CHECKS = new Set(["bridge", "login", "upload", "download", "modes", "tools", "selectors"]);
 const UPLOAD_REMEDIATION = [
     "Codex Settings > Computer Use > Chrome > Permissions > Uploads: set to Always allow, or add chatgpt.com to the allowed upload domains.",
@@ -47,6 +47,9 @@ export async function doctor(env, args = {}) {
         : undefined;
     for (const check of wanted) {
         switch (check) {
+            case "compatibility":
+                checks.compatibility = compatibilityCheck(env.compatibility);
+                break;
             case "bridge":
                 checks.bridge = boot?.ok
                     ? ok("Chrome bridge is available.")
@@ -95,6 +98,26 @@ export async function doctor(env, args = {}) {
     const ready = Object.values(checks).every(check => check?.status === "ok" || check?.status === "unknown");
     return resultOk({ ready, checks }, await contextFromPage(env.page));
 }
+function compatibilityCheck(report) {
+    if (report === undefined)
+        return unknown("Backend compatibility has not been negotiated.");
+    const firstWarning = report.warnings[0];
+    const message = firstWarning === undefined
+        ? "Backend protocol and advertised capabilities are compatible."
+        : firstWarning.message;
+    return {
+        status: report.status === "blocked"
+            ? "blocked"
+            : report.status === "warning"
+                ? "unknown"
+                : report.status === "unknown"
+                    ? "unknown"
+                    : "ok",
+        message,
+        ...(firstWarning?.code === undefined ? {} : { code: firstWarning.code }),
+        details: report
+    };
+}
 function bridgeCheck(boot) {
     if (boot === undefined) {
         return unknown("Bridge readiness was not requested.");
@@ -410,5 +433,5 @@ function capability(status, message, remediation, details, nextCommand, blockerK
     return check;
 }
 function isNodeError(error) {
-    return error instanceof Error && "code" in error;
+    return nodeErrorCode(error) !== undefined;
 }

package/dist/src/commands/experience.js

@@ -1,4 +1,5 @@
 import { resultError, resultOk } from "../errors.js";
+import { readPageState } from "../browser/page-state.js";
 import { localeLabels } from "../dom/locale-labels.js";
 import { normalizeForLabelMatch, visibleLabelMatches } from "../dom/label-match.js";
 import { contextFromPage } from "./context.js";
@@ -34,6 +35,9 @@ export async function openExperience(env, args) {
     const page = env.page;
     try {
         const before = detectExperienceFromSnapshot(await readSurfaceSnapshot(page));
+        const initialBlocker = await experiencePageBlocker(page, before);
+        if (initialBlocker !== undefined)
+            return initialBlocker;
         if (before.experience === args.experience) {
             return resultOk({
                 experience: args.experience,
@@ -52,6 +56,9 @@ export async function openExperience(env, args) {
         let controlClicked = await clickUniqueExperienceControl(page, labels);
         if (!controlClicked && await navigateConversationToSurfaceHome(page, args.timeoutMs)) {
             observed = detectExperienceFromSnapshot(await readSurfaceSnapshot(page));
+            const navigationBlocker = await experiencePageBlocker(page, observed);
+            if (navigationBlocker !== undefined)
+                return navigationBlocker;
             if (observed.experience === args.experience) {
                 return resultOk({
                     experience: args.experience,
@@ -85,6 +92,9 @@ export async function openExperience(env, args) {
             controlClicked = await clickUniqueExperienceControl(page, labels);
         }
         if (!controlClicked) {
+            const discoveryBlocker = await experiencePageBlocker(page, observed);
+            if (discoveryBlocker !== undefined)
+                return discoveryBlocker;
             return experienceSelectorDrift(page, `No unique visible ChatGPT ${args.experience === "work" ? "Work" : "Chat"} surface control was found.`, observed);
         }
         let after = before;
@@ -103,6 +113,9 @@ export async function openExperience(env, args) {
                 }));
             }
         }
+        const postconditionBlocker = await experiencePageBlocker(page, after);
+        if (postconditionBlocker !== undefined)
+            return postconditionBlocker;
         return {
             ok: false,
             status: "blocked",
@@ -125,6 +138,28 @@ export async function openExperience(env, args) {
         return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
     }
 }
+async function experiencePageBlocker(page, observed) {
+    const state = await readPageState(page);
+    if (state.blocker === undefined)
+        return undefined;
+    return {
+        ok: false,
+        status: "blocked",
+        warnings: [],
+        blocker: {
+            kind: state.blocker.kind,
+            code: `experience_blocked_${state.blocker.kind}`,
+            fieldPath: "experience",
+            message: state.blocker.message,
+            ...(state.blocker.visibleText === undefined ? {} : { visibleText: state.blocker.visibleText }),
+            resumable: true
+        },
+        context: await contextFromPage(page, {
+            experience: observed.experience,
+            selectorProfile: observed.selectorProfile
+        })
+    };
+}
 function pollAttempts(timeoutMs, pollMs) {
     return Math.max(1, Math.ceil(Math.max(0, timeoutMs) / pollMs));
 }

package/dist/src/commands/files.js

@@ -3,8 +3,9 @@ import { constants } from "node:fs";
 import { createHash } from "node:crypto";
 import path from "node:path";
 import { downloadLatestArtifact, locatorCountWithTimeout } from "./artifacts.js";
+import { ACTIVE_COMPOSER_FILE_INPUT_CLICK_EXPRESSION } from "../browser/active-composer-file-input.js";
 import { waitForDownloadFromClick } from "../browser/downloads.js";
-import { resultError, resultOk } from "../errors.js";
+import { nodeErrorCode, resultError, resultOk } from "../errors.js";
 import { addFilesButton, cssSelectors, requiredLocator } from "../dom/selectors.js";
 import { escapeRegExp, localeLabels } from "../dom/locale-labels.js";
 import { basenameForHostPath, currentHostPathPlatform, isHostAbsolutePath, resolveForHostPath } from "../platform/local-paths.js";
@@ -410,7 +411,7 @@ function guessFileType(extension) {
     }
 }
 function isNodeError(error) {
-    return error instanceof Error && "code" in error;
+    return nodeErrorCode(error) !== undefined;
 }
 async function readAttachmentEvidenceBaseline(page, timeoutMs) {
     if (typeof page.evaluate !== "function") {
@@ -762,31 +763,7 @@ async function clickHiddenFileInputWithCdp(page, paths, deadline, mutationState)
     const chooserPromise = waitForFileChooser(page, deadline).then(chooser => ({ ok: true, chooser }), error => ({ ok: false, error }));
     try {
         const evaluation = await withinNativeAttachmentDeadline(deadline, timeoutMs => Promise.resolve(cdp.send("Runtime.evaluate", {
-            expression: `(() => {
-        const visible = element => {
-          if (element.hidden || element.closest("[hidden], [inert], [aria-hidden='true']")) return false;
-          const style = getComputedStyle(element);
-          const rect = element.getBoundingClientRect();
-          return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0"
-            && (rect.width > 0 || rect.height > 0);
-        };
-        const textboxes = [...document.querySelectorAll("textarea, [contenteditable='true'], [role='textbox']")].filter(visible);
-        const composers = [...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(Boolean))];
-        if (composers.length !== 1) return { ok: false, reason: "active composer was not unique" };
-        const all = [...composers[0].querySelectorAll("input[type='file']")]
-          .filter(input => !input.disabled && input.getAttribute("aria-disabled") !== "true");
-        const preferred = all.filter(input => input.id === "upload-files");
-        const nonImage = all.filter(input => input.getAttribute("accept") !== "image/*");
-        const candidates = preferred.length ? preferred : nonImage.length ? nonImage : all;
-        if (candidates.length !== 1) return { ok: false, reason: "active composer file input was not unique" };
-        candidates[0].click();
-        return { ok: true };
-      })()`,
+            expression: ACTIVE_COMPOSER_FILE_INPUT_CLICK_EXPRESSION,
             userGesture: true,
             awaitPromise: true,
             returnByValue: true

package/dist/src/commands/modes.js

@@ -4,6 +4,7 @@ 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 { discoverPowerSlider, observedPowerSlider, resolvePowerTarget } from "./power-discovery.js";
 import { ensurePage } from "./session.js";
 const DEFAULT_MODE_EFFORT = "Thinking";
 const CURRENT_MODE_LABELS = dedupeLabels([
@@ -81,7 +82,11 @@ export async function setMode(env, args) {
             if (match === undefined) {
                 const sliderSelection = await selectModeWithPowerSlider(page, request);
                 if (sliderSelection !== undefined) {
-                    selected.push(sliderSelection);
+                    // A slider press is already a mutation. Even if the postcondition
+                    // label is unavailable, do not fall through to Advanced and issue a
+                    // second UI action against the same request. The final warning pass
+                    // will expose that this selection remains unverified.
+                    selected.push(sliderSelection.selected);
                     continue;
                 }
                 const nested = await openEffortSubmenu(page, candidates, request);
@@ -127,18 +132,23 @@ export async function setMode(env, args) {
     }
 }
 /**
- * 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.
+ * Chat's compact picker can expose a Power/reasoning ARIA slider. Discover the
+ * control from its semantic relationship to the localized Power axis and its
+ * owning menu, then use only a complete, bounded, DOM-provided value mapping.
+ * The Advanced submenu remains the fallback for every unrecognized or
+ * unprobed shape; in particular, this path never infers labels from a fixed
+ * five-position range.
  */
 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
+    const discovery = await discoverPowerSlider(page, {
+        powerLabels: localeLabels.configurationAxes.power
+    });
+    if (!discovery.ok || await isWorkPowerSurface(page, discovery.evidence.surface)) {
+        return undefined;
+    }
+    const target = resolvePowerTarget(discovery, request.labels);
+    const slider = observedPowerSlider(page, discovery);
+    if (target === undefined
         || slider?.count === undefined
         || slider.evaluate === undefined
         || slider.press === undefined
@@ -147,25 +157,47 @@ async function selectModeWithPowerSlider(page, request) {
         || await slider.count().catch(() => 0) !== 1) {
         return undefined;
     }
+    // Re-read the three values on the selected locator so a menu replacement
+    // between discovery and selection cannot apply an old operation's plan to a
+    // newly rendered slider.
     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
+        || state.min !== discovery.range.minimum
+        || state.max !== discovery.range.maximum
         || !Number.isInteger(state.now)
         || state.now < state.min
-        || state.now > state.max) {
+        || state.now > state.max
+        || target < state.min
+        || target > state.max) {
         return undefined;
     }
-    const key = wanted > state.now ? "ArrowRight" : "ArrowLeft";
-    for (let step = 0; step < Math.abs(wanted - state.now); step += 1) {
+    const key = target > state.now ? "ArrowRight" : "ArrowLeft";
+    for (let step = 0; step < Math.abs(target - state.now); step += 1) {
         await slider.press(key);
     }
     await page.waitForTimeout?.(150);
-    return findUniqueVisibleLabelForRequest(await visibleModeButtonLabelList(page), request);
+    const after = await slider.evaluate(element => Number(element.getAttribute("aria-valuenow")))
+        .catch(() => undefined);
+    const reflected = findUniqueVisibleLabelForRequest(await visibleModeButtonLabelList(page), request);
+    return {
+        // A silent/no-op keypress must not be reported as the requested level. We
+        // still return a handled selection to prevent a second Advanced mutation;
+        // the normal visible-mode verification warning exposes the unresolved
+        // postcondition to the caller.
+        selected: after === target ? reflected ?? request.requested : request.requested
+    };
+}
+async function isWorkPowerSurface(page, discoveredSurface) {
+    if (discoveredSurface === "work")
+        return true;
+    const url = typeof page.url === "function"
+        ? await Promise.resolve(page.url()).catch(() => "")
+        : "";
+    return /\/work(?:\/|$|\?)/i.test(url);
 }
 /**
  * Current Chat exposes the intelligence choices inside an Advanced "Effort <value>"

package/dist/src/commands/power-discovery.d.ts

@@ -0,0 +1,130 @@
+import type { LocatorLike, PageLike } from "../types.js";
+/**
+ * The upper bound is deliberately conservative.  A Power selector is expected
+ * to expose a small, discrete set of reasoning levels; accepting an enormous
+ * range would turn an unverified selector into a long mutation loop and would
+ * make an aria typo surprisingly expensive.
+ */
+export declare const MAX_POWER_LEVELS = 32;
+export declare const MAX_POWER_SLIDERS = 32;
+/** Maximum browser-realm nodes inspected by one Power discovery probe. */
+export declare const MAX_POWER_DOM_NODES = 4096;
+export type PowerSurface = "chat" | "work" | "unknown";
+export type PowerOptionEvidence = {
+    label: string;
+    value?: number;
+};
+export type PowerSliderRange = {
+    minimum: number;
+    maximum: number;
+    current: number;
+    count: number;
+};
+export type PowerSliderEvidence = {
+    role: "slider";
+    sliderIndex: number;
+    relationship: "aria-label" | "aria-labelledby" | "owner" | "menu-label";
+    matchedPowerLabels: string[];
+    surface: PowerSurface;
+    selectorProfile: string;
+    menuRole: string;
+    ownerRole?: string;
+    valueText?: string;
+    options: PowerOptionEvidence[];
+    range: PowerSliderRange;
+};
+export type PowerDiscoveryFailureReason = "no_visible_slider" | "no_semantic_power_slider" | "ambiguous_power_slider" | "missing_menu_relationship" | "invalid_aria_range" | "unsupported_range" | "observation_limit_exceeded" | "surface_mismatch";
+export type PowerDiscoveryFailureEvidence = {
+    visibleSliderCount: number;
+    semanticSliderCount: number;
+    invalidSemanticSliderCount: number;
+    hiddenSliderCount: number;
+    observedProfiles: string[];
+    observationTruncated: boolean;
+};
+export type PowerDiscoveryResult = {
+    ok: true;
+    evidence: PowerSliderEvidence;
+    sliderIndex: number;
+    range: PowerSliderRange;
+    options: PowerOptionEvidence[];
+    /** The non-English/visible label reported by the slider, if available. */
+    valueText?: string;
+} | {
+    ok: false;
+    reason: PowerDiscoveryFailureReason;
+    evidence: PowerDiscoveryFailureEvidence;
+};
+/**
+ * A serializable DOM observation used by the pure classifier below. Keeping
+ * the classifier independent from a browser implementation makes ambiguity and
+ * range rejection deterministic in unit tests, and prevents a later caller
+ * from accidentally turning inspection into a mutation.
+ */
+export type PowerSliderDomObservation = {
+    index: number;
+    visible: boolean;
+    ariaLabel?: string;
+    labelledByText?: string;
+    valueText?: string;
+    minimum?: string;
+    maximum?: string;
+    current?: string;
+    step?: string;
+    owner?: {
+        role?: string;
+        label?: string;
+        text?: string;
+        visible: boolean;
+    };
+    menu?: {
+        role: string;
+        label?: string;
+        text?: string;
+        visible: boolean;
+    };
+    surface?: {
+        experience?: PowerSurface;
+        selectorProfile?: string;
+    };
+    options?: Array<{
+        label: string;
+        value?: string;
+        visible: boolean;
+    }>;
+    optionSource?: "datalist" | "owner" | "power_menu";
+    optionsTruncated?: boolean;
+};
+export type PowerDomObservation = {
+    sliders: PowerSliderDomObservation[];
+    slidersTruncated?: boolean;
+};
+export type PowerDiscoveryOptions = {
+    powerLabels?: readonly string[];
+    expectedSurface?: PowerSurface;
+};
+/**
+ * Inspect the visible DOM once. This function is intentionally read-only: it
+ * never focuses, presses, clicks, hovers, waits, or writes to the page.
+ */
+export declare function discoverPowerSlider(page: PageLike, options?: PowerDiscoveryOptions): Promise<PowerDiscoveryResult>;
+/**
+ * Classify one bounded, read-only DOM observation.  No state is retained; each
+ * call starts from the supplied snapshot and therefore cannot leak a previous
+ * operation's discovered range or value mapping.
+ */
+export declare function classifyPowerSliderObservation(observation: PowerDomObservation, options?: PowerDiscoveryOptions): PowerDiscoveryResult;
+/**
+ * Resolve a visible requested label to a numeric value only when the DOM gave
+ * us a complete semantic mapping.  A current aria-valuetext is enough to
+ * recognize that no mutation is required; it is not enough to guess another
+ * level.  This is the important boundary that keeps ordinary inspection and
+ * unprobed slider ranges fail-closed.
+ */
+export declare function resolvePowerTarget(discovery: Extract<PowerDiscoveryResult, {
+    ok: true;
+}>, requestedLabels: readonly string[]): number | undefined;
+/** Return a locator for the observed slider without broadening the selector. */
+export declare function observedPowerSlider(page: PageLike, discovery: Extract<PowerDiscoveryResult, {
+    ok: true;
+}>): LocatorLike | undefined;