@youdie006/prodex 0.38.1 → 0.39.0

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 { readPowerSliderSelection } from "./picker-interaction.js";
+import { menuKeyboardStep, readPowerSliderSelection } from "./picker-interaction.js";
 export class ChatGptBrowserBlockerError extends Error {
     blocker;
     constructor(blocker) {
@@ -20,7 +20,13 @@ export class ChatGptBrowserBlockerError extends Error {
 // of this control rather than a model. Leaving it out meant --effort could not
 // reach the top of the slider at all, and the only route there - --model Pro -
 // answered with advice to "say --effort Pro", which then failed.
-const REASONING_EFFORTS = ["즉시", "중간", "높음", "매우 높음", "Pro"];
+/** A full trip round the menu is far more than any real picker needs. */
+const MENU_KEYBOARD_WALK_LIMIT = 16;
+// 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
+// pickers still name the top step that way.
+const REASONING_EFFORTS = ["즉시", "중간", "높음", "매우 높음", "Max", "Ultra", "Pro"];
 const PRO_MODES = ["기본", "확장"];
 // Aliases map friendly CLI input onto the exact Korean menu labels the picker
 // clicks by text. Keys are lowercased and space-stripped before lookup.
@@ -29,19 +35,26 @@ const REASONING_EFFORT_ALIASES = {
     instant: "즉시",
     medium: "중간",
     high: "높음",
-    max: "매우 높음",
     extrahigh: "매우 높음",
+    max: "매우 높음",
+    light: "즉시",
+    "가벼움": "즉시",
+    "최대": "Max",
+    ultra: "Ultra",
+    "울트라": "Ultra",
     pro: "Pro",
     "프로": "Pro"
 };
 // Menu labels per canonical value, verified live in both the Korean and the
 // English (US) ChatGPT UI. Matching tries every candidate so either UI works.
 const EFFORT_MENU_LABELS = {
-    "즉시": ["즉시", "Instant"],
+    "즉시": ["즉시", "Instant", "Light"],
     "중간": ["중간", "Medium"],
     "높음": ["높음", "High"],
     "매우 높음": ["매우 높음", "Extra High"],
-    Pro: ["Pro", "프로"]
+    Max: ["Max", "최대"],
+    Ultra: ["Ultra", "울트라"],
+    Pro: ["Pro", "프로", "6-pro", "GPT-6 Pro", "6 Pro"]
 };
 const PRO_MODE_SUBMENU_LABELS = {
     "기본": ["Pro 기본", "Pro Standard", "Standard", "기본"],
@@ -60,7 +73,7 @@ export function parseReasoningEffort(raw) {
     const alias = REASONING_EFFORT_ALIASES[trimmed.toLowerCase().replace(/\s+/g, "")];
     if (alias)
         return alias;
-    throw new Error(`--effort must be one of ${REASONING_EFFORTS.join(", ")} (English aliases: instant, medium, high, max)`);
+    throw new Error(`--effort must be one of ${REASONING_EFFORTS.join(", ")} (English aliases: instant/light, medium, high, extrahigh, max, ultra)`);
 }
 /** Normalize a CLI Pro sub-mode value onto the exact ChatGPT menu label. */
 export function parseProMode(raw) {
@@ -1422,6 +1435,38 @@ export function powerSliderStateExpression() {
     };
   })()`;
 }
+export function activeMenuItemExpression() {
+    return `(() => {
+    const a = document.activeElement;
+    if (!a) return null;
+    const menu = document.querySelector('[data-testid="composer-intelligence-picker-content"]');
+    if (menu && !menu.contains(a)) return null;
+    const label = ((a.innerText || a.textContent || "").trim().split(String.fromCharCode(10))[0] || "").trim();
+    return { role: a.getAttribute("role"), label };
+  })()`;
+}
+export function powerSliderPresentExpression() {
+    return `Boolean(document.querySelector('[data-testid="composer-intelligence-picker-content"] [role="slider"]'))`;
+}
+export function pickerClosedExpression() {
+    return `!document.querySelector('[data-testid="composer-intelligence-picker-content"]')`;
+}
+export function focusPickerMenuExpression() {
+    return `(() => {
+    const menu = document.querySelector('[data-testid="composer-intelligence-picker-content"]');
+    if (!menu) return { ok: false, reason: "picker menu not open" };
+    // Leave the focus the menu gave itself. It opens on the checked model row,
+    // and ArrowDown from there walks the model list. Focusing the first item
+    // instead lands on the label row above the slider, where ArrowDown only
+    // cycles that row's own widgets - measured as four steps that repeat
+    // forever and never reach a radio.
+    if (menu.contains(document.activeElement)) return { ok: true };
+    const radios = [...menu.querySelectorAll('[role="menuitemradio"]')];
+    const target = radios.find((r) => r.getAttribute("aria-checked") === "true") || radios[0];
+    if (target && typeof target.focus === "function") target.focus();
+    return { ok: menu.contains(document.activeElement) };
+  })()`;
+}
 export function focusPowerSliderExpression() {
     return `(() => {
     const slider = document.querySelector('[role="slider"]');
@@ -1680,7 +1725,45 @@ export function stepSelectionUnavailableWarning(requested, offered) {
     return (`step_not_applied: this ChatGPT picker has no "${requested}" step, so the send used the slider's current setting.${list} ` +
         'Pick one of those with --effort, or clear a saved default with `prodex setup --clear-model`.');
 }
+/**
+ * Choose a model row through the menu's roving focus.
+ *
+ * The rows carry pointer-events: none and sit outside the menu's box, so
+ * verifiedClickAt refuses them and .focus() is declined. ArrowDown from the row
+ * the menu opens on does reach them, and Enter commits. Doing this BEFORE the
+ * slider matters: with the recommended set active the slider walks a short
+ * mixed ladder ending at Extra High, and picking the model swaps in that
+ * model's own ladder, which continues past it.
+ */
+async function selectPickerModelByKeyboard(cdp, candidates) {
+    const focused = await cdp.evaluate(focusPickerMenuExpression());
+    if (!focused?.ok)
+        return false;
+    const limit = MENU_KEYBOARD_WALK_LIMIT;
+    for (let pressed = 0;; pressed += 1) {
+        const active = await cdp.evaluate(activeMenuItemExpression());
+        const move = menuKeyboardStep({ active, requested: candidates, pressed, limit });
+        if (move === "exhausted")
+            return false;
+        if (move === "select") {
+            await dispatchMenuKey(cdp, "Enter", 13);
+            // Committing closes the menu. Waiting for it to finish closing keeps the
+            // reopen below from landing mid-animation and toggling it shut again.
+            await waitForExpressionTrue(cdp, pickerClosedExpression(), 3_000);
+            return true;
+        }
+        await dispatchMenuKey(cdp, "ArrowDown", 40);
+        await sleep(140);
+    }
+}
+async function dispatchMenuKey(cdp, key, code) {
+    for (const type of ["keyDown", "keyUp"]) {
+        await cdp.send("Input.dispatchKeyEvent", { type, key, code: key, windowsVirtualKeyCode: code });
+    }
+}
 async function selectPickerModel(cdp, requested, warnings = []) {
+    if (await selectPickerModelByKeyboard(cdp, [requested]))
+        return;
     const hit = await cdp.evaluate(menuItemRectExpression(requested));
     if (!hit.ok || hit.x === undefined || hit.y === undefined) {
         const unavailable = modelSelectionUnavailableWarning(requested, hit.reason ?? "", hit.available);
@@ -1692,6 +1775,29 @@ async function selectPickerModel(cdp, requested, warnings = []) {
     }
     await verifiedClickWithRetry(cdp, () => cdp.evaluate(menuItemRectExpression(requested)), requested);
 }
+/**
+ * Make sure the composer picker is open, reopening it if it is not.
+ *
+ * Committing a model row closes the menu, and the slider lives inside it - so
+ * without this the step that follows reported "the picker did not expose its
+ * power slider" on a picker that was simply shut.
+ */
+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.
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        if (await cdp.evaluate(powerSliderPresentExpression()))
+            return true;
+        await waitForExpressionTrue(cdp, pickerClosedExpression(), 1_500);
+        const button = await cdp.evaluate(modelButtonRectExpression());
+        if (!button.ok || button.x === undefined || button.y === undefined)
+            return false;
+        await verifiedClickAt(cdp, button.x, button.y, "model selector");
+        if (await waitForExpressionTrue(cdp, powerSliderPresentExpression(), MENU_OPEN_TIMEOUT_MS))
+            return true;
+    }
+    return false;
+}
 async function selectPowerStep(cdp, requested) {
     // The menu paints a moment after it opens, and on a page that has just been
     // built - a project created seconds ago - that moment is longer. Failing the
@@ -1800,7 +1906,11 @@ async function selectModelReasoning(cdp, options, selectionWarnings = []) {
         // the whole send). Retry briefly with FRESH coordinates; a persistent
         // cover still fails with the refusal message.
         const clickDeadline = Date.now() + 5_000;
-        for (;;) {
+        // Clicking the trigger TOGGLES the picker, so clicking one that is already
+        // open shuts it and the next step reports "power slider not found" about a
+        // control that was on screen a moment earlier.
+        const alreadyOpen = await cdp.evaluate(powerSliderPresentExpression());
+        for (; !alreadyOpen;) {
             try {
                 await verifiedClickAt(cdp, button.x, button.y, "model selector");
                 break;
@@ -1832,7 +1942,16 @@ async function selectModelReasoning(cdp, options, selectionWarnings = []) {
             });
             if (plan.warning)
                 selectionWarnings.push(plan.warning);
+            // The model goes first: choosing it replaces the ladder the slider walks,
+            // so a step picked before it would be a step of the old ladder.
+            if (plan.modelLabel) {
+                await selectPickerModel(cdp, plan.modelLabel, selectionWarnings);
+            }
             if (plan.sliderLabel) {
+                // Committing the model closed the menu; the slider is inside it.
+                if (!(await ensurePickerOpen(cdp))) {
+                    throw new Error("ChatGPT's model picker would not reopen after the model was chosen.");
+                }
                 try {
                     await selectPowerStep(cdp, plan.sliderLabel);
                 }
@@ -1847,9 +1966,6 @@ async function selectModelReasoning(cdp, options, selectionWarnings = []) {
                     selectionWarnings.push(stepSelectionUnavailableWarning(plan.sliderLabel, offered));
                 }
             }
-            if (plan.modelLabel) {
-                await selectPickerModel(cdp, plan.modelLabel, selectionWarnings);
-            }
             // This branch cannot honour a sub-mode, and used to return without
             // saying so - the caller got a clean receipt for a 확장 it never got.
             const proModeWarning = proModeNotAppliedWarning(options.proMode, sliderState.effort ?? undefined);
@@ -2839,7 +2955,11 @@ export function modelMenuOptionsExpression() {
     return `(() => {
     const m = document.querySelector('[data-testid="composer-intelligence-picker-content"]');
     if (!m) return [];
-    return [...m.querySelectorAll('[role="menuitemradio"],[role="menuitem"]')]
+    // Only the radios are models. The plain menuitems above them are the power
+    // slider's own rows - its track, and the label pair naming the current model
+    // and effort - and listing those put GPT-6 Astra in twice and Extra High in
+    // as if it were a model.
+    return [...m.querySelectorAll('[role="menuitemradio"]')]
       .map((it) => {
         // A submenu row renders as label over value ("Model" / "GPT-5.6 Sol"),
         // and the value is the part a person actually wants to read.
@@ -3275,17 +3395,24 @@ async function readEffortSteps(cdp) {
             await dispatchArrowKey(cdp, "ArrowLeft");
             await sleep(120);
         }
-        const labels = [];
+        // 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.
+        const rungs = [];
         const record = async () => {
             const state = await cdp.evaluate(powerSliderStateExpression());
-            const label = state?.effort?.trim();
-            if (label && !labels.includes(label))
-                labels.push(label);
+            if (!state?.ok)
+                return;
+            const effort = state.effort?.trim();
+            if (!effort)
+                return;
+            rungs.push({ position: state.position ?? rungs.length, model: state.model?.trim() || null, effort });
         };
         await record();
         for (let i = 0; i < plan.climb; i += 1) {
             await dispatchArrowKey(cdp, "ArrowRight");
-            await sleep(120);
+            await sleep(220);
             await record();
         }
         // Put it back. Reading someone's setting must not change it.
@@ -3293,7 +3420,7 @@ async function readEffortSteps(cdp) {
             await dispatchArrowKey(cdp, "ArrowLeft");
             await sleep(120);
         }
-        return labels.length > 0 ? { labels, current } : undefined;
+        return rungs.length > 0 ? { rungs, current } : undefined;
     }
     catch {
         return undefined;

package/dist/cli-pro.js

@@ -449,11 +449,18 @@ export async function runProCommand(rest, io, runCliFn) {
             }
             if (listed.effortSteps) {
                 io.stdout("");
-                io.stdout("Effort steps on this account (the slider was walked and put back):");
-                for (const label of listed.effortSteps.labels) {
-                    io.stdout(`${label === listed.effortSteps.current ? "*" : " "} ${label}`);
+                // One slider walks a ladder of model-and-effort pairs, so the same
+                // effort name appears at more than one rung with a different model
+                // behind it. Printing bare names hid that.
+                io.stdout("Power slider on this account (the slider was walked and put back):");
+                const rungs = listed.effortSteps.rungs;
+                const width = String(rungs.length).length;
+                for (const rung of rungs) {
+                    const here = rung.effort === listed.effortSteps.current ? "*" : " ";
+                    const step = String(rung.position + 1).padStart(width, " ");
+                    io.stdout(`${here} ${step}/${rungs.length}  ${rung.model ?? "?"}  -  ${rung.effort}`);
                 }
-                io.stdout("Pass any of these to --effort. The list is complete: the slider shows one step at a time, so reading it any other way sees only the current one.");
+                io.stdout("Each row is one position of that single slider: it sets the model and the effort together, so they cannot be chosen apart. The list is complete - the slider shows one position at a time, so reading it any other way sees only the current one.");
             }
             else {
                 io.stdout("An arrow shows what that row is set to now; --model / --effort reach into those submenus (e.g. --model Pro).");

package/dist/config.js

@@ -11,7 +11,7 @@ const BrowserDefaultsSchema = z.object({
     model: z.string().min(1).optional(),
     pro_mode: z.enum(["기본", "확장"]).optional(),
     // Pro is the slider's fifth step, so a saved default may name it.
-    effort: z.enum(["즉시", "중간", "높음", "매우 높음", "Pro"]).optional(),
+    effort: z.enum(["즉시", "중간", "높음", "매우 높음", "Max", "Ultra", "Pro"]).optional(),
     project: z.string().min(1).optional()
 });
 const LocalConfigSchema = z.object({

package/dist/picker-interaction.js

@@ -10,6 +10,7 @@ export function readPowerSliderSelection(snapshot) {
     }));
     const powerLabels = new Set([
         "instant",
+        "light",
         "즉시",
         "빠름",
         "fast",
@@ -29,12 +30,43 @@ export function readPowerSliderSelection(snapshot) {
     const legacyModel = items.find((item) => item.lines[0] === "Model")?.lines[1] ?? null;
     const legacyEffort = items.find((item) => item.lines[0] === "Effort")?.lines[1] ?? null;
     const checkedModel = items.find((item) => item.role === "menuitemradio" && item.checked)?.lines[0] ?? null;
-    const sliderOwner = items.find((item) => item.role === "menuitem" && item.containsSlider)?.lines[0] ?? null;
+    // The slider stopped being an effort control: one slider now walks a ladder of
+    // model-and-effort pairs, and a row above the track reads "<model>" then
+    // "<effort>". Measured live, that pair sits in a SIBLING row - the row that
+    // literally contains the slider carries no text - so the pair is found by its
+    // shape rather than by ownership of the track. Reading the pair's first line
+    // as the effort is what made the listing announce "Extra High" as a model.
+    const pairRow = items.find((item) => item.role === "menuitem" && item.lines.length >= 2 && item.lines[0] !== "Model" && item.lines[0] !== "Effort");
+    const owner = items.find((item) => item.role === "menuitem" && item.containsSlider);
+    const sliderOwnerModel = pairRow?.lines[0] ?? null;
+    // A single-line row is the older form, where it carried only the step name.
+    const sliderOwner = pairRow?.lines[1] ?? (owner && owner.lines.length === 1 ? owner.lines[0] : null) ?? null;
     const visiblePowerLabel = items.find((item) => item.role === "menuitem" && powerLabels.has((item.lines[0] ?? "").toLowerCase()))?.lines[0] ?? null;
     const accessibleCandidate = snapshot.sliderValueText?.trim() || null;
     const accessibleValue = accessibleCandidate && powerLabels.has(accessibleCandidate.toLowerCase()) ? accessibleCandidate : null;
     return {
-        model: legacyModel ?? checkedModel,
+        // The checked radio is "Default" - the recommended set - while the slider
+        // decides the model a send actually uses, so the slider's row wins.
+        model: legacyModel ?? sliderOwnerModel ?? checkedModel,
         effort: accessibleValue ?? legacyEffort ?? sliderOwner ?? visiblePowerLabel
     };
 }
+/**
+ * Decide the next move when walking the composer picker's menu by keyboard.
+ *
+ * The model rows carry pointer-events: none and refuse focus(), so the menu's
+ * own roving focus is the only way to reach them. Only a radio counts as the
+ * target: the row above the slider repeats the model name as its first line,
+ * and committing there selects nothing.
+ */
+export function menuKeyboardStep(input) {
+    const { active, requested, pressed, limit } = input;
+    if (!active)
+        return "exhausted";
+    if (active.role === "menuitemradio") {
+        const label = active.label.trim().toLowerCase();
+        if (requested.some((candidate) => candidate.trim().toLowerCase() === label))
+            return "select";
+    }
+    return pressed < limit ? "down" : "exhausted";
+}

package/package.json

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