ikie-cli 0.1.39 → 0.1.40

package/dist/index.js

@@ -168,7 +168,7 @@ async function main() {
             const modelsUrl = (config.baseURL ?? IKIE_API_BASE).includes('/api/v1')
                 ? (config.baseURL ?? IKIE_API_BASE).replace('/api/v1', '/api/models')
                 : `${IKIE_HOST}/api/models`;
-            const res = await fetch(modelsUrl);
+            const res = await fetch(modelsUrl, { signal: AbortSignal.timeout(4000) });
             if (res.ok) {
                 const data = await res.json();
                 const serverDefault = data.models?.find(m => m.is_default);
@@ -201,6 +201,7 @@ ${errorLine('Not signed in.')}
     const client = new OpenAI({
         apiKey,
         baseURL: config.baseURL ?? IKIE_API_BASE,
+        timeout: 60000, // 60 seconds timeout to prevent indefinite hangs
     });
     const projectCtx = detectProjectContext();
     const projectContextStr = formatContextForPrompt(projectCtx);

package/dist/repl.js

@@ -4,7 +4,7 @@ import { restoreStdinListeners, extractUpstreamError } from './agent.js';
 import { c, PROMPT, CONTINUE_PROMPT, PROMPT_ARROW, printPromptHeader, promptHeaderText, modeTag, drawBanner, infoLine, successLine, errorLine, THEMES, setTheme, stripAnsi, contextRing, renderSlashMenu, supportsVT, CH, } from './theme.js';
 import { renderMarkdown } from './renderer.js';
 import { loadAllMemory } from './memory.js';
-import { HOME_DIR, saveConfig, DEFAULT_MODEL, IKIE_HOST, IKIE_API_BASE, isLoggedIn, getApiKey } from './config.js';
+import { HOME_DIR, saveConfig, DEFAULT_MODEL, IKIE_HOST, IKIE_API_BASE, isLoggedIn, getApiKey, loadConfig } from './config.js';
 import { login, logout } from './auth.js';
 import { join as pathJoin } from 'path';
 import { deleteSession, listSessions, loadSession, normalizeSessionName, saveSession } from './session.js';
@@ -459,6 +459,12 @@ async function handleSlashCommand(input, agent, config, projectContext, rl, sess
         }
         case 'login': {
             await login();
+            const reloaded = loadConfig();
+            Object.assign(config, reloaded);
+            const freshApiKey = getApiKey(config);
+            if (freshApiKey) {
+                agent.updateApiKey(freshApiKey);
+            }
             return true;
         }
         case 'skills': {
@@ -545,6 +551,12 @@ async function handleSlashCommand(input, agent, config, projectContext, rl, sess
         case 'onboarding': {
             console.log();
             await runOnboarding(config);
+            const reloaded = loadConfig();
+            Object.assign(config, reloaded);
+            const freshApiKey = getApiKey(config);
+            if (freshApiKey) {
+                agent.updateApiKey(freshApiKey);
+            }
             return true;
         }
         case 'mcp': {
@@ -618,6 +630,8 @@ async function handleSlashCommand(input, agent, config, projectContext, rl, sess
             }
             else {
                 logout();
+                delete config.account;
+                agent.updateApiKey('');
             }
             return true;
         }
@@ -1084,6 +1098,36 @@ function notify(message) {
         exec(`powershell -NoProfile -NonInteractive -Command "& {${ps}}"`, () => { });
     }
 }
+/**
+ * Parse numbered plan steps from an agent's plan-mode response.
+ * Looks for lines like `1. Do something` under a `## Plan` heading.
+ */
+function parsePlanSteps(conversation) {
+    const lastAssistant = [...conversation].reverse().find(m => m.role === 'assistant');
+    if (!lastAssistant || typeof lastAssistant.content !== 'string')
+        return [];
+    const text = lastAssistant.content;
+    const lines = text.split('\n');
+    const steps = [];
+    let inPlan = false;
+    for (const line of lines) {
+        const t = line.trim();
+        if (/^#{1,3}\s*plan/i.test(t)) {
+            inPlan = true;
+            continue;
+        }
+        if (inPlan) {
+            const m = t.match(/^\d+[.)]\s+(.+)/);
+            if (m) {
+                steps.push(m[1].trim());
+                continue;
+            }
+            if (/^#{1,3}\s/.test(t) || (t === '' && steps.length > 0))
+                break;
+        }
+    }
+    return steps;
+}
 export async function startREPL(agent, config, projectContext, oneShot) {
     void HISTORY_FILE;
     // Context window size — default 131072 (128k), updated silently from model info.
@@ -1378,8 +1422,11 @@ export async function startREPL(agent, config, projectContext, oneShot) {
             closeMenu();
             const next = agent.getMode() === 'agent' ? 'plan' : 'agent';
             agent.setMode(next);
+            // When supportsVT is true showPrompt prints a tip line between the
+            // header and the prompt, so we need to skip 2 lines to reach the header.
+            const linesUp = supportsVT ? 2 : 1;
             process.stdout.write('\x1b7' + // save cursor (on the input line)
-                '\x1b[1A\r\x1b[2K' + // up to the header line, col 0, clear it
+                `\x1b[${linesUp}A\r\x1b[2K` + // up past tip to header, clear it
                 promptHeaderText(next) +
                 '\x1b8');
             return;
@@ -1474,6 +1521,10 @@ export async function startREPL(agent, config, projectContext, oneShot) {
         }
         else {
             printPromptHeader(agent.getMode());
+            if (supportsVT) {
+                const tip = TIPS[tipIndex++ % TIPS.length];
+                process.stdout.write(`  ${c.secondary('Tip:')} ${c.dim(tip)}\n`);
+            }
             const tokens = agent.estimateConversationTokens();
             const pct = tokens / contextWindow;
             const ring = tokens > 0 ? contextRing(Math.min(pct, 1)) : '';
@@ -1487,11 +1538,6 @@ export async function startREPL(agent, config, projectContext, oneShot) {
             currentPrompt = prompt;
             rl.setPrompt(prompt);
             rl.prompt();
-            // Rotating tip below the prompt (only on VT-capable terminals)
-            if (supportsVT) {
-                const tip = TIPS[tipIndex++ % TIPS.length];
-                process.stdout.write(`\x1b[s\n${c.dim('   ' + tip)}\x1b[u`);
-            }
         }
     };
     rl.on('close', () => {
@@ -1552,6 +1598,12 @@ export async function startREPL(agent, config, projectContext, oneShot) {
             showPrompt();
             return;
         }
+        if (!isLoggedIn(config)) {
+            console.log(errorLine('Not signed in. Run /login to sign in and continue.'));
+            process.stdout.write('\n');
+            showPrompt();
+            return;
+        }
         const agentInput = expandPastedBlocks(fullInput);
         const imagesForTurn = [...imageState.pending];
         const userContent = buildUserContent(agentInput, imagesForTurn);
@@ -1577,8 +1629,9 @@ export async function startREPL(agent, config, projectContext, oneShot) {
             const b = data[0];
             if (b === 0x1b && data.length === 1) {
                 if (!abortController.signal.aborted) {
+                    process.stdout.write('\r\x1b[2K');
                     abortController.abort();
-                    process.stdout.write(`\n${c.warning('  Cancelled')}\n`);
+                    process.stdout.write(`  ${c.warning('Cancelled')}\n`);
                 }
             }
             else if (b === 0x03) {
@@ -1586,8 +1639,9 @@ export async function startREPL(agent, config, projectContext, oneShot) {
                 if (ctrlCCount >= 2)
                     process.exit(0);
                 if (!abortController.signal.aborted) {
+                    process.stdout.write('\r\x1b[2K');
                     abortController.abort();
-                    process.stdout.write(`\n${c.warning('  Cancelled')}\n`);
+                    process.stdout.write(`  ${c.warning('Cancelled')}\n`);
                 }
                 setTimeout(() => { ctrlCCount = 0; }, 2000);
             }
@@ -1624,6 +1678,10 @@ export async function startREPL(agent, config, projectContext, oneShot) {
                 if (go && !abortController.signal.aborted) {
                     agent.setMode('agent');
                     process.stdout.write(`  ${c.muted('→ switching to')} ${modeTag('agent')} ${c.muted('mode, executing…')}\n`);
+                    const planSteps = parsePlanSteps(agent.getConversation());
+                    if (planSteps.length > 0) {
+                        agent.setPlanSteps(planSteps);
+                    }
                     await agent.send('Execute the plan you just proposed. Make the changes now.', {
                         autoApprove: config.autoApprove,
                         signal: abortController.signal,

package/dist/session-manager.d.ts

@@ -0,0 +1,29 @@
+type AgentSession = {
+    id: number;
+    name: string;
+    buffer: string[];
+};
+export declare class SessionManager {
+    static activeId: number;
+    static nextAgentId: number;
+    static sessions: Map<number, AgentSession>;
+    static onRedraw?: () => void;
+    static init(mainAgentName?: string, onRedrawCallback?: () => void): void;
+    static register(name: string): number;
+    static remove(id: number): void;
+    static getActiveId(): number;
+    static setActiveId(id: number, afterRedraw?: () => void): void;
+    static switchToNext(afterRedraw?: () => void): void;
+    static switchToPrev(afterRedraw?: () => void): void;
+    static isActive(agentId: number): boolean;
+    /**
+     * Append already-rendered lines to an agent's scrollback WITHOUT echoing to
+     * stdout. Used by the live task board, which paints its own animation frames
+     * directly and only needs the *settled* result recorded for history/redraw.
+     */
+    static recordHistory(agentId: number, text: string): void;
+    static write(agentId: number, text: string): void;
+    private static appendToBuffer;
+    static redraw(afterRedraw?: () => void): void;
+}
+export {};

package/dist/session-manager.js

@@ -0,0 +1,145 @@
+import chalk from 'chalk';
+export class SessionManager {
+    static activeId = 0;
+    static nextAgentId = 0;
+    static sessions = new Map();
+    static onRedraw;
+    static init(mainAgentName = 'Main', onRedrawCallback) {
+        const id = this.nextAgentId++;
+        this.sessions.set(id, { id, name: mainAgentName, buffer: [] });
+        this.activeId = id;
+        this.onRedraw = onRedrawCallback;
+    }
+    static register(name) {
+        const id = this.nextAgentId++;
+        this.sessions.set(id, { id, name, buffer: [] });
+        return id;
+    }
+    static remove(id) {
+        if (id !== 0) {
+            this.sessions.delete(id);
+            if (this.activeId === id) {
+                this.setActiveId(0);
+            }
+            else {
+                this.redraw();
+            }
+        }
+    }
+    static getActiveId() {
+        return this.activeId;
+    }
+    static setActiveId(id, afterRedraw) {
+        if (this.sessions.has(id)) {
+            this.activeId = id;
+            this.redraw(afterRedraw);
+        }
+    }
+    static switchToNext(afterRedraw) {
+        const ids = Array.from(this.sessions.keys());
+        const idx = ids.indexOf(this.activeId);
+        if (idx >= 0) {
+            this.setActiveId(ids[(idx + 1) % ids.length], afterRedraw);
+        }
+    }
+    static switchToPrev(afterRedraw) {
+        const ids = Array.from(this.sessions.keys());
+        const idx = ids.indexOf(this.activeId);
+        if (idx >= 0) {
+            this.setActiveId(ids[(idx - 1 + ids.length) % ids.length], afterRedraw);
+        }
+    }
+    static isActive(agentId) {
+        return this.activeId === agentId;
+    }
+    /**
+     * Append already-rendered lines to an agent's scrollback WITHOUT echoing to
+     * stdout. Used by the live task board, which paints its own animation frames
+     * directly and only needs the *settled* result recorded for history/redraw.
+     */
+    static recordHistory(agentId, text) {
+        let session = this.sessions.get(agentId);
+        if (!session) {
+            session = { id: agentId, name: `Agent ${agentId}`, buffer: [] };
+            this.sessions.set(agentId, session);
+        }
+        this.appendToBuffer(session, text);
+    }
+    static write(agentId, text) {
+        let session = this.sessions.get(agentId);
+        if (!session) {
+            session = { id: agentId, name: `Agent ${agentId}`, buffer: [] };
+            this.sessions.set(agentId, session);
+        }
+        this.appendToBuffer(session, text);
+        if (agentId === this.activeId) {
+            process.stdout.write(text);
+        }
+    }
+    static appendToBuffer(session, text) {
+        let currentLine = session.buffer.length > 0 ? session.buffer[session.buffer.length - 1] : '';
+        for (let i = 0; i < text.length; i++) {
+            const char = text[i];
+            if (char === '\n') {
+                session.buffer[session.buffer.length - 1] = currentLine;
+                session.buffer.push('');
+                currentLine = '';
+            }
+            else if (char === '\r') {
+                // simple CR behavior: overwrite current line
+                // Wait, typically \r\n are together. If we see \r and next is \n, we skip \r.
+                if (text[i + 1] === '\n') {
+                    // ignore \r before \n
+                }
+                else {
+                    currentLine = ''; // reset line
+                }
+            }
+            else {
+                currentLine += char;
+            }
+        }
+        // Clean up ANSI escape code for "clear line" at start of current line if any
+        currentLine = currentLine.replace(/^\x1b\[2K/, '');
+        if (session.buffer.length === 0) {
+            session.buffer.push(currentLine);
+        }
+        else {
+            session.buffer[session.buffer.length - 1] = currentLine;
+        }
+        if (session.buffer.length > 1000) {
+            session.buffer.splice(0, session.buffer.length - 1000);
+        }
+    }
+    static redraw(afterRedraw) {
+        const session = this.sessions.get(this.activeId);
+        if (!session)
+            return;
+        process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
+        let out = '';
+        out += chalk.bgGray.white('--- AGENTS ---') + '\n';
+        const ids = Array.from(this.sessions.keys());
+        for (const id of ids) {
+            const s = this.sessions.get(id);
+            if (id === this.activeId) {
+                out += chalk.bgGreen.black(` [${id}: ${s.name}] `) + ' ';
+            }
+            else {
+                out += chalk.bgBlack.gray(` [${id}: ${s.name}] `) + ' ';
+            }
+        }
+        out += '\n' + chalk.dim('(Alt+Right / Alt+Left to switch. Scroll up to read history)\n\n');
+        for (const line of session.buffer) {
+            out += line + '\n';
+        }
+        // Remove trailing newline so the cursor stays on the last line for spinners
+        if (out.endsWith('\n')) {
+            out = out.slice(0, -1);
+        }
+        process.stdout.write(out);
+        if (afterRedraw)
+            afterRedraw();
+        if (this.onRedraw)
+            this.onRedraw();
+    }
+}

package/dist/theme.d.ts

@@ -34,6 +34,7 @@ export declare const c: {
     readonly bold: import("chalk").ChalkInstance;
     readonly dim: import("chalk").ChalkInstance;
     readonly italic: import("chalk").ChalkInstance;
+    readonly strikethrough: import("chalk").ChalkInstance;
 };
 export declare function stripAnsi(str: string): string;
 export declare const BANNER_ROWS = 9;
@@ -70,7 +71,9 @@ export declare class InlineSpinner {
     private frameIdx;
     private frames;
     private visible;
-    constructor(label?: string, elapsedSince?: number);
+    private signal?;
+    private onAbort;
+    constructor(label?: string, elapsedSince?: number, signal?: AbortSignal);
     start(): void;
     private draw;
     stop(successMessage?: string): void;

package/dist/theme.js

@@ -186,6 +186,7 @@ export const c = {
     get bold() { return chalk.bold; },
     get dim() { return chalk.dim; },
     get italic() { return chalk.italic; },
+    get strikethrough() { return chalk.strikethrough; },
 };
 function truncate(str, max) {
     if (str.length <= max)
@@ -313,9 +314,22 @@ export class InlineSpinner {
     frameIdx = 0;
     frames = ['.', 'o', 'O', 'o'];
     visible = false;
-    constructor(label = 'Thinking', elapsedSince) {
+    signal;
+    onAbort = () => {
+        this.stop();
+    };
+    constructor(label = 'Thinking', elapsedSince, signal) {
         this.label = label;
         this.elapsedSince = elapsedSince;
+        if (signal) {
+            this.signal = signal;
+            if (signal.aborted) {
+                this.stop();
+            }
+            else {
+                signal.addEventListener('abort', this.onAbort);
+            }
+        }
     }
     start() {
         if (this.timer || this.delayTimer)
@@ -338,9 +352,14 @@ export class InlineSpinner {
         const elapsedFrom = this.elapsedSince ?? this.startTime;
         const elapsed = ((Date.now() - elapsedFrom) / 1000).toFixed(1);
         const frame = c.primary(this.frames[this.frameIdx]);
-        process.stdout.write(`\r\x1b[2K  ${frame} ${c.muted(this.label)} ${c.accent(`${elapsed}s`)} ${c.muted('· Esc to interrupt')}`);
+        const text = `\r\x1b[2K  ${frame} ${c.muted(this.label)} ${c.accent(`${elapsed}s`)} ${c.muted('· Esc to interrupt')}`;
+        process.stdout.write(text);
     }
     stop(successMessage) {
+        if (this.signal) {
+            this.signal.removeEventListener('abort', this.onAbort);
+            this.signal = undefined;
+        }
         if (this.delayTimer) {
             clearTimeout(this.delayTimer);
             this.delayTimer = null;
@@ -351,12 +370,26 @@ export class InlineSpinner {
         }
         const wasVisible = this.visible;
         this.visible = false;
+        let out = '';
         if (successMessage) {
-            process.stdout.write(`\r\x1b[2K  ${c.success('ok')} ${c.muted(successMessage)}\n`);
+            const elapsedFrom = this.elapsedSince ?? this.startTime;
+            const elapsed = ((Date.now() - elapsedFrom) / 1000).toFixed(1);
+            // If success message is just "ok" (default behavior) or something else
+            if (successMessage === 'ok') {
+                out = `\r\x1b[2K  ${c.success('✓')} ${c.muted(this.label)} ${c.accent(`${elapsed}s`)}\n`;
+            }
+            else if (successMessage === 'failed') {
+                out = `\r\x1b[2K  ${c.error('✗')} ${c.muted(this.label)} ${c.accent(`${elapsed}s`)}\n`;
+            }
+            else {
+                out = `\r\x1b[2K  ${c.success('✓')} ${c.muted(successMessage)} ${c.accent(`${elapsed}s`)}\n`;
+            }
         }
         else if (wasVisible) {
-            process.stdout.write('\r\x1b[2K');
+            out = '\r\x1b[2K';
         }
+        if (out)
+            process.stdout.write(out);
     }
     updateLabel(label) {
         this.label = label;
@@ -375,7 +408,6 @@ export function toolMeta(rawName) {
         case 'grep': return { verb: 'Grep', tint: c.info };
         case 'search_files': return { verb: 'Search', tint: c.info };
         case 'memory_write': return { verb: 'Remember', tint: c.secondary };
-        case 'spawn_agent': return { verb: 'Agent', tint: c.secondary };
         case 'switch_mode': return { verb: 'SwitchMode', tint: c.warning };
         case 'ask_user': return { verb: 'Ask', tint: c.info };
         case 'fetch_url': return { verb: 'Fetch', tint: c.info };

package/dist/tools.d.ts

@@ -5,4 +5,4 @@ export declare const SAFE_TOOLS: Set<string>;
 export declare const PLAN_TOOLS: Set<string>;
 export declare function isRestrictedPath(path: string): boolean;
 export declare function formatToolArgs(name: string, input: Record<string, unknown>): string;
-export declare function executeTool(name: string, input: Record<string, unknown>): Promise<string>;
+export declare function executeTool(name: string, input: Record<string, unknown>, signal?: AbortSignal): Promise<string>;