myshell-tools 2.8.0 → 2.13.0

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.
  *
@@ -322,10 +371,15 @@ async function runWelcome(ctx, out, readLine, mutableConfig, installProviderFn,
     out.write('Set myshell-tools as your default shell tool? (y/N) ');
     const defaultAns = await readLine();
     const setAsDefault = parseYesNo(defaultAns, false);
+    // Default is NO for auto-update — require explicit 'y' to enable.
+    out.write('Keep myshell-tools up to date automatically? (y/N) ');
+    const autoUpdateAns = await readLine();
+    const autoUpdate = parseYesNo(autoUpdateAns, false);
     const saved = {
         onboarded: true,
         setAsDefault,
         ...(updated.mode !== undefined ? { mode: updated.mode } : {}),
+        ...(autoUpdate ? { autoUpdate: true } : {}),
     };
     await saveConfig(saved);
     // When the user opts in, actually write the shell startup hook (real install,
@@ -393,6 +447,7 @@ async function runSettings(_ctx, mutableCtx, out, readLine) {
         '',
         `  [1] Mode: ${cfg.mode ?? 'balanced'}`,
         `  [2] Set as default shell: ${cfg.setAsDefault ? 'on' : 'off'}`,
+        `  [3] Auto-update: ${cfg.autoUpdate === true ? 'on' : 'off'}`,
         '',
         '  [Enter] Back',
         '',
@@ -409,8 +464,27 @@ async function runSettings(_ctx, mutableCtx, out, readLine) {
     else if (key === '2') {
         mutableCtx.config = await toggleDefaultShell(mutableCtx.config, out);
     }
+    else if (key === '3') {
+        mutableCtx.config = await toggleAutoUpdate(mutableCtx.config, out);
+    }
     // anything else → back
 }
+/**
+ * Toggle the auto-update preference and persist the updated config.
+ * Reports the new state so the user knows what changed.
+ */
+async function toggleAutoUpdate(config, out) {
+    const enable = config.autoUpdate !== true;
+    const updated = {
+        onboarded: config.onboarded,
+        setAsDefault: config.setAsDefault,
+        ...(config.mode !== undefined ? { mode: config.mode } : {}),
+        ...(enable ? { autoUpdate: true } : {}),
+    };
+    await saveConfig(updated);
+    out.write(`Auto-update: ${enable ? 'on' : 'off'}\n`);
+    return updated;
+}
 // ---------------------------------------------------------------------------
 // Manage conversations screen
 // ---------------------------------------------------------------------------
@@ -515,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';
@@ -529,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();
@@ -551,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) {
@@ -598,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) {
@@ -617,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;
@@ -658,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,
@@ -682,22 +894,63 @@ 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
 // ---------------------------------------------------------------------------
-async function renderMainScreen(ctx, mutableCtx, metas, out) {
+async function renderMainScreen(ctx, mutableCtx, metas, out, updateInfo) {
     out.write('\n');
     // Header box — always box(), 🧠 emoji, real provider data
     const headerLines = renderHeaderLines(mutableCtx.env, ctx.version);
     out.write(box(`🧠 myshell-tools v${ctx.version}`, headerLines) + '\n\n');
+    // Update banner — only shown when a newer version is genuinely available
+    if (updateInfo?.updateAvailable === true && updateInfo.latest !== null) {
+        out.write(`  ▲ Update available: ${updateInfo.current} → ${updateInfo.latest}  (press u)\n\n`);
+    }
     // Budget line — real ledger data, never fabricated
     const entries = await readLedger(ctx.cwd);
     const spend = summarizeSpend(entries, ctx.clock.isoNow());
@@ -727,6 +980,10 @@ async function renderMainScreen(ctx, mutableCtx, metas, out) {
         { key: 'k', label: 'Login Codex', section: 'Auth' },
         { key: 'o', label: opencodeLabel, section: 'Auth' },
     ];
+    // [u] Update now — shown only when a newer version is actually available
+    const updateEntry = updateInfo?.updateAvailable === true && updateInfo.latest !== null
+        ? [{ key: 'u', label: `Update now (→ ${updateInfo.latest})`, section: 'Options' }]
+        : [];
     // Menu — sectioned via menu()
     out.write(menu([
         { key: 'c', label: 'Continue last conversation', section: 'Conversations' },
@@ -739,6 +996,7 @@ async function renderMainScreen(ctx, mutableCtx, metas, out) {
         { key: 's', label: 'Settings', section: 'Options' },
         { key: 'd', label: 'Doctor', section: 'Options' },
         { key: '$', label: 'Cost', section: 'Options' },
+        ...updateEntry,
         { key: 'q', label: 'Quit', section: 'Options' },
     ]) + '\n\n');
 }
@@ -766,6 +1024,9 @@ export async function startMenu(ctx, out) {
     const installProviderFn = ctx.installProvider !== undefined ? ctx.installProvider : installProvider;
     const loginFn = ctx.login !== undefined ? ctx.login : runLogin;
     const detectEnvironmentFn = ctx.detectEnvironment !== undefined ? ctx.detectEnvironment : detectEnvironment;
+    const checkForUpdateFn = ctx.checkForUpdate;
+    const updateSelfFn = ctx.updateSelf;
+    const relaunchFn = ctx.relaunch;
     // Build the readLine function — either injected (for tests) or backed by a
     // real readline interface driven by the event-driven LineReader queue.
     let readLine;
@@ -803,10 +1064,33 @@ export async function startMenu(ctx, out) {
             // status (e.g. codex now "ready" if the user signed in during setup).
             mutableCtx.env = await detectEnvironmentFn();
         }
+        // ---- Update check (once per launch, after onboarding) --------------------
+        // Fast path: uses the cache when fresh, so it never hangs.
+        // Injected seam allows tests to stay hermetic (no real npm registry calls).
+        let updateInfo;
+        if (checkForUpdateFn !== undefined) {
+            updateInfo = await checkForUpdateFn().catch(() => undefined);
+        }
+        // ---- Opt-in auto-update at launch ----------------------------------------
+        // Guard: only runs once; requires both the update and relaunch seams to be wired.
+        if (mutableCtx.config.autoUpdate === true &&
+            updateInfo?.updateAvailable === true &&
+            updateInfo.latest !== null &&
+            updateSelfFn !== undefined) {
+            out.write(`▲ Auto-updating ${updateInfo.current} → ${updateInfo.latest}…\n`);
+            const ok = await updateSelfFn(out).catch(() => false);
+            if (ok) {
+                if (relaunchFn !== undefined) {
+                    await relaunchFn().catch(() => 1);
+                }
+                return; // Relinquish control to the freshly-installed version.
+            }
+            out.write('Auto-update failed — continuing with current version.\n');
+        }
         // ---- B. Main screen loop -------------------------------------------------
         while (true) {
             const metas = await ctx.store.list();
-            await renderMainScreen(ctx, mutableCtx, metas, out);
+            await renderMainScreen(ctx, mutableCtx, metas, out, updateInfo);
             out.write('> ');
             const key = await readLine();
             // ---- EOF / close — exit gracefully (FIX 1: no ERR_USE_AFTER_CLOSE) ----
@@ -823,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;
             }
@@ -832,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');
@@ -844,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`);
@@ -858,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 ------------------------------------
@@ -908,6 +1200,18 @@ export async function startMenu(ctx, out) {
                 mutableCtx.env = await detectEnvironmentFn();
                 continue;
             }
+            // ---- [u] Update now -----------------------------------------------------
+            // Only active when an update is actually available and the seam is wired.
+            if (key === 'u' && updateInfo?.updateAvailable === true && updateSelfFn !== undefined) {
+                const ok = await updateSelfFn(out).catch(() => false);
+                if (ok && updateInfo.latest !== null) {
+                    out.write(`✓ Updated to ${updateInfo.latest} — restart myshell-tools to use it.\n`);
+                }
+                else if (!ok) {
+                    out.write('Update failed. Run: npm install -g myshell-tools@latest\n');
+                }
+                continue;
+            }
             // ---- [s] Settings -------------------------------------------------------
             if (key === 's') {
                 await runSettings(ctx, mutableCtx, out, readLine);