@youdie006/prodex 0.28.1 → 0.30.0

package/dist/chatgpt-browser.js

@@ -2462,6 +2462,62 @@ export function sidebarProjectNamesExpression() {
 // Read-only discovery for --project/setup --project: list the sidebar project
 // names exactly as ChatGPT renders them, so nobody has to guess spelling or
 // case. Polls briefly because the Projects section hydrates after navigation.
+/**
+ * Recent conversations with their titles, for the interactive "continue an
+ * existing chat" list.
+ */
+/**
+ * Point the dedicated tab at a conversation and wait until it is really there.
+ *
+ * `--target-url` confirms which conversation a send means; it deliberately does
+ * not navigate, so nothing moves a shared browser behind the user's back. When
+ * the user has just picked a conversation from a list, moving there IS the
+ * request, so the picker navigates first and then confirms.
+ */
+export async function navigateChatGptTabTo(url, options = {}) {
+    const port = resolveCdpPort(options.port);
+    const page = await findChatGptPage(port, 3_000);
+    if (!page.ok || !page.page)
+        return false;
+    const target = normalizeChatGptTargetUrl(url);
+    const cdp = await connectCdp(page.page.webSocketDebuggerUrl);
+    try {
+        await cdp.send("Runtime.enable");
+        await cdp.evaluate(`location.assign(${JSON.stringify(target)})`);
+        const deadline = Date.now() + Math.max(1_000, options.timeoutMs ?? 20_000);
+        while (Date.now() < deadline) {
+            await sleep(500);
+            try {
+                const here = await cdp.evaluate("location.href");
+                if (typeof here === "string" && chatGptUrlsReferToSameTarget(here, target))
+                    return true;
+            }
+            catch {
+                // Mid-navigation evaluate failures are expected; keep polling.
+            }
+        }
+        return false;
+    }
+    finally {
+        cdp.close();
+    }
+}
+export async function listRecentChatGptConversations(input = {}) {
+    const port = resolveCdpPort(input.port);
+    const page = await findChatGptPage(port, input.timeoutMs ?? 3_000);
+    if (!page.ok || !page.page)
+        return [];
+    const { recentConversationTitlesExpression } = await import("./tui.js");
+    try {
+        return ((await evaluateOnPage(page.page, recentConversationTitlesExpression(input.limit ?? 10), {
+            timeoutMs: 30_000
+        })) ?? []);
+    }
+    catch {
+        // Nothing to continue from is a normal answer here, not a failure.
+        return [];
+    }
+}
 export async function listChatGptSidebarProjects(input = {}) {
     const port = resolveCdpPort(input.port);
     const timeoutMs = input.timeoutMs ?? 15_000;

package/dist/cli-pro.js

@@ -838,7 +838,14 @@ export async function runAskProCommand(rest, io) {
     // reasoning axis explicitly suppresses the default for the other axis, and
     // pinning --target-url suppresses a default project (it would navigate away
     // from the confirmed tab).
-    const selectionModel = explicitModel ?? browserDefaults?.model;
+    // Choosing an effort IS choosing the reasoning axis, and ChatGPT deselects
+    // Pro the moment an effort is set - so applying a pinned Pro first would
+    // select a model only to undo it, and a quick question would still pay for
+    // the Pro selection dance.
+    // --pro-mode refines Pro, so it keeps a pinned Pro. --effort replaces it:
+    // ChatGPT deselects Pro the moment an effort is set, so applying the pinned
+    // Pro first would select a model only to undo it.
+    const selectionModel = explicitModel ?? (explicitEffort !== undefined ? undefined : browserDefaults?.model);
     const selectionProjectNew = explicitProjectNew;
     // A persisted default project APPLIES under --new-chat: since 0.16.11 a
     // fresh chat inside the project is exactly what "--new-chat + project"

package/dist/cli.js

@@ -70,6 +70,22 @@ async function runInteractiveUi(io) {
                 { label: "browser", value: browser }
             ];
         },
+        pinnedProject: async () => {
+            const { loadBrowserDefaults } = await import("./config.js");
+            return (await loadBrowserDefaults(io.cwd).catch(() => undefined))?.project;
+        },
+        pinnedModel: async () => {
+            const { loadBrowserDefaults } = await import("./config.js");
+            return (await loadBrowserDefaults(io.cwd).catch(() => undefined))?.model;
+        },
+        listConversations: async () => {
+            const { listRecentChatGptConversations } = await import("./chatgpt-browser.js");
+            return listRecentChatGptConversations({});
+        },
+        openThread: async (url) => {
+            const { navigateChatGptTabTo } = await import("./chatgpt-browser.js");
+            return navigateChatGptTabTo(url, {});
+        },
         listProjects: async () => {
             const { listChatGptSidebarProjects } = await import("./chatgpt-browser.js");
             const listed = await listChatGptSidebarProjects({});

package/dist/tui-flow.js

@@ -0,0 +1,49 @@
+/**
+ * What the interactive picker asks, in the order it asks it.
+ *
+ * The first version asked for the prompt first and treated the kind of send as
+ * an afterthought, which is backwards: whether this is an ordinary chat or a
+ * ten-minute research run changes what you would type. Deciding the kind, then
+ * the destination, then writing the prompt matches how the request is actually
+ * formed - and it leaves the seconds spent choosing free for prodex to fetch
+ * the project and conversation lists the destination step needs.
+ */
+export const SEND_KINDS = [
+    { id: "chat", label: "Normal chat", hint: "ordinary Pro answer", tools: [] },
+    { id: "deep-research", label: "Deep research", hint: "browsed report, runs about 10 minutes", tools: ["deep-research"] },
+    { id: "web-search", label: "Web search", hint: "current facts, with sources", tools: ["web-search"] },
+    { id: "create-image", label: "Create image", tools: ["create-image"] }
+];
+/**
+ * One screen for the whole destination question. Splitting "which project" from
+ * "new thread or not" made the user answer twice for one decision, and left no
+ * way at all to say "that conversation, the one from yesterday".
+ */
+export function destinationChoices(pinnedProject) {
+    return [
+        { id: "continue", label: "Continue an existing conversation", hint: "pick from your recent chats" },
+        {
+            id: "new",
+            label: "New chat",
+            ...(pinnedProject ? { hint: `in your pinned project: ${pinnedProject}` } : { hint: "in the plain chat list" })
+        },
+        { id: "project", label: "New chat in an existing project", hint: "pick from your sidebar projects" },
+        { id: "project-new", label: "New chat in a new project" },
+        ...(pinnedProject ? [{ id: "no-project", label: "New chat, ignoring the pinned project" }] : [])
+    ];
+}
+/**
+ * prodex is named for Pro, but the same signed-in browser runs the ordinary
+ * reasoning levels, and a one-line question does not want minutes of Pro.
+ * Offered only for an ordinary chat: the tool kinds bring their own pipeline,
+ * and ChatGPT deselects Pro as soon as an effort is set.
+ */
+export function effortChoices(pinnedModel) {
+    return [
+        { label: pinnedModel ? `Keep ${pinnedModel}` : "Keep the current selection", hint: "whatever this repo pinned" },
+        { effort: "instant", label: "Instant", hint: "seconds, for a quick question" },
+        { effort: "medium", label: "Medium" },
+        { effort: "high", label: "High" },
+        { effort: "max", label: "Extra high", hint: "slowest of the standard levels" }
+    ];
+}

package/dist/tui-run.js

@@ -7,7 +7,9 @@
  * what keeps the interactive path from drifting away from the documented flags.
  */
 import readline from "node:readline";
-import { consultArgsFromChoices, moveCursor, progressLabel, renderContextPanel, renderProgressBar, renderSelectList, toggleSelection } from "./tui.js";
+import { renderBanner } from "./banner.js";
+import { destinationChoices, effortChoices, SEND_KINDS } from "./tui-flow.js";
+import { consultArgsFromChoices, conversationThreadUrl, moveCursor, progressLabel, renderContextPanel, renderProgressBar, renderSelectList } from "./tui.js";
 const ESC = "";
 const CLEAR = `${ESC}[2J${ESC}[H`;
 // The alternate screen buffer: the terminal comes back exactly as it was, so a
@@ -115,38 +117,6 @@ function numericChoice(key, length) {
         return undefined;
     return digit - 1;
 }
-async function pickMany(io, input, header = "") {
-    let cursor = 0;
-    let selected = [];
-    for (;;) {
-        io.write(CLEAR +
-            header +
-            renderSelectList({
-                ...input,
-                cursor,
-                selected,
-                multi: true,
-                width: terminalWidth(),
-                color: colorEnabled(),
-                footer: "  space toggle   1-9 toggle directly   enter confirm (none is fine)   q cancel"
-            }) +
-            "\n");
-        const key = await readKey(io);
-        if (isCancel(key))
-            return undefined;
-        const typed = numericChoice(key, input.options.length);
-        if (typed !== undefined)
-            selected = toggleSelection(selected, typed);
-        else if (key.name === "up" || key.name === "k")
-            cursor = moveCursor(cursor, "up", input.options.length);
-        else if (key.name === "down" || key.name === "j")
-            cursor = moveCursor(cursor, "down", input.options.length);
-        else if (key.name === "space")
-            selected = toggleSelection(selected, cursor);
-        else if (isConfirm(key))
-            return selected;
-    }
-}
 /** Read one line with the terminal back in cooked mode, so editing works. */
 async function askLine(io, question) {
     io.input.setRawMode?.(false);
@@ -161,11 +131,6 @@ async function askLine(io, question) {
     keys?.drain();
     return answer.trim();
 }
-const TOOL_CHOICES = [
-    { id: "deep-research", label: "Deep research", hint: "browsed report, runs about 10 minutes" },
-    { id: "web-search", label: "Web search", hint: "current facts, with sources" },
-    { id: "create-image", label: "Create image" }
-];
 /**
  * Walk the questions a send needs, then run it with a moving progress bar.
  * Returns the process exit code.
@@ -179,85 +144,119 @@ export async function runInteractiveConsult(io, deps) {
     io.write(ALT_SCREEN_ON + HIDE_CURSOR);
     let header = "";
     try {
-        io.write(CLEAR);
-        // Gather the context WHILE the prompt is being typed. Reading the browser
-        // state takes a second or two, and doing it first left the screen blank for
-        // that long - anything typed into that gap was swallowed, prompt included.
+        // The logo is the program saying which program it is; the panel says what
+        // this send will use. Both belong above the first question, not nowhere.
+        const banner = colorEnabled() ? `${renderBanner({ color: true })}\n` : "";
+        io.write(CLEAR + banner);
+        // Everything the later screens need is fetched while the first question is
+        // being read, so no step waits on the network.
         const contextPromise = deps.describeContext?.().catch(() => []);
-        const prompt = await askLine(io, "Ask ChatGPT Pro\n\n  prompt: ");
-        // The panel still leads every question that follows, which is where it
-        // earns its place: choosing a project and tools without knowing the browser
-        // is down wastes every answer given before the failure.
+        const pinnedPromise = deps.pinnedProject?.().catch(() => undefined);
+        const pinnedModelPromise = deps.pinnedModel?.().catch(() => undefined);
+        const conversationsPromise = deps.listConversations?.().catch(() => []);
+        const kindChoice = await pick(io, {
+            title: "What kind of send is this?",
+            step: { index: 1, total: 3 },
+            options: SEND_KINDS.map((kind) => ({ label: kind.label, ...(kind.hint ? { hint: kind.hint } : {}) }))
+        }, banner);
+        if (kindChoice === undefined)
+            return cancel(io);
+        const tools = SEND_KINDS[kindChoice].tools;
+        // Only an ordinary chat has a reasoning level to choose: the tool kinds
+        // bring their own pipeline, and an effort would deselect Pro under them.
+        let effort;
+        if (SEND_KINDS[kindChoice].id === "chat") {
+            const efforts = effortChoices(await pinnedModelPromise);
+            const chosen = await pick(io, {
+                title: "How much reasoning?",
+                options: efforts.map((entry) => ({ label: entry.label, ...(entry.hint ? { hint: entry.hint } : {}) }))
+            }, banner);
+            if (chosen === undefined)
+                return cancel(io);
+            effort = efforts[chosen].effort;
+        }
         const rows = (await contextPromise) ?? [];
         if (rows.length > 0)
-            header = `${renderContextPanel(rows, { color: colorEnabled(), width: terminalWidth() })}\n\n`;
-        if (prompt.length === 0) {
-            io.write("Nothing to ask.\n");
-            return 1;
-        }
-        const projectChoice = await pick(io, {
-            title: "Where should this consult land?",
-            step: { index: 1, total: 3 },
-            options: [
-                { label: "The chat that is already open", hint: "keeps the thread's context" },
-                { label: "An existing project" },
-                { label: "A new project" },
-                { label: "No project", hint: "plain chat list, ignores a pinned default" }
-            ]
+            header = `${banner}${renderContextPanel(rows, { color: colorEnabled(), width: terminalWidth() })}\n\n`;
+        else
+            header = banner;
+        const pinnedProject = await pinnedPromise;
+        const destinations = destinationChoices(pinnedProject);
+        const destinationChoice = await pick(io, {
+            title: "Where should it go?",
+            step: { index: 2, total: 3 },
+            options: destinations.map((entry) => ({ label: entry.label, ...(entry.hint ? { hint: entry.hint } : {}) }))
         }, header);
-        if (projectChoice === undefined)
+        if (destinationChoice === undefined)
             return cancel(io);
-        const modes = ["current", "existing", "new", "none"];
-        const projectMode = modes[projectChoice];
+        const destination = destinations[destinationChoice].id;
+        let projectMode = "current";
         let projectName;
-        if (projectMode === "existing") {
+        let targetUrl;
+        if (destination === "continue") {
+            const conversations = (await conversationsPromise) ?? [];
+            if (conversations.length === 0) {
+                io.write("\nNo recent conversations were readable. Start a new chat instead.\n");
+                return 1;
+            }
+            const chosen = await pick(io, { title: "Which conversation?", options: conversations.map((entry) => ({ label: entry.title })) }, header);
+            if (chosen === undefined)
+                return cancel(io);
+            targetUrl = conversationThreadUrl(conversations[chosen].id);
+        }
+        else if (destination === "project") {
             const projects = await deps.listProjects();
             if (projects.length === 0) {
                 io.write("\nNo projects are visible in the ChatGPT sidebar.\n");
                 return 1;
             }
-            const chosen = await pick(io, {
-                title: "Which project?",
-                options: projects.map((name) => ({ label: name }))
-            }, header);
+            const chosen = await pick(io, { title: "Which project?", options: projects.map((name) => ({ label: name })) }, header);
             if (chosen === undefined)
                 return cancel(io);
+            projectMode = "existing";
             projectName = projects[chosen];
         }
-        else if (projectMode === "new") {
-            projectName = await askLine(io, `${CLEAR}New project\n\n  name: `);
+        else if (destination === "project-new") {
+            projectName = await askLine(io, `${CLEAR}${header}New project\n\n  name: `);
             if (!projectName)
                 return cancel(io);
+            projectMode = "new";
+        }
+        else if (destination === "no-project") {
+            projectMode = "none";
+        }
+        // The prompt comes last: what you type depends on what you just decided.
+        io.write(CLEAR + header + SHOW_CURSOR);
+        const kindLabel = SEND_KINDS[kindChoice].label;
+        const prompt = await askLine(io, `${kindLabel}   Step 3 of 3\n\n  prompt: `);
+        io.write(HIDE_CURSOR);
+        if (prompt.length === 0) {
+            io.write("Nothing to ask.\n");
+            return 1;
         }
-        const toolChoice = await pickMany(io, {
-            title: "Turn on any composer tools for this send",
-            step: { index: 2, total: 3 },
-            options: TOOL_CHOICES.map((tool) => ({ label: tool.label, ...(tool.hint ? { hint: tool.hint } : {}) }))
-        }, header);
-        if (toolChoice === undefined)
-            return cancel(io);
-        const tools = toolChoice.map((index) => TOOL_CHOICES[index].id);
-        const threadChoice = await pick(io, {
-            title: "Start a fresh thread?",
-            step: { index: 3, total: 3 },
-            options: [
-                { label: "Continue the current thread", hint: "follow-ups keep context" },
-                { label: "Start a new chat", hint: "recommended for an unrelated question" }
-            ]
-        }, header);
-        if (threadChoice === undefined)
-            return cancel(io);
         const choices = {
             prompt,
             projectMode,
             ...(projectName ? { projectName } : {}),
+            ...(targetUrl ? { targetUrl } : {}),
+            ...(effort ? { effort } : {}),
             tools,
-            newChat: threadChoice === 1
+            newChat: !targetUrl
         };
         const args = consultArgsFromChoices(choices);
         // Leave the alternate screen before the send: the answer, the receipt id
         // and any blocker belong in the scrollback the user keeps.
         io.write(ALT_SCREEN_OFF + SHOW_CURSOR);
+        // --target-url confirms which conversation a send means; it deliberately
+        // does not navigate. Picking one from a list IS a request to go there, so
+        // move the tab first and let the flag confirm it landed.
+        if (targetUrl && deps.openThread) {
+            io.write("Opening the conversation you picked...\n");
+            if (!(await deps.openThread(targetUrl))) {
+                io.write(`Could not open ${targetUrl} in the dedicated browser.\n`);
+                return 1;
+            }
+        }
         io.write(`Sending. Equivalent command:\n  prodex ${formatCommand(args)}\n\n`);
         // Deep research runs about ten minutes; an ordinary Pro answer, minutes.
         // Fill the bar against that so the wait has a shape.

package/dist/tui.js

@@ -10,6 +10,10 @@
  * The rendering and the choice-to-argument mapping are pure so they can be
  * tested without a terminal; only `runInteractiveConsult` touches stdin.
  */
+/** Where a conversation lives, given its id. */
+export function conversationThreadUrl(conversationId) {
+    return `https://chatgpt.com/c/${conversationId}`;
+}
 /**
  * Map the picker's answers onto the exact command line a person could have
  * typed. Keeping this a pure function means the interactive path cannot drift
@@ -20,8 +24,23 @@ export function consultArgsFromChoices(choices) {
     if (prompt.length === 0)
         throw new Error("The prompt is empty - there is nothing to ask.");
     const args = ["pro", "browser", "ask"];
+    // A picked conversation is the whole destination: the send rejects a project
+    // or a fresh chat alongside a pinned target, and rightly so.
+    if (choices.targetUrl) {
+        args.push("--target-url", choices.targetUrl, "--confirm-target");
+        if (choices.effort)
+            args.push("--effort", choices.effort);
+        for (const attachment of choices.attachments ?? [])
+            args.push("--attach", attachment);
+        for (const tool of choices.tools)
+            args.push("--tool", tool);
+        args.push("--", prompt);
+        return args;
+    }
     if (choices.newChat)
         args.push("--new-chat");
+    if (choices.effort)
+        args.push("--effort", choices.effort);
     if (choices.projectMode === "existing" || choices.projectMode === "new") {
         const name = choices.projectName?.trim();
         if (!name)
@@ -38,6 +57,37 @@ export function consultArgsFromChoices(choices) {
     args.push("--", prompt);
     return args;
 }
+/**
+ * Recent conversations with their titles, for the "continue an existing chat"
+ * list. Only the sidebar listing is fetched - the transcripts themselves are
+ * large and nothing here needs them.
+ */
+export function recentConversationTitlesExpression(limit = 10) {
+    return `(async () => {
+  let token = "";
+  try {
+    const session = await fetch("/api/auth/session", { credentials: "include" });
+    if (!session.ok) return [];
+    const parsed = await session.json();
+    token = (parsed && parsed.accessToken) || "";
+  } catch (error) {
+    return [];
+  }
+  try {
+    const response = await fetch("/backend-api/conversations?offset=0&limit=${limit}&order=updated", {
+      credentials: "include",
+      headers: token ? { Authorization: "Bearer " + token } : {}
+    });
+    if (!response.ok) return [];
+    const listed = await response.json();
+    return ((listed && listed.items) || [])
+      .filter((item) => item && item.id)
+      .map((item) => ({ id: item.id, title: (item.title || "").trim() || "Untitled" }));
+  } catch (error) {
+    return [];
+  }
+})()`;
+}
 const ESC = "";
 const DIM = `${ESC}[2m`;
 const BOLD = `${ESC}[1m`;

package/package.json

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