@youdie006/prodex 0.39.0 → 0.39.1

package/dist/chatgpt-browser.js

@@ -6,7 +6,7 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { captureBrowserDiagnostics, diagnosticsEnabled, diagnosticsNote } from "./browser-diagnostics.js";
 import os from "node:os";
-import { menuKeyboardStep, readPowerSliderSelection } from "./picker-interaction.js";
+import { chatSurfaceChoice, menuKeyboardStep, readPowerSliderSelection, sliderRestoreStep } from "./picker-interaction.js";
 export class ChatGptBrowserBlockerError extends Error {
     blocker;
     constructor(blocker) {
@@ -22,6 +22,8 @@ export class ChatGptBrowserBlockerError extends Error {
 // answered with advice to "say --effort Pro", which then failed.
 /** A full trip round the menu is far more than any real picker needs. */
 const MENU_KEYBOARD_WALK_LIMIT = 16;
+/** Enough presses to cross any slider this code accepts, twice over. */
+const POWER_SLIDER_RESTORE_ATTEMPTS = 26;
 // Two more rungs than before. Measured live: with the model row chosen rather
 // than the recommended set, the slider reads Light / Medium / High / Extra High
 // / Max / Ultra, and Ultra is the top of the machine. Pro is kept because older
@@ -1445,6 +1447,20 @@ export function activeMenuItemExpression() {
     return { role: a.getAttribute("role"), label };
   })()`;
 }
+export function chatWorkSurfaceExpression() {
+    return `(() => {${CLICK_POINT_SNIPPET}
+    const buttons = [...document.querySelectorAll('[role="radio"],[role="tab"]')].filter((el) => {
+      const t = ((el.innerText || el.textContent || "").trim());
+      return t === "Chat" || t === "Work";
+    });
+    const surfaces = buttons.map((el) => ({
+      label: ((el.innerText || el.textContent || "").trim()),
+      checked: el.getAttribute("aria-checked") === "true" || el.getAttribute("aria-selected") === "true"
+    }));
+    const chat = buttons.find((el) => ((el.innerText || el.textContent || "").trim()) === "Chat");
+    return { surfaces, chat: chat ? clickPoint(chat) : { ok: false, reason: "no Chat toggle" } };
+  })()`;
+}
 export function powerSliderPresentExpression() {
     return `Boolean(document.querySelector('[data-testid="composer-intelligence-picker-content"] [role="slider"]'))`;
 }
@@ -1782,6 +1798,33 @@ async function selectPickerModel(cdp, requested, warnings = []) {
  * without this the step that follows reported "the picker did not expose its
  * power slider" on a picker that was simply shut.
  */
+/**
+ * Put the browser back on ChatGPT's Chat surface when it has drifted onto Work.
+ *
+ * The two have different pickers - Work's offers no Pro at all - and nothing on
+ * the page announces which one is live, so a drifted browser silently drives
+ * the wrong picker. Returns a warning to carry to the caller when it moved.
+ */
+async function ensureChatSurface(cdp) {
+    let probe;
+    try {
+        probe = await cdp.evaluate(chatWorkSurfaceExpression());
+    }
+    catch {
+        return undefined;
+    }
+    if (!probe)
+        return undefined;
+    if (chatSurfaceChoice(probe.surfaces ?? []) !== "switch-to-chat")
+        return undefined;
+    const chat = probe.chat;
+    if (!chat?.ok || chat.x === undefined || chat.y === undefined) {
+        return "ChatGPT is on its Work surface, whose picker offers different models and no Pro, and the Chat toggle could not be clicked.";
+    }
+    await verifiedClickAt(cdp, chat.x, chat.y, "Chat surface toggle");
+    await sleep(1_500);
+    return "ChatGPT was on its Work surface, whose picker offers different models and no Pro. Switched back to Chat.";
+}
 async function ensurePickerOpen(cdp) {
     // The slider, not the menu, is what the caller needs - and an open menu that
     // has not painted its slider yet looks identical to one that has.
@@ -1870,6 +1913,11 @@ export function sliderWalkPlan(state) {
 async function selectModelReasoning(cdp, options, selectionWarnings = []) {
     if (!options.model && !options.proMode && !options.effort)
         return;
+    // Which surface is live decides which picker exists at all, so settle that
+    // before looking for anything in it.
+    const surfaceWarning = await ensureChatSurface(cdp);
+    if (surfaceWarning)
+        selectionWarnings.push(surfaceWarning);
     // --pro-mode selects a Pro sub-mode, so it is meaningless with a non-Pro
     // --model. Fail loudly instead of silently dropping the requested sub-mode.
     if (options.proMode && options.model && !/pro/i.test(options.model)) {
@@ -3380,25 +3428,25 @@ export async function listChatGptSidebarProjects(input = {}) {
  * listing exactly as it was rather than failing a read-only command.
  */
 async function readEffortSteps(cdp) {
+    const focused = await cdp.evaluate(focusPowerSliderExpression());
+    if (!focused?.ok)
+        return undefined;
+    const start = await cdp.evaluate(powerSliderStateExpression());
+    if (!start?.ok)
+        return undefined;
+    const plan = sliderWalkPlan({ position: start.position, min: start.min, max: start.max });
+    if (!plan)
+        return undefined;
+    const current = start.effort ?? null;
+    const startedAt = start.position;
     try {
-        const focused = await cdp.evaluate(focusPowerSliderExpression());
-        if (!focused?.ok)
-            return undefined;
-        const start = await cdp.evaluate(powerSliderStateExpression());
-        if (!start?.ok)
-            return undefined;
-        const plan = sliderWalkPlan({ position: start.position, min: start.min, max: start.max });
-        if (!plan)
-            return undefined;
-        const current = start.effort ?? null;
         for (let i = 0; i < plan.toBottom; i += 1) {
             await dispatchArrowKey(cdp, "ArrowLeft");
             await sleep(120);
         }
-        // Every position is recorded, including repeats. One slider now walks a
-        // ladder of model-and-effort pairs, so "Light" is three different rungs -
-        // collapsing by label turned six positions into three and lost which model
-        // each one sends with.
+        // Every position is recorded, including repeats. The slider can walk a
+        // ladder of model-and-effort pairs, so one effort name is several rungs -
+        // collapsing by label lost which model each one would send with.
         const rungs = [];
         const record = async () => {
             const state = await cdp.evaluate(powerSliderStateExpression());
@@ -3415,16 +3463,40 @@ async function readEffortSteps(cdp) {
             await sleep(220);
             await record();
         }
-        // Put it back. Reading someone's setting must not change it.
-        for (let i = 0; i < plan.climb - plan.back; i += 1) {
-            await dispatchArrowKey(cdp, "ArrowLeft");
-            await sleep(120);
-        }
         return rungs.length > 0 ? { rungs, current } : undefined;
     }
     catch {
         return undefined;
     }
+    finally {
+        // Whatever happened above, the setting goes back. Replaying a precomputed
+        // count skipped this whenever the walk was interrupted, and one run left a
+        // slider on High that had been on Pro.
+        await restorePowerSlider(cdp, startedAt);
+    }
+}
+async function restorePowerSlider(cdp, target) {
+    for (let guard = 0; guard < POWER_SLIDER_RESTORE_ATTEMPTS; guard += 1) {
+        let state;
+        try {
+            state = await cdp.evaluate(powerSliderStateExpression());
+        }
+        catch {
+            return;
+        }
+        if (!state?.ok)
+            return;
+        const move = sliderRestoreStep({ ...(state.position !== undefined ? { current: state.position } : {}), ...(target !== undefined ? { target } : {}) });
+        if (move === "done")
+            return;
+        try {
+            await dispatchArrowKey(cdp, move === "left" ? "ArrowLeft" : "ArrowRight");
+        }
+        catch {
+            return;
+        }
+        await sleep(150);
+    }
 }
 export async function listChatGptModelOptions(input = {}) {
     const port = resolveCdpPort(input.port);
@@ -3460,7 +3532,18 @@ export async function listChatGptModelOptions(input = {}) {
                 throw new Error("ChatGPT model menu did not open after clicking the selector");
             const options = await cdp.evaluate(modelMenuOptionsExpression());
             const effortSteps = await readEffortSteps(cdp);
-            return { url: status.url, options, ...(effortSteps ? { effortSteps } : {}) };
+            // Chat and Work have different pickers - Work's offers no Pro - and a
+            // listing that does not say which one it read is how a browser sitting on
+            // Work convinced two machines that Pro had been removed from the account.
+            let surface;
+            try {
+                const probe = await cdp.evaluate(chatWorkSurfaceExpression());
+                surface = probe?.surfaces?.find((entry) => entry.checked)?.label;
+            }
+            catch {
+                // the toggle predates some builds; saying nothing is right there
+            }
+            return { url: status.url, options, ...(effortSteps ? { effortSteps } : {}), ...(surface ? { surface } : {}) };
         }
         finally {
             try {

package/dist/cli-pro.js

@@ -443,6 +443,9 @@ export async function runProCommand(rest, io, runCliFn) {
                 });
                 throw new Error(blocker.next_step ? `${blocker.message} Next: ${blocker.next_step}` : errorMessage(error));
             }
+            if (listed.surface) {
+                io.stdout(`Read from ChatGPT's ${listed.surface} surface. Chat and Work have different pickers - only one of them offers Pro.`);
+            }
             io.stdout("Model menu options in the visible ChatGPT tab (read-only; nothing was selected):");
             for (const option of listed.options) {
                 io.stdout(formatModelMenuOption(option));

package/dist/picker-interaction.js

@@ -70,3 +70,30 @@ export function menuKeyboardStep(input) {
     }
     return pressed < limit ? "down" : "exhausted";
 }
+/**
+ * One move towards putting the power slider back where the walk found it.
+ *
+ * Driven by the position actually read rather than by a replayed count, so an
+ * interrupted walk still converges instead of abandoning the setting wherever
+ * it stopped.
+ */
+export function sliderRestoreStep(input) {
+    const { current, target } = input;
+    if (!Number.isInteger(current) || !Number.isInteger(target))
+        return "done";
+    if (current === target)
+        return "done";
+    return current > target ? "left" : "right";
+}
+/**
+ * Decide whether the browser needs putting back on ChatGPT's Chat surface.
+ *
+ * Chat and Work have different model pickers - Work's has no Pro at all - so a
+ * browser that has drifted onto Work silently drives the wrong one.
+ */
+export function chatSurfaceChoice(surfaces) {
+    const chat = surfaces.find((surface) => surface.label.trim().toLowerCase() === "chat");
+    if (!chat)
+        return "no-toggle";
+    return chat.checked ? "already-chat" : "switch-to-chat";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youdie006/prodex",
-  "version": "0.39.0",
+  "version": "0.39.1",
   "description": "Local receipt bus for coordinating Codex execution with ChatGPT Pro/Projects consultation.",
   "author": "youdie006",
   "license": "MIT",