@redonvn/cli 0.1.9 → 0.1.11

package/dist/cli/commands/ask.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -45,11 +12,15 @@ exports.askCommand = askCommand;
  */
 const chalk_1 = __importDefault(require("chalk"));
 const readline_1 = __importDefault(require("readline"));
-const axios_1 = __importDefault(require("axios"));
 const store_1 = require("../../auth/store");
 const permissions_1 = require("../../auth/permissions");
 const permissions_2 = require("../../auth/permissions");
 const config_1 = require("../../config");
+const agent_1 = require("../../api/agent");
+const chat_1 = require("../../api/chat");
+const config_2 = require("../../mcp/config");
+const client_1 = require("../../mcp/client");
+const chrome_launcher_1 = require("../../mcp/chrome-launcher");
 // ─── Session state ─────────────────────────────────────────────────────────────
 let currentThreadId = null;
 let currentAgentId = null;
@@ -63,16 +34,26 @@ const LOGO = [
     '  ██║  ██║███████╗██████╔╝██║  ██║██║',
     '  ╚═╝  ╚═╝╚══════╝╚═════╝ ╚═╝  ╚═╝╚═╝',
 ];
+// Gradient #FF3333 → #FFCC99 top→bottom (logo) / #FFCC99 → #FF3333 for highlights
+function gradientColor(step, total) {
+    const t = total <= 1 ? 0 : step / (total - 1);
+    const r = 0xFF;
+    const g = Math.round(0xCC - t * (0xCC - 0x33));
+    const b = Math.round(0x99 - t * (0x99 - 0x33));
+    return chalk_1.default.rgb(r, g, b);
+}
+// Single highlight color: bright orange-red, same family as logo
+const HIGHLIGHT = chalk_1.default.rgb(0xFF, 0x66, 0x33);
 function printBanner(cfg) {
     console.log();
-    for (const line of LOGO) {
-        console.log(chalk_1.default.cyan(line));
-    }
+    LOGO.forEach((line, i) => {
+        console.log(gradientColor(i, LOGO.length)(line));
+    });
     console.log();
     console.log(chalk_1.default.dim('  v' + config_1.CLI_VERSION) +
         '  ' +
         chalk_1.default.white(cfg.userName ?? cfg.userEmail ?? String(cfg.userId)));
-    console.log(chalk_1.default.dim('  Type / to see commands, Ctrl-C to exit.'));
+    console.log(chalk_1.default.dim('  Type / for commands  ·  ↑↓ navigate  ·  Ctrl+Enter new line  ·  Ctrl-C exit'));
     console.log();
 }
 // ─── Slash command list ────────────────────────────────────────────────────────
@@ -81,7 +62,8 @@ const COMMANDS = [
     { cmd: '/account', desc: 'Account info' },
     { cmd: '/agents', desc: 'List AI agents — select default' },
     { cmd: '/permissions', desc: 'View / toggle tool permissions on this machine' },
-    { cmd: '/mcps', desc: 'List configured MCP servers' },
+    { cmd: '/mcps', desc: 'List MCP servers and their tools' },
+    { cmd: '/threads', desc: 'Browse & switch conversation threads' },
     { cmd: '/thread', desc: 'Show current conversation thread ID' },
     { cmd: '/new', desc: 'Start a new conversation thread' },
     { cmd: '/clear', desc: 'Clear screen' },
@@ -92,7 +74,7 @@ function printHelp() {
     console.log(chalk_1.default.bold(' Commands'));
     console.log();
     for (const { cmd, desc } of COMMANDS) {
-        console.log(`  ${chalk_1.default.cyan(cmd.padEnd(16))}  ${chalk_1.default.dim(desc)}`);
+        console.log(`  ${HIGHLIGHT(cmd.padEnd(16))}  ${chalk_1.default.dim(desc)}`);
     }
     console.log();
     console.log(chalk_1.default.dim('  Type anything else to chat with the current agent.'));
@@ -110,16 +92,50 @@ function printAccount(cfg) {
         (cfg.expiresAt < Date.now() ? chalk_1.default.red('  (EXPIRED)') : ''));
     console.log();
 }
-// ─── /agents ──────────────────────────────────────────────────────────────────
-async function printAgents(cfg, rl) {
-    process.stdout.write(chalk_1.default.dim('  Loading agents...\r'));
+// ─── /agents — viewport TUI with lazy-load pagination ────────────────────────
+//
+// Layout (VIEWPORT_SIZE rows visible at a time):
+//
+//   AI Agents  (42)  ↑↓ move · Enter select · 0 reset · Esc cancel
+//   Default (no agent): RedAI
+//
+//    ❯ ●  CLI Proxy                        ← focused row
+//      ○  Trung Hiếu
+//      ○  ...
+//   ── loading more... ──                  ← shown when fetching next page
+//
+// viewTop = first visible index in `agents[]`.
+// cursor  = absolute index in `agents[]`.
+// When cursor reaches viewTop + VIEWPORT_SIZE - LOAD_AHEAD and more pages exist,
+// fetch next page silently and append to `agents[]`.
+const VIEWPORT_SIZE = 12;
+const LOAD_AHEAD = 3; // trigger fetch when this many rows remain below cursor
+const PAGE_SIZE = 20;
+const AGENT_COL = 28;
+function buildAgentRow(a, focused) {
+    const bullet = a.id === currentAgentId ? chalk_1.default.green('●') : chalk_1.default.dim('○');
+    const inactive = a.active ? '' : chalk_1.default.red(' (off)');
+    const pad = a.name.slice(0, AGENT_COL).padEnd(AGENT_COL);
+    const nameStr = focused
+        ? HIGHLIGHT.bold(pad)
+        : a.id === currentAgentId
+            ? chalk_1.default.bold.green(pad)
+            : chalk_1.default.white(pad);
+    return (focused ? HIGHLIGHT(' ❯ ') : '   ') + bullet + '  ' + nameStr + inactive;
+}
+async function interactiveAgents(cfg) {
+    process.stdout.write(chalk_1.default.dim('\n  Loading agents...\r'));
     let agents = [];
+    let totalItems = 0;
+    let currentPage = 1;
+    let totalPages = 1;
+    let loadingMore = false;
     try {
-        const res = await axios_1.default.get(`${cfg.apiBaseUrl}/api/v1/user/agents?pageSize=50&active=true`, {
-            headers: buildHeaders(cfg),
-            timeout: 10000,
-        });
-        agents = res.data?.data?.items ?? [];
+        const first = await (0, agent_1.fetchAgentsPage)(cfg, 1, PAGE_SIZE);
+        agents = first.items;
+        totalItems = first.meta.totalItems;
+        totalPages = first.meta.totalPages;
+        currentPage = 1;
     }
     catch {
         process.stdout.write('                        \r');
@@ -133,44 +149,152 @@ async function printAgents(cfg, rl) {
         console.log();
         return;
     }
-    console.log();
-    console.log(chalk_1.default.bold(` AI Agents  (${agents.length})`));
-    console.log();
-    agents.forEach((a, i) => {
-        const current = a.id === currentAgentId;
-        const bullet = current ? chalk_1.default.green('●') : chalk_1.default.dim('○');
-        const name = current ? chalk_1.default.bold.green(a.name) : a.name;
-        const type = a.typeEnum ? chalk_1.default.dim(` [${a.typeEnum}]`) : '';
-        const active = a.active ? '' : chalk_1.default.red(' (inactive)');
-        console.log(`  ${bullet}  ${String(i + 1).padStart(2)}.  ${name}${type}${active}`);
-    });
-    console.log();
-    console.log(chalk_1.default.dim('  Enter number to select agent, or press Enter to keep current.'));
-    // Pause readline and wait for selection inline
-    rl.pause();
-    const answer = await new Promise((resolve) => {
-        const tmp = readline_1.default.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
-        process.stdout.write(chalk_1.default.dim('  › '));
-        tmp.once('line', (line) => { tmp.close(); resolve(line.trim()); });
-    });
-    rl.resume();
-    if (!answer) {
+    // cursor starts on currently selected agent, or 0
+    let cursor = Math.max(0, agents.findIndex(a => a.id === currentAgentId));
+    let viewTop = Math.max(0, Math.min(cursor, agents.length - VIEWPORT_SIZE));
+    // ── render helpers ─────────────────────────────────────────────────────────
+    // Number of rows currently shown (min of VIEWPORT_SIZE and available)
+    const viewLen = () => Math.min(VIEWPORT_SIZE, agents.length - viewTop);
+    // Header line (2 fixed lines) + viewLen data rows + footer (1 line) = full block
+    const HEADER_LINES = 3; // blank + title + hint
+    const FOOTER_LINES = 1; // blank line after list
+    const blockLines = () => HEADER_LINES + viewLen() + FOOTER_LINES;
+    const printBlock = () => {
+        const shown = viewLen();
         console.log();
-        return;
-    }
-    const idx = parseInt(answer, 10) - 1;
-    if (isNaN(idx) || idx < 0 || idx >= agents.length) {
-        console.log(chalk_1.default.yellow('  Invalid selection.'));
+        console.log(chalk_1.default.bold(` AI Agents  (${totalItems})`) +
+            chalk_1.default.dim('  ↑↓ move  ·  Enter select  ·  0 reset  ·  Esc cancel'));
+        console.log(chalk_1.default.dim('  Default (no agent): RedAI'));
+        for (let i = 0; i < shown; i++) {
+            const absIdx = viewTop + i;
+            console.log(buildAgentRow(agents[absIdx], absIdx === cursor));
+        }
         console.log();
-        return;
-    }
-    const chosen = agents[idx];
-    currentAgentId = chosen.id;
-    currentAgentName = chosen.name;
-    console.log(chalk_1.default.green(`\n  ✓ Agent set to: ${chalk_1.default.bold(chosen.name)}`));
-    console.log();
+    };
+    // Full redraw: erase existing block, reprint from top
+    const redraw = () => {
+        const bl = blockLines();
+        // Move up past entire block + erase to end of screen
+        process.stdout.write(`\x1B[${bl}A\r\x1B[J`);
+        printBlock();
+    };
+    // Repaint a single row in the viewport (absIdx = absolute index in agents[])
+    const repaintRow = (absIdx) => {
+        const relIdx = absIdx - viewTop;
+        if (relIdx < 0 || relIdx >= viewLen())
+            return;
+        // From bottom of block (after trailing blank line), move up to that row
+        const stepsUp = FOOTER_LINES + (viewLen() - 1 - relIdx) + 1; // +1 for blank
+        process.stdout.write(`\x1B[${stepsUp}A\r\x1B[2K`);
+        process.stdout.write(buildAgentRow(agents[absIdx], absIdx === cursor));
+        process.stdout.write(`\x1B[${stepsUp}B\r`);
+    };
+    printBlock();
+    // ── lazy-load next page ────────────────────────────────────────────────────
+    const maybeLoadMore = (resolve, handler) => {
+        if (loadingMore)
+            return;
+        if (currentPage >= totalPages)
+            return;
+        // trigger when cursor is within LOAD_AHEAD rows of the end of loaded list
+        if (cursor < agents.length - LOAD_AHEAD)
+            return;
+        loadingMore = true;
+        const nextPage = currentPage + 1;
+        // Show "loading" indicator on the last visible row
+        const lastVisAbs = viewTop + viewLen() - 1;
+        const stepsUp = FOOTER_LINES + 1; // blank + last row
+        process.stdout.write(`\x1B[${stepsUp}A\r\x1B[2K`);
+        process.stdout.write(chalk_1.default.dim('  ── loading more... ──'));
+        process.stdout.write(`\x1B[${stepsUp}B\r`);
+        (0, agent_1.fetchAgentsPage)(cfg, nextPage, PAGE_SIZE).then((page) => {
+            agents.push(...page.items);
+            currentPage = nextPage;
+            totalPages = page.meta.totalPages;
+            totalItems = page.meta.totalItems;
+            loadingMore = false;
+            void lastVisAbs;
+            redraw();
+        }).catch(() => {
+            loadingMore = false;
+            // restore overwritten row
+            repaintRow(lastVisAbs);
+        });
+        void resolve;
+        void handler;
+    };
+    // ── keypress loop ──────────────────────────────────────────────────────────
+    await new Promise((resolve) => {
+        const handler = (_char, key) => {
+            if (!key || loadingMore)
+                return;
+            // ↑ / k
+            if (key.name === 'up' || (key.name === 'k' && !key.ctrl)) {
+                if (cursor === 0)
+                    return;
+                const prev = cursor--;
+                if (cursor < viewTop) {
+                    viewTop--;
+                    redraw();
+                }
+                else {
+                    repaintRow(prev);
+                    repaintRow(cursor);
+                }
+                return;
+            }
+            // ↓ / j
+            if (key.name === 'down' || (key.name === 'j' && !key.ctrl)) {
+                if (cursor === agents.length - 1 && currentPage >= totalPages)
+                    return;
+                if (cursor < agents.length - 1) {
+                    const prev = cursor++;
+                    if (cursor >= viewTop + VIEWPORT_SIZE) {
+                        viewTop++;
+                        redraw();
+                    }
+                    else {
+                        repaintRow(prev);
+                        repaintRow(cursor);
+                    }
+                    maybeLoadMore(resolve, handler);
+                }
+                return;
+            }
+            // Enter — select
+            if (key.name === 'return') {
+                process.stdin.removeListener('keypress', handler);
+                const chosen = agents[cursor];
+                currentAgentId = chosen.id;
+                currentAgentName = chosen.name;
+                console.log(chalk_1.default.green(`  ✓ Agent set to: ${chalk_1.default.bold(chosen.name)}`));
+                console.log();
+                resolve();
+                return;
+            }
+            // 0 — reset to default RedAI
+            if (key.name === '0') {
+                process.stdin.removeListener('keypress', handler);
+                currentAgentId = null;
+                currentAgentName = 'RedAI';
+                console.log(chalk_1.default.green('  ✓ Reset to default: RedAI'));
+                console.log();
+                resolve();
+                return;
+            }
+            // Esc / q — cancel
+            if (key.name === 'escape' || key.name === 'q' || (key.ctrl && key.name === 'c')) {
+                process.stdin.removeListener('keypress', handler);
+                console.log(chalk_1.default.dim('  Cancelled. Agent unchanged.'));
+                console.log();
+                resolve();
+                return;
+            }
+        };
+        process.stdin.on('keypress', handler);
+    });
 }
-// ─── /permissions ─────────────────────────────────────────────────────────────
+// ─── /permissions — interactive TUI ──────────────────────────────────────────
 const TOOL_DESC = {
     Read: 'Read files',
     Write: 'Create/overwrite files',
@@ -186,44 +310,513 @@ const TOOL_DESC = {
     McpCall: 'Call MCP tool',
     McpList: 'List MCP tools',
 };
-function printPermissions() {
+// Render one permission row. cursorLine=true → this row is focused.
+function permRow(name, enabled, focused) {
+    const checkbox = enabled ? chalk_1.default.green('[✓]') : chalk_1.default.dim('[ ]');
+    const nameStr = focused
+        ? HIGHLIGHT.bold(name.padEnd(13))
+        : chalk_1.default.white(name.padEnd(13));
+    const desc = focused
+        ? HIGHLIGHT.dim(TOOL_DESC[name])
+        : chalk_1.default.dim(TOOL_DESC[name]);
+    const cursor = focused ? HIGHLIGHT(' ❯ ') : '   ';
+    return cursor + checkbox + '  ' + nameStr + '  ' + desc;
+}
+async function interactivePermissions() {
     const perms = (0, permissions_1.loadPermissions)();
-    console.log();
-    console.log(chalk_1.default.bold(' Tool Permissions') + chalk_1.default.dim('  (edit: redai permission)'));
-    console.log();
-    for (const name of permissions_2.ALL_TOOL_NAMES) {
-        const off = perms[name] === false;
-        const icon = off ? chalk_1.default.red('✗ off') : chalk_1.default.green('✓ on ');
-        console.log(`  ${icon}  ${chalk_1.default.bold(name.padEnd(13))} ${chalk_1.default.dim(TOOL_DESC[name])}`);
-    }
-    console.log();
+    // Build mutable state: enabled[i] mirrors perms for each tool
+    const enabled = permissions_2.ALL_TOOL_NAMES.map((n) => perms[n] !== false);
+    let cursor = 0;
+    const total = permissions_2.ALL_TOOL_NAMES.length;
+    // Print header + all rows
+    const printAll = () => {
+        console.log();
+        console.log(chalk_1.default.bold(' Tool Permissions') +
+            chalk_1.default.dim('  ↑↓ move  ·  Space toggle  ·  Enter save  ·  Esc cancel'));
+        console.log();
+        for (let i = 0; i < total; i++) {
+            console.log(permRow(permissions_2.ALL_TOOL_NAMES[i], enabled[i], i === cursor));
+        }
+        console.log();
+    };
+    // Move cursor up N rows from current bottom of list, rewrite 1 row, return
+    const repaintRow = (idx) => {
+        // cursor is currently at bottom of list (after the trailing \n of printAll)
+        // We need absolute positioning: go up (total - idx) lines from bottom-of-list
+        const stepsUp = total - idx + 1; // +1 for the blank line after list
+        process.stdout.write(`\x1B[${stepsUp}A`); // move up
+        process.stdout.write('\r\x1B[2K'); // clear line
+        process.stdout.write(permRow(permissions_2.ALL_TOOL_NAMES[idx], enabled[idx], idx === cursor));
+        process.stdout.write(`\x1B[${stepsUp}B`); // move back down
+        process.stdout.write('\r');
+    };
+    printAll();
+    return new Promise((resolve) => {
+        const handler = (_char, key) => {
+            if (!key)
+                return;
+            // ↑ / k
+            if (key.name === 'up' || (key.name === 'k' && !key.ctrl)) {
+                if (cursor === 0)
+                    return;
+                const prev = cursor;
+                cursor--;
+                repaintRow(prev);
+                repaintRow(cursor);
+                return;
+            }
+            // ↓ / j
+            if (key.name === 'down' || (key.name === 'j' && !key.ctrl)) {
+                if (cursor === total - 1)
+                    return;
+                const prev = cursor;
+                cursor++;
+                repaintRow(prev);
+                repaintRow(cursor);
+                return;
+            }
+            // Space — toggle
+            if (key.name === 'space') {
+                enabled[cursor] = !enabled[cursor];
+                repaintRow(cursor);
+                return;
+            }
+            // Enter — save & exit
+            if (key.name === 'return') {
+                process.stdin.removeListener('keypress', handler);
+                const newPerms = {};
+                for (let i = 0; i < total; i++) {
+                    newPerms[permissions_2.ALL_TOOL_NAMES[i]] = enabled[i];
+                }
+                (0, permissions_1.savePermissions)(newPerms);
+                const onCount = enabled.filter(Boolean).length;
+                const offCount = total - onCount;
+                console.log(chalk_1.default.green('  ✓ Saved.') +
+                    chalk_1.default.dim(`  ${onCount} enabled, ${offCount} disabled.`));
+                console.log();
+                resolve();
+                return;
+            }
+            // Esc / q / Ctrl-C — cancel
+            if (key.name === 'escape' || key.name === 'q' || (key.ctrl && key.name === 'c')) {
+                process.stdin.removeListener('keypress', handler);
+                console.log(chalk_1.default.dim('  Cancelled. No changes saved.'));
+                console.log();
+                resolve();
+                return;
+            }
+        };
+        process.stdin.on('keypress', handler);
+    });
 }
-// ─── /mcps ────────────────────────────────────────────────────────────────────
-function printMcps() {
-    try {
-        // lazy import to avoid hard dep at top level
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const { loadMcpConfig } = require('../../mcp/config');
-        const servers = loadMcpConfig();
-        const names = Object.keys(servers);
+// ─── /mcps — interactive TUI ──────────────────────────────────────────────────
+//
+// Keys:
+//   ↑↓ / j k   navigate
+//   Space       toggle enable/disable
+//   d           remove server from config
+//   a           open catalog to add servers
+//   Enter/t     test selected server (spawn + list tools)
+//   Esc/q       exit
+async function interactiveMcps() {
+    let servers = (0, config_2.loadMcpConfig)();
+    let cursor = 0;
+    const getNames = () => Object.keys(servers);
+    const COL_NAME = 16;
+    const buildRow = (name, focused) => {
+        const cfg = servers[name];
+        const on = (0, config_2.isMcpEnabled)(cfg);
+        const statusIcon = on ? chalk_1.default.green('●') : chalk_1.default.dim('○');
+        const checkbox = on ? chalk_1.default.green('[on] ') : chalk_1.default.dim('[off]');
+        const nameStr = focused
+            ? HIGHLIGHT.bold(name.padEnd(COL_NAME))
+            : chalk_1.default.white(name.padEnd(COL_NAME));
+        const cmd = chalk_1.default.dim(`${cfg.command} ${(cfg.args ?? []).slice(0, 2).join(' ')}`);
+        const cur = focused ? HIGHLIGHT(' ❯ ') : '   ';
+        return cur + statusIcon + ' ' + checkbox + '  ' + nameStr + '  ' + cmd;
+    };
+    const printAll = (names) => {
         console.log();
-        console.log(chalk_1.default.bold(' MCP Servers'));
+        console.log(chalk_1.default.bold(` MCP Servers  (${names.length})`) +
+            chalk_1.default.dim('  ↑↓ move  ·  Space on/off  ·  d remove  ·  a add  ·  c chrome  ·  Enter test  ·  Esc exit'));
         console.log();
         if (names.length === 0) {
-            console.log(chalk_1.default.dim('  No MCP servers configured.'));
-            console.log(chalk_1.default.dim('  Run `redai mcp add` to configure one.'));
+            console.log(chalk_1.default.dim('  No servers configured. Press a to add from catalog.'));
         }
         else {
-            for (const name of names) {
-                console.log(`  ${chalk_1.default.green('●')}  ${name}`);
+            for (let i = 0; i < names.length; i++) {
+                console.log(buildRow(names[i], i === cursor));
             }
         }
         console.log();
+    };
+    const repaintRow = (idx, names) => {
+        const total = names.length;
+        if (total === 0)
+            return;
+        const stepsUp = total - idx + 1;
+        process.stdout.write(`\x1B[${stepsUp}A\r\x1B[2K`);
+        process.stdout.write(buildRow(names[idx], idx === cursor));
+        process.stdout.write(`\x1B[${stepsUp}B\r`);
+    };
+    const printStatus = (msg) => {
+        process.stdout.write('\r\x1B[2K' + msg + '\n');
+    };
+    printAll(getNames());
+    await new Promise((resolve) => {
+        const handler = async (_char, key) => {
+            if (!key)
+                return;
+            const names = getNames();
+            const total = names.length;
+            if (key.name === 'up' || (key.name === 'k' && !key.ctrl)) {
+                if (total === 0 || cursor === 0)
+                    return;
+                const prev = cursor--;
+                repaintRow(prev, names);
+                repaintRow(cursor, names);
+                return;
+            }
+            if (key.name === 'down' || (key.name === 'j' && !key.ctrl)) {
+                if (total === 0 || cursor === total - 1)
+                    return;
+                const prev = cursor++;
+                repaintRow(prev, names);
+                repaintRow(cursor, names);
+                return;
+            }
+            // Space — toggle enable/disable
+            if (key.name === 'space' && total > 0) {
+                const name = names[cursor];
+                const cfg = servers[name];
+                const nowEnabled = !(0, config_2.isMcpEnabled)(cfg);
+                servers[name] = { ...cfg, enabled: nowEnabled };
+                (0, config_2.saveMcpConfig)(servers);
+                repaintRow(cursor, names);
+                return;
+            }
+            // d — remove focused server
+            if (key.name === 'd' && total > 0) {
+                const name = names[cursor];
+                delete servers[name];
+                (0, config_2.saveMcpConfig)(servers);
+                if (cursor >= Object.keys(servers).length)
+                    cursor = Math.max(0, Object.keys(servers).length - 1);
+                // Full redraw since row count changed
+                process.stdout.write(`\x1B[${total + 3}A`); // jump up past entire list + header + footer
+                process.stdout.write('\x1B[0J'); // erase from cursor to end
+                printAll(getNames());
+                return;
+            }
+            // a — add from catalog (pause this handler, run catalog TUI, resume)
+            if (key.name === 'a') {
+                process.stdin.removeListener('keypress', handler);
+                await addFromCatalogInline(servers);
+                // reload and redraw
+                servers = (0, config_2.loadMcpConfig)();
+                cursor = 0;
+                printAll(getNames());
+                process.stdin.on('keypress', handler);
+                return;
+            }
+            // Enter / t — test focused server
+            if ((key.name === 'return' || key.name === 't') && total > 0) {
+                const name = names[cursor];
+                const cfg = servers[name];
+                if (!(0, config_2.isMcpEnabled)(cfg)) {
+                    printStatus(chalk_1.default.yellow(`  "${name}" is disabled.`));
+                    return;
+                }
+                printStatus(chalk_1.default.dim(`  Connecting to ${name}...`));
+                try {
+                    const client = await client_1.mcpClientPool.getClient(name);
+                    const { tools } = await client.listTools();
+                    printStatus(chalk_1.default.green(`  ✓ ${name}: ${tools.length} tool(s) — ${tools.map(t => t.name).join(', ')}`));
+                    await client_1.mcpClientPool.shutdown();
+                }
+                catch (err) {
+                    printStatus(chalk_1.default.red(`  ✗ ${name}: ${err instanceof Error ? err.message : String(err)}`));
+                }
+                return;
+            }
+            // c — launch Chrome with debug profile for chrome-devtools MCP
+            if (key.name === 'c') {
+                const already = await (0, chrome_launcher_1.isCdpAlive)();
+                if (already) {
+                    printStatus(chalk_1.default.green(`  ✓ Chrome CDP already active on port ${chrome_launcher_1.CDP_PORT}.`));
+                    return;
+                }
+                printStatus(chalk_1.default.dim('  Launching Chrome with debug profile...'));
+                const result = await (0, chrome_launcher_1.launchChromeForDebug)();
+                if (result.ok) {
+                    printStatus(chalk_1.default.green(`  ✓ Chrome launched. CDP ready on port ${chrome_launcher_1.CDP_PORT}.`));
+                }
+                else {
+                    printStatus(chalk_1.default.red(`  ✗ ${result.error}`));
+                }
+                return;
+            }
+            // Esc / q — exit
+            if (key.name === 'escape' || key.name === 'q' || (key.ctrl && key.name === 'c')) {
+                process.stdin.removeListener('keypress', handler);
+                resolve();
+                return;
+            }
+        };
+        process.stdin.on('keypress', handler);
+    });
+}
+// Inline catalog picker called from within /mcps TUI
+async function addFromCatalogInline(existing) {
+    const items = config_2.MCP_CATALOG;
+    let cursor = 0;
+    const selected = new Array(items.length).fill(false);
+    const total = items.length;
+    const COL_NAME = 20;
+    const buildRow = (i, focused) => {
+        const entry = items[i];
+        const alreadyAdded = !!existing[entry.name];
+        const checked = selected[i];
+        const checkbox = alreadyAdded ? chalk_1.default.dim('[~]') : checked ? chalk_1.default.green('[✓]') : chalk_1.default.dim('[ ]');
+        const nameStr = alreadyAdded
+            ? chalk_1.default.dim(entry.name.padEnd(COL_NAME))
+            : focused ? HIGHLIGHT.bold(entry.name.padEnd(COL_NAME)) : chalk_1.default.white(entry.name.padEnd(COL_NAME));
+        const desc = focused && !alreadyAdded ? HIGHLIGHT.dim(entry.description) : chalk_1.default.dim(entry.description);
+        return (focused ? HIGHLIGHT(' ❯ ') : '   ') + checkbox + '  ' + nameStr + '  ' + desc;
+    };
+    const repaintRow = (idx) => {
+        const stepsUp = total - idx + 1;
+        process.stdout.write(`\x1B[${stepsUp}A\r\x1B[2K`);
+        process.stdout.write(buildRow(idx, idx === cursor));
+        process.stdout.write(`\x1B[${stepsUp}B\r`);
+    };
+    console.log();
+    console.log(chalk_1.default.bold(' Add from Catalog') + chalk_1.default.dim('  ↑↓ move  ·  Space select  ·  Enter install  ·  Esc back'));
+    console.log(chalk_1.default.dim('  [~] = already installed'));
+    console.log();
+    for (let i = 0; i < total; i++)
+        console.log(buildRow(i, i === cursor));
+    console.log();
+    await new Promise((resolve) => {
+        const handler = (_char, key) => {
+            if (!key)
+                return;
+            if (key.name === 'up' || (key.name === 'k' && !key.ctrl)) {
+                if (cursor === 0)
+                    return;
+                const prev = cursor--;
+                repaintRow(prev);
+                repaintRow(cursor);
+                return;
+            }
+            if (key.name === 'down' || (key.name === 'j' && !key.ctrl)) {
+                if (cursor === total - 1)
+                    return;
+                const prev = cursor++;
+                repaintRow(prev);
+                repaintRow(cursor);
+                return;
+            }
+            if (key.name === 'space') {
+                if (!existing[items[cursor].name]) {
+                    selected[cursor] = !selected[cursor];
+                    repaintRow(cursor);
+                }
+                return;
+            }
+            if (key.name === 'return') {
+                process.stdin.removeListener('keypress', handler);
+                const toAdd = items.filter((_, i) => selected[i]);
+                for (const entry of toAdd) {
+                    existing[entry.name] = entry.config;
+                    console.log(chalk_1.default.green(`  ✓ Added "${entry.name}"`));
+                    if (entry.config.env)
+                        console.log(chalk_1.default.yellow(`    Needs: ${Object.keys(entry.config.env).join(', ')}`));
+                }
+                if (toAdd.length > 0)
+                    (0, config_2.saveMcpConfig)(existing);
+                else
+                    console.log(chalk_1.default.dim('  Nothing selected.'));
+                console.log();
+                resolve();
+                return;
+            }
+            if (key.name === 'escape' || key.name === 'q' || (key.ctrl && key.name === 'c')) {
+                process.stdin.removeListener('keypress', handler);
+                resolve();
+                return;
+            }
+        };
+        process.stdin.on('keypress', handler);
+    });
+}
+// ─── /threads — viewport TUI with lazy-load pagination ───────────────────────
+const THREAD_VIEWPORT = 12;
+const THREAD_PAGE_SIZE = 20;
+const THREAD_LOAD_AHEAD = 3;
+const THREAD_COL_TITLE = 36;
+function fmtThreadTime(ts) {
+    const d = new Date(ts);
+    const now = new Date();
+    const sameDay = d.toDateString() === now.toDateString();
+    if (sameDay)
+        return d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    return d.toLocaleDateString([], { month: 'short', day: 'numeric' });
+}
+function buildThreadRow(t, focused) {
+    const isCurrent = t.id === currentThreadId;
+    const bullet = isCurrent ? chalk_1.default.cyan('▶') : chalk_1.default.dim('○');
+    const title = (t.title ?? 'Untitled').slice(0, THREAD_COL_TITLE).padEnd(THREAD_COL_TITLE);
+    const time = chalk_1.default.dim(fmtThreadTime(t.updatedAt));
+    const cur = focused ? HIGHLIGHT(' ❯ ') : '   ';
+    const nameStr = focused
+        ? HIGHLIGHT.bold(title)
+        : isCurrent
+            ? chalk_1.default.bold.cyan(title)
+            : chalk_1.default.white(title);
+    return cur + bullet + '  ' + nameStr + '  ' + time;
+}
+async function interactiveThreads(cfg) {
+    process.stdout.write(chalk_1.default.dim('\n  Loading threads...\r'));
+    let threads = [];
+    let totalItems = 0;
+    let currentPage = 1;
+    let totalPages = 1;
+    let loadingMore = false;
+    try {
+        const first = await (0, chat_1.fetchThreadsPage)(cfg, 1, THREAD_PAGE_SIZE);
+        threads = first.items;
+        totalItems = first.meta.totalItems;
+        totalPages = first.meta.totalPages;
     }
     catch {
-        console.log(chalk_1.default.dim('  (MCP config unavailable)'));
+        process.stdout.write('                        \r');
+        console.log(chalk_1.default.red('  ✗ Could not fetch threads.'));
+        console.log();
+        return;
+    }
+    process.stdout.write('                        \r');
+    if (threads.length === 0) {
+        console.log(chalk_1.default.dim('  No threads found. Use /new to create one.'));
         console.log();
+        return;
     }
+    let cursor = Math.max(0, threads.findIndex(t => t.id === currentThreadId));
+    let viewTop = Math.max(0, Math.min(cursor, threads.length - THREAD_VIEWPORT));
+    const HEADER_LINES = 3;
+    const FOOTER_LINES = 1;
+    const viewLen = () => Math.min(THREAD_VIEWPORT, threads.length - viewTop);
+    const blockLines = () => HEADER_LINES + viewLen() + FOOTER_LINES;
+    const printBlock = () => {
+        const shown = viewLen();
+        console.log();
+        console.log(chalk_1.default.bold(` Threads  (${totalItems})`) +
+            chalk_1.default.dim('  ↑↓ move  ·  Enter switch  ·  Esc cancel'));
+        console.log(chalk_1.default.dim(`  Current: ${currentThreadId ? currentThreadId.slice(0, 8) + '…' : 'none'}`));
+        for (let i = 0; i < shown; i++) {
+            console.log(buildThreadRow(threads[viewTop + i], viewTop + i === cursor));
+        }
+        console.log();
+    };
+    const redraw = () => {
+        process.stdout.write(`\x1B[${blockLines()}A\r\x1B[J`);
+        printBlock();
+    };
+    const repaintRow = (absIdx) => {
+        const relIdx = absIdx - viewTop;
+        if (relIdx < 0 || relIdx >= viewLen())
+            return;
+        const stepsUp = FOOTER_LINES + (viewLen() - 1 - relIdx) + 1;
+        process.stdout.write(`\x1B[${stepsUp}A\r\x1B[2K`);
+        process.stdout.write(buildThreadRow(threads[absIdx], absIdx === cursor));
+        process.stdout.write(`\x1B[${stepsUp}B\r`);
+    };
+    printBlock();
+    const maybeLoadMore = () => {
+        if (loadingMore || currentPage >= totalPages)
+            return;
+        if (cursor < threads.length - THREAD_LOAD_AHEAD)
+            return;
+        loadingMore = true;
+        const nextPage = currentPage + 1;
+        const lastVisAbs = viewTop + viewLen() - 1;
+        const stepsUp = FOOTER_LINES + 1;
+        process.stdout.write(`\x1B[${stepsUp}A\r\x1B[2K`);
+        process.stdout.write(chalk_1.default.dim('  ── loading more... ──'));
+        process.stdout.write(`\x1B[${stepsUp}B\r`);
+        (0, chat_1.fetchThreadsPage)(cfg, nextPage, THREAD_PAGE_SIZE).then((page) => {
+            threads.push(...page.items);
+            currentPage = nextPage;
+            totalPages = page.meta.totalPages;
+            totalItems = page.meta.totalItems;
+            loadingMore = false;
+            void lastVisAbs;
+            redraw();
+        }).catch(() => {
+            loadingMore = false;
+            repaintRow(lastVisAbs);
+        });
+    };
+    await new Promise((resolve) => {
+        const handler = (_char, key) => {
+            if (!key || loadingMore)
+                return;
+            if (key.name === 'up' || (key.name === 'k' && !key.ctrl)) {
+                if (cursor === 0)
+                    return;
+                const prev = cursor--;
+                if (cursor < viewTop) {
+                    viewTop--;
+                    redraw();
+                }
+                else {
+                    repaintRow(prev);
+                    repaintRow(cursor);
+                }
+                return;
+            }
+            if (key.name === 'down' || (key.name === 'j' && !key.ctrl)) {
+                if (cursor === threads.length - 1 && currentPage >= totalPages)
+                    return;
+                if (cursor < threads.length - 1) {
+                    const prev = cursor++;
+                    if (cursor >= viewTop + THREAD_VIEWPORT) {
+                        viewTop++;
+                        redraw();
+                    }
+                    else {
+                        repaintRow(prev);
+                        repaintRow(cursor);
+                    }
+                    maybeLoadMore();
+                }
+                return;
+            }
+            if (key.name === 'return') {
+                process.stdin.removeListener('keypress', handler);
+                const chosen = threads[cursor];
+                currentThreadId = chosen.id;
+                // persist to session
+                const s = (0, store_1.loadSession)();
+                s.threads[cfg.apiBaseUrl] = chosen.id;
+                (0, store_1.saveSession)(s);
+                const title = chosen.title ?? 'Untitled';
+                console.log(chalk_1.default.cyan(`  ✓ Switched to: ${chalk_1.default.bold(title.slice(0, 50))}`));
+                console.log(`  ${chalk_1.default.dim('Thread  ')}  ${chosen.id}`);
+                console.log();
+                resolve();
+                return;
+            }
+            if (key.name === 'escape' || key.name === 'q' || (key.ctrl && key.name === 'c')) {
+                process.stdin.removeListener('keypress', handler);
+                console.log(chalk_1.default.dim('  Cancelled. Thread unchanged.'));
+                console.log();
+                resolve();
+                return;
+            }
+        };
+        process.stdin.on('keypress', handler);
+    });
 }
 // ─── /thread ──────────────────────────────────────────────────────────────────
 function printThread() {
@@ -237,127 +830,171 @@ function printThread() {
     }
     console.log();
 }
-// ─── Create / reset thread ────────────────────────────────────────────────────
-async function createThread(cfg, title) {
-    try {
-        const res = await axios_1.default.post(`${cfg.apiBaseUrl}/api/v1/user/chat/threads`, { title }, { headers: buildHeaders(cfg), timeout: 10000 });
-        return res.data?.data?.id ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-// ─── Send message + stream response ───────────────────────────────────────────
-async function sendMessage(cfg, prompt) {
-    // Ensure thread exists
+// ─── Chat ─────────────────────────────────────────────────────────────────────
+async function chat(cfg, prompt) {
     if (!currentThreadId) {
-        process.stdout.write(chalk_1.default.dim('  Creating thread...'));
-        const tid = await createThread(cfg, prompt.slice(0, 80));
-        if (!tid) {
-            process.stdout.write('\r' + ' '.repeat(30) + '\r');
-            console.log(chalk_1.default.red('  ✗ Could not create thread. Check connection.'));
-            console.log();
-            return;
-        }
-        currentThreadId = tid;
-        process.stdout.write('\r' + ' '.repeat(30) + '\r');
+        console.log(chalk_1.default.yellow('\n  No active thread. Run /new to create one first.\n'));
+        return;
     }
-    // Send message → get runId
-    process.stdout.write(chalk_1.default.dim(`  ⠸ ${currentAgentName}...`));
-    let runId = null;
+    // Animated spinner: cycles until first delta or error
+    const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let frameIdx = 0;
+    let spinnerActive = false;
+    let spinnerTimer = null;
+    const startSpinner = (label) => {
+        spinnerActive = true;
+        frameIdx = 0;
+        process.stdout.write(chalk_1.default.dim(`  ${FRAMES[0]} ${label}...`));
+        spinnerTimer = setInterval(() => {
+            if (!spinnerActive)
+                return;
+            frameIdx = (frameIdx + 1) % FRAMES.length;
+            process.stdout.write(`\r  ${chalk_1.default.dim(FRAMES[frameIdx] + ' ' + label + '...')}`);
+        }, 80);
+    };
+    const stopSpinner = () => {
+        if (!spinnerActive)
+            return; // idempotent — don't erase content after spinner stopped
+        if (spinnerTimer) {
+            clearInterval(spinnerTimer);
+            spinnerTimer = null;
+        }
+        spinnerActive = false;
+        process.stdout.write('\r' + ' '.repeat(40) + '\r');
+    };
+    startSpinner(currentAgentName);
+    let runId;
     try {
-        const body = {
-            contentBlocks: [{ type: 'text', text: prompt }],
-            agentMode: 'FAST',
-        };
-        if (currentAgentId)
-            body.agentId = currentAgentId;
-        const res = await axios_1.default.post(`${cfg.apiBaseUrl}/api/v1/user/chat/threads/${currentThreadId}/messages`, body, { headers: buildHeaders(cfg), timeout: 30000 });
-        runId = res.data?.data?.runId ?? null;
-        if (!runId)
-            throw new Error('No runId returned');
+        const result = await (0, chat_1.sendMessage)(cfg, currentThreadId, prompt, currentAgentId);
+        runId = result.runId;
     }
     catch (err) {
-        process.stdout.write('\r' + ' '.repeat(40) + '\r');
-        const msg = axios_1.default.isAxiosError(err) && err.response
-            ? `${err.response.status}: ${JSON.stringify(err.response.data)}`
-            : err instanceof Error ? err.message : String(err);
-        console.log(chalk_1.default.red(`  ✗ ${msg}`));
+        stopSpinner();
+        console.log(chalk_1.default.red(`  ✗ ${err instanceof Error ? err.message : String(err)}`));
         console.log();
         return;
     }
-    process.stdout.write('\r' + ' '.repeat(40) + '\r');
-    // Stream SSE response
-    console.log();
-    process.stdout.write(chalk_1.default.dim('  '));
+    // Spinner keeps running while waiting for first SSE event
+    let firstEvent = true;
+    let streamErrored = false;
+    const stopSpinnerAndBegin = () => {
+        if (!firstEvent)
+            return;
+        firstEvent = false;
+        stopSpinner();
+        console.log();
+        process.stdout.write(chalk_1.default.dim('  '));
+    };
+    const streamCbs = {
+        onDelta: (text) => {
+            stopSpinnerAndBegin();
+            process.stdout.write(text);
+        },
+        onToolCall: (toolName, toolArgs) => {
+            stopSpinnerAndBegin();
+            const argsStr = JSON.stringify(toolArgs, null, 2)
+                .split('\n')
+                .map((l, i) => (i === 0 ? l : '    ' + l))
+                .join('\n');
+            process.stdout.write(`\n\n  ${chalk_1.default.dim('⚙')} ${chalk_1.default.cyan(toolName)} ${chalk_1.default.dim(argsStr)}\n  `);
+        },
+        onToolResult: (_toolName, result) => {
+            const preview = typeof result === 'string'
+                ? result.slice(0, 120)
+                : JSON.stringify(result ?? '').slice(0, 120);
+            process.stdout.write(`\n  ${chalk_1.default.dim('→')} ${chalk_1.default.dim(preview)}${(preview.length >= 120 ? chalk_1.default.dim('…') : '')}\n  `);
+        },
+        onToolInterrupt: (toolName, toolArgs) => {
+            stopSpinnerAndBegin();
+            const argsStr = JSON.stringify(toolArgs);
+            process.stdout.write(`\n\n  ${chalk_1.default.yellow('⏸')} ${chalk_1.default.yellow(`Tool call requires approval: ${toolName}`)} ${chalk_1.default.dim(argsStr)}\n  `);
+        },
+        onError: (msg) => {
+            stopSpinnerAndBegin();
+            streamErrored = true;
+            process.stdout.write(`\n\n  ${chalk_1.default.red('✗')} ${chalk_1.default.red(msg)}\n`);
+        },
+    };
     try {
-        await streamResponse(cfg, currentThreadId, runId);
+        await (0, chat_1.streamResponse)(cfg, currentThreadId, runId, streamCbs);
     }
     catch (err) {
-        console.log(chalk_1.default.red(`\n  ✗ Stream error: ${err instanceof Error ? err.message : String(err)}`));
+        stopSpinnerAndBegin();
+        if (!streamErrored) {
+            console.log(chalk_1.default.red(`\n  ✗ Stream error: ${err instanceof Error ? err.message : String(err)}`));
+        }
+    }
+    finally {
+        // Ensure spinner cleared even if stream ended without any events
+        stopSpinner();
     }
     console.log('\n');
 }
-async function streamResponse(cfg, threadId, runId) {
-    const url = `${cfg.apiBaseUrl}/api/v1/user/chat/threads/${threadId}/stream/${runId}`;
-    // Use undici for proper SSE streaming
-    const { fetch: undiciFetch } = await Promise.resolve().then(() => __importStar(require('undici')));
-    const res = await undiciFetch(url, {
-        headers: { ...buildHeaders(cfg), Accept: 'text/event-stream' },
-    });
-    if (!res.body)
+const sugg = {
+    matched: [],
+    selectedIdx: 0,
+    renderedLines: 0,
+    buffer: '',
+};
+const COL_CMD = 18;
+// Strip ANSI codes to get visual width
+function visibleLen(s) {
+    return s.replace(/\x1B\[[0-9;]*m/g, '').length;
+}
+// Build a single suggestion row string
+function buildRow(c, selected) {
+    const cmdPadded = c.cmd.padEnd(COL_CMD);
+    if (selected) {
+        return '  ' + HIGHLIGHT.bold(cmdPadded) + '  ' + HIGHLIGHT(c.desc);
+    }
+    return '  ' + chalk_1.default.white(cmdPadded) + '  ' + chalk_1.default.dim(c.desc);
+}
+// Write all ANSI output in a single syscall to prevent mid-frame flicker
+function flush(s) {
+    process.stdout.write(s);
+}
+function buildEraseBlock() {
+    if (sugg.renderedLines === 0)
+        return '';
+    let s = '';
+    for (let i = 0; i < sugg.renderedLines; i++)
+        s += '\x1B[1B\x1B[2K';
+    s += `\x1B[${sugg.renderedLines}A`;
+    return s;
+}
+function eraseSuggestions() {
+    if (sugg.renderedLines === 0)
         return;
-    const reader = res.body.getReader();
-    const decoder = new TextDecoder();
-    let buf = '';
-    let lastType = '';
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buf += decoder.decode(value, { stream: true });
-        const lines = buf.split('\n');
-        buf = lines.pop() ?? '';
-        for (const line of lines) {
-            if (!line.startsWith('data: '))
-                continue;
-            const raw = line.slice(6).trim();
-            if (!raw || raw === '[DONE]')
-                continue;
-            try {
-                const evt = JSON.parse(raw);
-                // Text delta → print inline
-                const delta = evt.delta ?? evt.text ?? evt.content ?? '';
-                if (delta) {
-                    // First chunk after non-text event → newline indent
-                    if (lastType !== 'text')
-                        process.stdout.write('\n  ');
-                    process.stdout.write(delta);
-                    lastType = 'text';
-                }
-                else if (evt.type === 'done' || evt.status === 'completed') {
-                    break;
-                }
-                else if (evt.error) {
-                    console.log(chalk_1.default.red(`\n  ✗ ${evt.error}`));
-                    break;
-                }
-            }
-            catch {
-                // Non-JSON SSE line — ignore
-            }
-        }
+    flush(buildEraseBlock());
+    sugg.renderedLines = 0;
+}
+// Partial update — only rewrite the 2 rows that changed (prev + next selected).
+// Batched into ONE flush call to eliminate flicker.
+function patchSelection(prevIdx, nextIdx) {
+    if (sugg.matched.length === 0)
+        return;
+    const buf = sugg.buffer;
+    const promptCursorCol = visibleLen('redai › ' + buf);
+    // From prompt line, go to prevIdx row, rewrite it
+    const toPrev = prevIdx + 1;
+    const toNext = nextIdx - prevIdx; // relative move after rewriting prev
+    const backUp = nextIdx + 1; // lines to go back up to prompt
+    let out = `\x1B[${toPrev}B\r\x1B[2K` + buildRow(sugg.matched[prevIdx], false);
+    if (toNext !== 0) {
+        out += `\x1B[${Math.abs(toNext)}${toNext > 0 ? 'B' : 'A'}`;
     }
-    reader.releaseLock();
+    out += `\r\x1B[2K` + buildRow(sugg.matched[nextIdx], true);
+    out += `\x1B[${backUp}A\r\x1B[${promptCursorCol}C`;
+    flush(out);
 }
-// ─── Auth headers ─────────────────────────────────────────────────────────────
-function buildHeaders(cfg) {
-    return {
-        Authorization: `Bearer ${cfg.cliToken}`,
-        'Content-Type': 'application/json',
-        // workspace scope — required by guards
-        ...(cfg.workspaceId ? { 'x-workspace-id': cfg.workspaceId } : {}),
-    };
+function moveSuggestion(dir) {
+    if (sugg.matched.length === 0)
+        return;
+    const prev = sugg.selectedIdx;
+    const next = (prev + dir + sugg.matched.length) % sugg.matched.length;
+    sugg.selectedIdx = next;
+    // Only patch the 2 changed rows — no full redraw, no flicker
+    patchSelection(prev, next);
 }
 // ─── Main REPL ────────────────────────────────────────────────────────────────
 async function askCommand() {
@@ -370,81 +1007,267 @@ async function askCommand() {
         console.error(chalk_1.default.red('Session expired. Run `redai login` again.'));
         process.exit(1);
     }
-    process.stdout.write('\x1Bc'); // clear screen
+    // Restore last thread for this server from session cache
+    const session = (0, store_1.loadSession)();
+    if (session.threads[cfg.apiBaseUrl]) {
+        currentThreadId = session.threads[cfg.apiBaseUrl];
+    }
+    process.stdout.write('\x1Bc');
     printBanner(cfg);
-    const rl = readline_1.default.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        terminal: true,
-        prompt: '\n' + chalk_1.default.cyan('redai') + chalk_1.default.dim(' › '),
-    });
-    rl.prompt();
-    rl.on('line', async (raw) => {
-        const input = raw.trim();
-        if (!input) {
-            rl.prompt();
+    if (currentThreadId) {
+        console.log(`  ${chalk_1.default.dim('Thread  ')}  ${chalk_1.default.dim(currentThreadId)}`);
+        console.log();
+    }
+    readline_1.default.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY)
+        process.stdin.setRawMode(true);
+    let buffer = '';
+    let slashMode = false;
+    let busy = false;
+    let inputLines = 1; // terminal rows the current input block occupies
+    const PROMPT_PREFIX = chalk_1.default.cyan('redai') + chalk_1.default.dim(' › ');
+    const CONT_PREFIX = chalk_1.default.dim('  ... '); // continuation prefix for Shift+Enter lines
+    const PROMPT_VIS = 'redai › ';
+    const CONT_VIS = '  ... ';
+    // Build one display string per logical line in buffer
+    const buildInputLines = () => buffer.split('\n').map((part, i) => i === 0 ? PROMPT_PREFIX + part : CONT_PREFIX + part);
+    // Erase the current input block + any suggestion rows, then reprint everything
+    // in a single flush() call to avoid flicker.
+    // After the call, cursor sits at end of the last input line.
+    const reprintInputBlock = (withSuggestions = false) => {
+        const lines = buildInputLines();
+        const newCount = lines.length;
+        const lastLine = lines[newCount - 1];
+        const lastVis = newCount === 1
+            ? visibleLen(PROMPT_VIS + buffer.split('\n')[0])
+            : visibleLen(CONT_VIS + buffer.split('\n')[newCount - 1]);
+        let out = '';
+        // Move up to top of old input block (cursor is on last input line)
+        if (inputLines > 1)
+            out += `\x1B[${inputLines - 1}A`;
+        // Erase from here to bottom of screen (wipes input + old suggestions)
+        out += '\r\x1B[J';
+        // Write all input lines
+        out += lines.join('\n');
+        inputLines = newCount;
+        if (withSuggestions && sugg.matched.length > 0) {
+            const rows = sugg.matched.map((c, i) => buildRow(c, i === sugg.selectedIdx));
+            out += '\n' + rows.join('\n');
+            // Jump back up past suggestion rows to last input line
+            out += `\x1B[${rows.length}A`;
+            sugg.renderedLines = rows.length;
+        }
+        else {
+            sugg.renderedLines = 0;
+        }
+        // Position cursor at end of last input line
+        out += `\r\x1B[${lastVis}C`;
+        // lastLine is used only for its length — already captured above
+        void lastLine;
+        flush(out);
+    };
+    const printPrompt = () => {
+        buffer = '';
+        inputLines = 1;
+        process.stdout.write('\n' + PROMPT_PREFIX);
+    };
+    printPrompt();
+    // Execute whatever command is currently in buffer (or selected suggestion)
+    const executeInput = async (input) => {
+        if (!input.startsWith('/')) {
+            busy = true;
+            await chat(cfg, input);
+            busy = false;
+            printPrompt();
+            return;
+        }
+        const cmd = input.split(/\s+/)[0].toLowerCase();
+        busy = true;
+        switch (cmd) {
+            case '/':
+            case '/help':
+                printHelp();
+                break;
+            case '/account':
+                printAccount(cfg);
+                break;
+            case '/agents':
+                await interactiveAgents(cfg);
+                break;
+            case '/permissions':
+                await interactivePermissions();
+                break;
+            case '/mcps':
+                await interactiveMcps();
+                break;
+            case '/threads':
+                await interactiveThreads(cfg);
+                break;
+            case '/thread':
+                printThread();
+                break;
+            case '/new': {
+                process.stdout.write(chalk_1.default.dim('\n  Creating thread...'));
+                try {
+                    currentThreadId = await (0, chat_1.createThread)(cfg, 'New conversation');
+                    const s = (0, store_1.loadSession)();
+                    s.threads[cfg.apiBaseUrl] = currentThreadId;
+                    (0, store_1.saveSession)(s);
+                    process.stdout.write('\r' + ' '.repeat(30) + '\r');
+                    console.log(chalk_1.default.green('  ✓ New thread created'));
+                    console.log(`  ${chalk_1.default.dim('Thread  ')}  ${currentThreadId}`);
+                    console.log();
+                }
+                catch (err) {
+                    process.stdout.write('\r' + ' '.repeat(30) + '\r');
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.log(chalk_1.default.red('  ✗ Could not create thread:'), chalk_1.default.dim(msg));
+                    console.log();
+                }
+                break;
+            }
+            case '/clear':
+                process.stdout.write('\x1Bc');
+                printBanner(cfg);
+                break;
+            case '/exit':
+            case '/quit':
+                console.log(chalk_1.default.dim('\n  Bye!\n'));
+                process.exit(0);
+            default:
+                console.log(chalk_1.default.yellow(`\n  Unknown command: ${cmd}`));
+                console.log(chalk_1.default.dim('  Type /help to see available commands.\n'));
+        }
+        busy = false;
+        printPrompt();
+    };
+    process.stdin.on('keypress', async (char, key) => {
+        if (busy)
             return;
+        // ── Ctrl-C / Ctrl-D ───────────────────────────────────────────────────────
+        if (key?.ctrl && (key.name === 'c' || key.name === 'd')) {
+            if (sugg.renderedLines > 0)
+                eraseSuggestions();
+            console.log(chalk_1.default.dim('\n\n  Bye!\n'));
+            process.exit(0);
         }
-        // ── / → show command list ────────────────────────────────────────────────
-        if (input === '/') {
-            printHelp();
-            rl.prompt();
+        // ── Arrow Up ──────────────────────────────────────────────────────────────
+        if (key?.name === 'up') {
+            if (slashMode && sugg.matched.length > 0)
+                moveSuggestion(-1);
             return;
         }
-        // ── Slash commands ────────────────────────────────────────────────────────
-        if (input.startsWith('/')) {
-            const cmd = input.split(' ')[0].toLowerCase();
-            rl.pause();
-            switch (cmd) {
-                case '/help':
-                    printHelp();
-                    break;
-                case '/account':
-                    printAccount(cfg);
-                    break;
-                case '/agents':
-                    await printAgents(cfg, rl);
-                    break;
-                case '/permissions':
-                    printPermissions();
-                    break;
-                case '/mcps':
-                    printMcps();
-                    break;
-                case '/thread':
-                    printThread();
-                    break;
-                case '/new':
-                    currentThreadId = null;
-                    console.log(chalk_1.default.dim('\n  Thread reset — next message starts a new conversation.\n'));
-                    break;
-                case '/clear':
-                    process.stdout.write('\x1Bc');
-                    printBanner(cfg);
-                    break;
-                case '/exit':
-                case '/quit':
-                    console.log(chalk_1.default.dim('\n  Bye!\n'));
-                    rl.close();
-                    process.exit(0);
-                    break;
-                default:
-                    console.log(chalk_1.default.yellow(`\n  Unknown command: ${cmd}`));
-                    console.log(chalk_1.default.dim('  Type / to see available commands.\n'));
-            }
-            rl.resume();
-            rl.prompt();
+        // ── Arrow Down ────────────────────────────────────────────────────────────
+        if (key?.name === 'down') {
+            if (slashMode && sugg.matched.length > 0)
+                moveSuggestion(1);
             return;
         }
-        // ── Regular prompt → send to RedAI backend ────────────────────────────────
-        rl.pause();
-        await sendMessage(cfg, input);
-        rl.resume();
-        rl.prompt();
-    });
-    rl.on('close', () => {
-        console.log(chalk_1.default.dim('\n  Bye!\n'));
-        process.exit(0);
+        // ── Escape — close suggestions, keep buffer ───────────────────────────────
+        if (key?.name === 'escape') {
+            if (slashMode) {
+                slashMode = false;
+                sugg.matched = [];
+                sugg.selectedIdx = 0;
+                sugg.buffer = '';
+                reprintInputBlock();
+            }
+            return;
+        }
+        // ── Ctrl+Enter (0x0A, name='enter') — insert newline ─────────────────────
+        // Windows Terminal sends 0x0A for Ctrl+Enter, distinct from Enter (0x0D)
+        if (key?.name === 'enter') {
+            if (slashMode)
+                return;
+            buffer += '\n';
+            reprintInputBlock();
+            return;
+        }
+        // ── Backspace ────────────────────────────────────────────────────────────
+        if (key?.name === 'backspace') {
+            if (buffer.length === 0)
+                return;
+            buffer = buffer.slice(0, -1);
+            if (slashMode) {
+                if (buffer === '') {
+                    slashMode = false;
+                }
+                // reprint input + updated suggestions in one shot
+                sugg.matched = buffer === ''
+                    ? []
+                    : COMMANDS.filter(c => c.cmd.startsWith(buffer.toLowerCase()));
+                sugg.selectedIdx = 0;
+                sugg.buffer = buffer;
+                reprintInputBlock(buffer.length > 0);
+            }
+            else {
+                reprintInputBlock();
+            }
+            return;
+        }
+        // ── Tab — fill selected suggestion ───────────────────────────────────────
+        if (key?.name === 'tab' && slashMode && sugg.matched.length > 0) {
+            buffer = sugg.matched[sugg.selectedIdx].cmd;
+            slashMode = false;
+            sugg.matched = [];
+            sugg.selectedIdx = 0;
+            sugg.buffer = '';
+            sugg.renderedLines = 0;
+            reprintInputBlock();
+            return;
+        }
+        // ── Enter — submit ────────────────────────────────────────────────────────
+        if (key?.name === 'return') {
+            // Pick selected suggestion if list is open
+            if (slashMode && sugg.matched.length > 0) {
+                buffer = sugg.matched[sugg.selectedIdx].cmd;
+            }
+            const input = buffer.trim();
+            // Erase input block + suggestions
+            let out = '';
+            if (inputLines > 1)
+                out += `\x1B[${inputLines - 1}A`;
+            out += '\r\x1B[J';
+            buffer = '';
+            slashMode = false;
+            inputLines = 1;
+            sugg.matched = [];
+            sugg.selectedIdx = 0;
+            sugg.renderedLines = 0;
+            if (!input) {
+                // Empty submit — just reprint prompt in-place, no blank line
+                flush(out + PROMPT_PREFIX);
+                return;
+            }
+            // Echo submitted text collapsed to single line, then newline
+            const displayText = input.replace(/\n/g, ' ↵ ');
+            out += PROMPT_PREFIX + displayText + '\n';
+            flush(out);
+            await executeInput(input);
+            return;
+        }
+        // ── Regular character ─────────────────────────────────────────────────────
+        if (!char || char.length !== 1)
+            return;
+        buffer += char;
+        if (slashMode) {
+            // update matched list then reprint input + suggestions together
+            sugg.matched = COMMANDS.filter(c => c.cmd.startsWith(buffer.toLowerCase()));
+            sugg.selectedIdx = 0;
+            sugg.buffer = buffer;
+            reprintInputBlock(true);
+            return;
+        }
+        if (buffer === '/') {
+            slashMode = true;
+            sugg.matched = [...COMMANDS];
+            sugg.selectedIdx = 0;
+            sugg.buffer = buffer;
+            reprintInputBlock(true);
+            return;
+        }
+        // Plain text — just append char without full reprint (no flicker)
+        process.stdout.write(char);
     });
     await new Promise(() => undefined);
 }