myshell-tools 2.10.0 → 2.13.0

package/dist/core/types.d.ts

@@ -163,6 +163,12 @@ export type CoreEvent = {
     readonly from: Tier;
     readonly to: Tier;
     readonly reason: string;
+} | {
+    readonly type: 'failover';
+    readonly from: ProviderId;
+    readonly to: ProviderId;
+    readonly tier: Tier;
+    readonly reason: string;
 } | {
     readonly type: 'notice';
     readonly level: 'info' | 'warn' | 'error';
@@ -175,4 +181,8 @@ export type CoreEvent = {
     readonly totalCostUsd: number;
     readonly sessionId: string;
     readonly attempts: number;
+    /** Set on failing finals only: the error category that caused the failure. */
+    readonly errorCategory?: import('../providers/port.js').CliError['category'];
+    /** Set on failing finals only: the provider that was being used when failure occurred. */
+    readonly provider?: import('../providers/port.js').ProviderId;
 };

package/dist/interface/menu.d.ts

@@ -161,6 +161,50 @@ export declare function renderBudgetLine(spend: SpendSummary, _color: boolean):
  * Returns string[] (no ANSI — pure string building, safe for tests).
  */
 export declare function renderConversationList(metas: ConversationMeta[], nowMs: number): string[];
+/**
+ * Count how many timestamps in `times` fall within the half-open window
+ * `[now - windowMs, now]` (both endpoints inclusive).
+ *
+ * Pure — no I/O, no side effects, never throws.
+ *
+ * @param times    - Immutable array of epoch-ms timestamps (e.g. from ctx.clock.now()).
+ * @param now      - The current epoch-ms (e.g. from ctx.clock.now()).
+ * @param windowMs - Width of the sliding window in milliseconds (e.g. 1500).
+ * @returns Number of entries within the window.
+ */
+export declare function countRecentInterrupts(times: readonly number[], now: number, windowMs: number): number;
+/**
+ * Decide what action to take based on the number of recent Ctrl+C presses and
+ * whether a task is currently running.
+ *
+ * Rules:
+ *   count >= 3 → `'exit-app'`
+ *   count === 2 → `'to-menu'`
+ *   count === 1 && taskRunning → `'cancel-task'`
+ *   count === 1 && !taskRunning → `'hint'`
+ *   count <= 0  → `'hint'` (defensive)
+ *
+ * Pure — never throws, no I/O, no side effects.
+ *
+ * @param count       - Number of recent interrupt presses (from countRecentInterrupts).
+ * @param taskRunning - Whether a task is currently in-flight.
+ * @returns The action to take.
+ */
+export declare function interpretInterrupt(count: number, taskRunning: boolean): 'cancel-task' | 'to-menu' | 'exit-app' | 'hint';
+/**
+ * Decide whether a raw-session SIGINT count warrants escaping back to the menu.
+ *
+ * Returns true when count >= 2 (rapid double Ctrl+C), false otherwise.
+ * A single press (count === 1) is left entirely to the child process — the
+ * terminal already delivers SIGINT to the whole foreground process group, so
+ * claude/codex/opencode handles its own cancel without interference from us.
+ *
+ * Pure — no I/O, no side effects, never throws.
+ *
+ * @param count - Number of recent Ctrl+C presses (from countRecentInterrupts).
+ * @returns True when the user should be returned to the myshell-tools menu.
+ */
+export declare function shouldEscapeRawSession(count: number): boolean;
 /**
  * Start the sessions-first interactive menu.
  *

package/dist/interface/menu.js

@@ -181,6 +181,55 @@ export function renderConversationList(metas, nowMs) {
         return `[${idx}] ${pin}${rel}  ${m.title}${categorySuffix}`;
     });
 }
+// ---------------------------------------------------------------------------
+// Ctrl+C escape model — pure helpers
+// ---------------------------------------------------------------------------
+/**
+ * Count how many timestamps in `times` fall within the half-open window
+ * `[now - windowMs, now]` (both endpoints inclusive).
+ *
+ * Pure — no I/O, no side effects, never throws.
+ *
+ * @param times    - Immutable array of epoch-ms timestamps (e.g. from ctx.clock.now()).
+ * @param now      - The current epoch-ms (e.g. from ctx.clock.now()).
+ * @param windowMs - Width of the sliding window in milliseconds (e.g. 1500).
+ * @returns Number of entries within the window.
+ */
+export function countRecentInterrupts(times, now, windowMs) {
+    const cutoff = now - windowMs;
+    let count = 0;
+    for (const t of times) {
+        if (t >= cutoff && t <= now)
+            count += 1;
+    }
+    return count;
+}
+/**
+ * Decide what action to take based on the number of recent Ctrl+C presses and
+ * whether a task is currently running.
+ *
+ * Rules:
+ *   count >= 3 → `'exit-app'`
+ *   count === 2 → `'to-menu'`
+ *   count === 1 && taskRunning → `'cancel-task'`
+ *   count === 1 && !taskRunning → `'hint'`
+ *   count <= 0  → `'hint'` (defensive)
+ *
+ * Pure — never throws, no I/O, no side effects.
+ *
+ * @param count       - Number of recent interrupt presses (from countRecentInterrupts).
+ * @param taskRunning - Whether a task is currently in-flight.
+ * @returns The action to take.
+ */
+export function interpretInterrupt(count, taskRunning) {
+    if (count >= 3)
+        return 'exit-app';
+    if (count === 2)
+        return 'to-menu';
+    if (count === 1)
+        return taskRunning ? 'cancel-task' : 'hint';
+    return 'hint';
+}
 /**
  * Build a {@link LineReader} backed by a single `node:readline` interface.
  *
@@ -540,11 +589,11 @@ async function runManage(ctx, out, readLine) {
  * Follows the injected `readLine` seam so it is fully testable without TTY.
  * Never modifies the native CLI's files.
  */
-async function runImportNative(ctx, mutableCtx, out, readLine) {
+async function runImportNative(ctx, mutableCtx, out, readLine, loginFn, detectEnvironmentFn) {
     out.write('\nImport from:\n  [1] Claude\n  [2] Codex\n\n> ');
     const choice = await readLine();
     if (choice === null)
-        return;
+        return 'menu';
     let provider;
     if (choice === '1') {
         provider = 'claude';
@@ -554,12 +603,12 @@ async function runImportNative(ctx, mutableCtx, out, readLine) {
     }
     else {
         out.write('Cancelled.\n');
-        return;
+        return 'menu';
     }
     const sessions = await listNativeSessions(provider);
     if (sessions.length === 0) {
         out.write(`No ${provider} conversations found.\n`);
-        return;
+        return 'menu';
     }
     // Render a numbered picker
     const nowMs = ctx.clock.now();
@@ -576,29 +625,58 @@ async function runImportNative(ctx, mutableCtx, out, readLine) {
     out.write('\nPick a conversation number (or Enter to cancel): ');
     const pick = await readLine();
     if (pick === null || pick.length === 0)
-        return;
+        return 'menu';
     const num = parseInt(pick, 10);
     if (Number.isNaN(num) || num < 1 || num > sessions.length) {
         out.write('Invalid selection.\n');
-        return;
+        return 'menu';
     }
     const session = sessions[num - 1];
     if (session === undefined)
-        return;
+        return 'menu';
     const { id, imported } = await importNativeSession(session, ctx.store);
     const convTitle = session.title.length > 0 ? session.title : '(untitled)';
     out.write(`Imported ${imported} messages into a new conversation: "${convTitle}"\n`);
-    // Enter the chat loop for the newly imported conversation
-    await runChatLoop(ctx, mutableCtx, id, out, readLine);
+    // Enter the chat loop for the newly imported conversation.
+    // Return value propagates the 'exit' signal to the caller (startMenu).
+    return runChatLoop(ctx, mutableCtx, id, out, readLine, loginFn, detectEnvironmentFn);
 }
 // ---------------------------------------------------------------------------
 // Raw provider passthrough
 // ---------------------------------------------------------------------------
+/**
+ * Decide whether a raw-session SIGINT count warrants escaping back to the menu.
+ *
+ * Returns true when count >= 2 (rapid double Ctrl+C), false otherwise.
+ * A single press (count === 1) is left entirely to the child process — the
+ * terminal already delivers SIGINT to the whole foreground process group, so
+ * claude/codex/opencode handles its own cancel without interference from us.
+ *
+ * Pure — no I/O, no side effects, never throws.
+ *
+ * @param count - Number of recent Ctrl+C presses (from countRecentInterrupts).
+ * @returns True when the user should be returned to the myshell-tools menu.
+ */
+export function shouldEscapeRawSession(count) {
+    return count >= 2;
+}
 /**
  * Launch the native `claude`, `codex`, or `opencode` interactive CLI directly
  * (stdio:inherit), so the user gets a raw provider session. The session is owned
  * by the native CLI (not by myshell-tools); we simply hand over the terminal and wait.
  *
+ * On Unix, a best-effort "Ctrl+C twice → back to menu" escape is registered:
+ *   - A single Ctrl+C is left entirely to the child (the terminal delivers SIGINT
+ *     to the whole foreground group; we must NOT interfere with single presses).
+ *   - Two presses within 1 500 ms → SIGTERM the child and return to the menu.
+ * On Windows the SIGINT handler is NOT registered (process-group semantics differ
+ * and forced interception risks a broken console) — behaviour is exactly as today.
+ *
+ * The SIGINT listener is always removed in a finally block so it never leaks back
+ * to the menu loop. This is best-effort: forcibly terminating the child to return
+ * to the menu may leave the terminal in a non-ideal state; the existing
+ * "Returned from <bin>." message and menu re-render happen on return regardless.
+ *
  * On exit (any exit code), control returns to the myshell-tools menu.
  */
 async function runRawProviderSession(out, readLine, env) {
@@ -623,15 +701,67 @@ async function runRawProviderSession(out, readLine, env) {
     }
     const bin = selected.bin;
     out.write(`\nLaunching ${bin} — press Ctrl+C or type /exit inside ${bin} to return.\n`);
+    // Best-effort escape hint (Unix only — on Windows we skip the handler).
+    if (process.platform !== 'win32') {
+        out.write('(Ctrl+C twice quickly → back to the myshell menu)\n');
+    }
     // stdio:'inherit' hands the terminal to the native CLI so its interactive
     // session runs in place. reject:false so we return to menu on any exit code.
-    await execa(bin, [], { stdio: 'inherit', reject: false });
+    const subprocess = execa(bin, [], { stdio: 'inherit', reject: false });
+    // Unix-only: register the rapid-double-Ctrl+C escape handler.
+    // On Windows: skip entirely — SIGINT/process-group semantics differ and
+    // forced interception risks a broken console. Behaviour is as before today.
+    if (process.platform !== 'win32') {
+        const INTERRUPT_WINDOW_MS = 1_500;
+        const interruptTimes = [];
+        const rawSigintHandler = () => {
+            const now = Date.now();
+            interruptTimes.push(now);
+            const count = countRecentInterrupts(interruptTimes, now, INTERRUPT_WINDOW_MS);
+            // count === 1: do nothing — let the single Ctrl+C reach the child via the
+            // terminal's foreground-group delivery. Do NOT kill or write anything here.
+            if (shouldEscapeRawSession(count)) {
+                // Rapid double press → user wants to return to the menu.
+                out.write('\n[info] Returning to menu…\n');
+                subprocess.kill('SIGTERM');
+            }
+        };
+        process.on('SIGINT', rawSigintHandler);
+        try {
+            await subprocess;
+        }
+        finally {
+            process.removeListener('SIGINT', rawSigintHandler);
+        }
+    }
+    else {
+        // Windows: no SIGINT handler — await the child normally.
+        await subprocess;
+    }
     out.write(`\nReturned from ${bin}.\n`);
 }
 // ---------------------------------------------------------------------------
 // Chat loop
 // ---------------------------------------------------------------------------
-async function runChatLoop(ctx, mutableCtx, convId, out, readLine) {
+/**
+ * Run the interactive chat loop for a single conversation.
+ *
+ * Returns `'menu'` when the user exits normally (/back, /exit, EOF, or 2×Ctrl+C)
+ * and `'exit'` when the user presses Ctrl+C three times within the 1 500 ms window,
+ * signalling that the entire app should quit.
+ *
+ * The SIGINT handler uses a press-counting model (window ~1 500 ms, timestamps from
+ * `ctx.clock.now()`):
+ *   1 press while a task runs  → cancel the task, stay in chat.
+ *   1 press at the prompt      → print a hint, stay in chat.
+ *   2 presses within the window → abort any running task, break to menu.
+ *   3 presses within the window → abort any running task, break and signal exit.
+ *
+ * The handler is registered on entry and removed in the `finally` block so it
+ * never leaks between chat sessions. NO process.exit() is called here; cli.ts
+ * owns process lifetime.
+ */
+async function runChatLoop(ctx, mutableCtx, convId, out, readLine, loginFn, detectEnvironmentFn) {
     // Print a short recap of the conversation (last entry) if history exists
     const history = await ctx.store.load(convId);
     if (history.length > 0) {
@@ -642,22 +772,78 @@ async function runChatLoop(ctx, mutableCtx, convId, out, readLine) {
     }
     out.write(prompt('task or /help', out.color) + '\n');
     let currentAc = null;
-    // Handle SIGINT: cancel in-flight task or return to menu
+    // Interrupt timestamps — populated on each SIGINT; checked against the
+    // 1 500 ms sliding window. Using ctx.clock.now() (not Date.now) so tests
+    // can drive time with a fake clock.
+    const interruptTimes = [];
+    const INTERRUPT_WINDOW_MS = 1_500;
+    // The 'exit' signal is communicated from the SIGINT handler to the main
+    // loop via this flag (the handler can't break the outer while directly).
+    let shouldExit = false;
+    // Handle Ctrl+C with the press-counting model.
     const sigintHandler = () => {
-        if (currentAc !== null) {
-            currentAc.abort();
-            out.write('\n[warn] Task cancelled.\n');
+        const now = ctx.clock.now();
+        interruptTimes.push(now);
+        const count = countRecentInterrupts(interruptTimes, now, INTERRUPT_WINDOW_MS);
+        const action = interpretInterrupt(count, currentAc !== null);
+        if (action === 'cancel-task') {
+            currentAc?.abort();
             currentAc = null;
+            out.write('\n[warn] Task cancelled. (Ctrl+C again → menu, ×3 → exit)\n');
+        }
+        else if (action === 'hint') {
+            out.write('\n[info] Ctrl+C again → back to menu, ×3 → exit to shell.\n');
+        }
+        else if (action === 'to-menu') {
+            // Abort any running task, then tell the main loop to break back to menu.
+            if (currentAc !== null) {
+                currentAc.abort();
+                currentAc = null;
+            }
+            // Signal the main loop; the loop checks this flag after each await.
+            shouldExit = false;
+            // We can't directly break the loop from an event handler, so we set a
+            // flag and resolve any pending readLine by closing (the loop checks the
+            // flag). In practice the loop is either awaiting readLine() or runTask().
+            // For the readLine case the user typed nothing yet — we need to interrupt
+            // that await. We use a shared resolver pattern: see loopBreaker below.
+            loopBreaker?.('menu');
         }
         else {
-            out.write('\n[info] Use /back or /exit to return to the menu.\n');
+            // exit-app
+            if (currentAc !== null) {
+                currentAc.abort();
+                currentAc = null;
+            }
+            shouldExit = true;
+            loopBreaker?.('exit');
         }
     };
+    // loopBreaker lets the SIGINT handler resolve the loop-level promise so the
+    // `while (true)` can break immediately even when awaiting readLine().
+    let loopBreaker = null;
     process.on('SIGINT', sigintHandler);
+    let loopResult = 'menu';
     try {
         while (true) {
             out.write('myshell-tools> ');
-            const line = await readLine();
+            // Race readLine() against a loopBreak signal from the SIGINT handler.
+            // When Ctrl+C fires (to-menu or exit-app), loopBreaker is called with the
+            // desired result, which wins the race and breaks the loop.
+            const line = await new Promise((resolve) => {
+                loopBreaker = resolve;
+                readLine().then(resolve).catch(() => resolve(null));
+            });
+            loopBreaker = null;
+            // SIGINT-driven exit signals
+            if (line === 'menu') {
+                loopResult = 'menu';
+                break;
+            }
+            if (line === 'exit') {
+                loopResult = 'exit';
+                break;
+            }
             // EOF → exit the chat loop gracefully
             if (line === null)
                 break;
@@ -683,15 +869,16 @@ async function runChatLoop(ctx, mutableCtx, convId, out, readLine) {
             // Build per-provider advertised model sets from the live env so route()
             // can prefer a model the CLI actually advertises. Only include installed
             // providers (exactOptionalPropertyTypes is ON).
+            // Use mutableCtx.env (not ctx.env) so post-login re-detect is reflected.
             const menuAvailableModels = {};
-            if (ctx.env.claude.installed && ctx.env.claude.availableModels.length > 0) {
-                menuAvailableModels['claude'] = ctx.env.claude.availableModels;
+            if (mutableCtx.env.claude.installed && mutableCtx.env.claude.availableModels.length > 0) {
+                menuAvailableModels['claude'] = mutableCtx.env.claude.availableModels;
             }
-            if (ctx.env.codex.installed && ctx.env.codex.availableModels.length > 0) {
-                menuAvailableModels['codex'] = ctx.env.codex.availableModels;
+            if (mutableCtx.env.codex.installed && mutableCtx.env.codex.availableModels.length > 0) {
+                menuAvailableModels['codex'] = mutableCtx.env.codex.availableModels;
             }
-            if (ctx.env.opencode.installed && ctx.env.opencode.availableModels.length > 0) {
-                menuAvailableModels['opencode'] = ctx.env.opencode.availableModels;
+            if (mutableCtx.env.opencode.installed && mutableCtx.env.opencode.availableModels.length > 0) {
+                menuAvailableModels['opencode'] = mutableCtx.env.opencode.availableModels;
             }
             const deps = {
                 clock: ctx.clock,
@@ -707,13 +894,50 @@ async function runChatLoop(ctx, mutableCtx, convId, out, readLine) {
             };
             const ac = new AbortController();
             currentAc = ac;
-            await runTask(line, deps, out, ac.signal);
+            const result = await runTask(line, deps, out, ac.signal);
             currentAc = null;
+            // Check for a loopBreaker signal that fired during the task (e.g. 3×Ctrl+C
+            // while runTask was awaited — the abort fires and the flag is set).
+            if (shouldExit) {
+                loopResult = 'exit';
+                break;
+            }
+            // Inline re-login on auth failure: offer to sign in and retry once.
+            if (result.final !== undefined &&
+                !result.final.success &&
+                result.final.errorCategory === 'auth' &&
+                result.final.provider !== undefined) {
+                const failingProvider = result.final.provider;
+                out.write(`\n[warn] ${failingProvider} isn't signed in.\n`);
+                out.write(`Sign in to ${failingProvider} now and retry? (Y/n) `);
+                const ans = await readLine();
+                if (parseYesNo(ans, true)) {
+                    await loginFn(out, failingProvider, { readLine });
+                    mutableCtx.env = await detectEnvironmentFn();
+                    // Retry the same task once.
+                    const retryAc = new AbortController();
+                    currentAc = retryAc;
+                    const retryResult = await runTask(line, deps, out, retryAc.signal);
+                    currentAc = null;
+                    if (shouldExit) {
+                        loopResult = 'exit';
+                        break;
+                    }
+                    // If still auth failure after retry, inform and continue to prompt.
+                    if (retryResult.final !== undefined &&
+                        !retryResult.final.success &&
+                        retryResult.final.errorCategory === 'auth') {
+                        out.write(`\n[warn] Still not signed in to ${failingProvider}. Returning to prompt.\n`);
+                    }
+                }
+            }
         }
     }
     finally {
         process.removeListener('SIGINT', sigintHandler);
+        loopBreaker = null;
     }
+    return loopResult;
 }
 // ---------------------------------------------------------------------------
 // Main screen render
@@ -883,7 +1107,9 @@ export async function startMenu(ctx, out) {
                 const firstMsg = await readLine();
                 if (firstMsg !== null && firstMsg.length > 0) {
                     const meta = await ctx.store.create(firstMsg);
-                    await runChatLoop(ctx, mutableCtx, meta.id, out, readLine);
+                    const chatResult = await runChatLoop(ctx, mutableCtx, meta.id, out, readLine, loginFn, detectEnvironmentFn);
+                    if (chatResult === 'exit')
+                        break;
                 }
                 continue;
             }
@@ -892,7 +1118,9 @@ export async function startMenu(ctx, out) {
                 const all = await ctx.store.list();
                 const latest = all[0];
                 if (latest !== undefined) {
-                    await runChatLoop(ctx, mutableCtx, latest.id, out, readLine);
+                    const chatResult = await runChatLoop(ctx, mutableCtx, latest.id, out, readLine, loginFn, detectEnvironmentFn);
+                    if (chatResult === 'exit')
+                        break;
                 }
                 else {
                     out.write('No conversations yet. Press n to start one.\n');
@@ -904,7 +1132,9 @@ export async function startMenu(ctx, out) {
             if (!Number.isNaN(digit) && digit >= 1 && digit <= 9) {
                 const target = metas[digit - 1];
                 if (target !== undefined) {
-                    await runChatLoop(ctx, mutableCtx, target.id, out, readLine);
+                    const chatResult = await runChatLoop(ctx, mutableCtx, target.id, out, readLine, loginFn, detectEnvironmentFn);
+                    if (chatResult === 'exit')
+                        break;
                 }
                 else {
                     out.write(`No conversation at position ${digit}.\n`);
@@ -918,7 +1148,9 @@ export async function startMenu(ctx, out) {
             }
             // ---- [i] Import a native conversation -----------------------------------
             if (key === 'i') {
-                await runImportNative(ctx, mutableCtx, out, readLine);
+                const importResult = await runImportNative(ctx, mutableCtx, out, readLine, loginFn, detectEnvironmentFn);
+                if (importResult === 'exit')
+                    break;
                 continue;
             }
             // ---- [r] Open a raw provider session ------------------------------------