ikie-cli 0.1.33 → 0.1.35

package/dist/config.d.ts

@@ -18,6 +18,14 @@ export declare const IKIE_API_BASE: string;
 export declare const IKIE_PORT: number;
 export interface IkieConfig {
     model: string;
+    /**
+     * True once the user has explicitly chosen a model (via /model, /settings
+     * model, or the picker). When false/unset, startup follows the server's
+     * default model. Tracked explicitly because the chosen model may legitimately
+     * equal DEFAULT_MODEL — value comparison alone can't tell "picked" from "never
+     * picked".
+     */
+    modelPinned?: boolean;
     maxTokens: number;
     autoApprove: boolean;
     apiKey?: string;

package/dist/config.js

@@ -74,6 +74,10 @@ export function hasExplicitModel() {
     try {
         if (existsSync(CONFIG_FILE)) {
             const raw = JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+            // Preferred: the explicit pin flag, written whenever the user picks a model.
+            if (typeof raw.modelPinned === 'boolean')
+                return raw.modelPinned;
+            // Legacy configs (pre-flag): infer a choice from a non-default saved model.
             return typeof raw.model === 'string' && raw.model !== DEFAULT_MODEL;
         }
     }

package/dist/index.js

@@ -8,6 +8,7 @@ import { loadAllMemory, formatMemoryForPrompt } from './memory.js';
 import { discoverSkills, formatSkillsForPrompt } from './skills.js';
 import { buildSystemPrompt, Agent } from './agent.js';
 import { startREPL } from './repl.js';
+import { getMcpManager } from './mcp-manager.js';
 import { login, logout } from './auth.js';
 import { c, errorLine } from './theme.js';
 import { runOnboarding, shouldRunOnboarding } from './onboarding.js';
@@ -135,6 +136,22 @@ async function main() {
         await runSkillsCli(argv._.slice(1).map(String), Boolean(argv.force));
         process.exit(0);
     }
+    // ── show-output: print a previously truncated tool output ─────
+    if (cmd === 'show-output') {
+        const id = argv._[1];
+        if (!id) {
+            console.error(errorLine('Usage: ikie show-output <id>'));
+            process.exit(1);
+        }
+        const savedOutputs = globalThis._ikieOutputs;
+        const output = savedOutputs?.get(id);
+        if (!output) {
+            console.error(errorLine(`No saved output with id "${id}". Outputs are only kept for the current session.`));
+            process.exit(1);
+        }
+        console.log(output);
+        process.exit(0);
+    }
     let config = loadConfig();
     if (argv.model)
         config.model = argv.model;
@@ -169,6 +186,7 @@ async function main() {
     if (argv.onboarding || (!oneShot && shouldRunOnboarding(config))) {
         config = loadConfig(); // reload — onboarding may have saved login
         await runOnboarding(config);
+        config = loadConfig(); // reload again — onboarding saved account + completion flag
     }
     const apiKey = getApiKey(config);
     if (!apiKey) {
@@ -199,7 +217,25 @@ ${errorLine('Not signed in.')}
         console.log();
     }
     const agent = new Agent(client, config, systemPrompt);
-    await startREPL(agent, config, projectContextStr, oneShot);
+    // Connect configured MCP servers before the first turn.
+    const cwd = process.cwd();
+    try {
+        await getMcpManager().connectAll(cwd);
+    }
+    catch {
+        // Failures are recorded per-server; don't crash the REPL.
+    }
+    try {
+        await startREPL(agent, config, projectContextStr, oneShot);
+    }
+    finally {
+        try {
+            getMcpManager().disconnectAll();
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
 }
 main().catch((err) => {
     console.error(errorLine(`Fatal: ${err instanceof Error ? err.message : String(err)}`));

package/dist/mcp-manager.d.ts

@@ -1,96 +1,82 @@
-export interface MCPTool {
+import type OpenAI from 'openai';
+export type McpTransportType = 'stdio' | 'http' | 'streamable-http' | 'sse';
+export interface McpServerEntry {
+    type?: McpTransportType;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    enabled?: boolean;
+    autoStart?: boolean;
+    description?: string;
+}
+export interface McpScopeConfig {
+    mcpServers?: Record<string, McpServerEntry>;
+}
+export interface McpTool {
     name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: Record<string, any>;
-        required?: string[];
-    };
+    description?: string;
+    inputSchema?: Record<string, unknown>;
 }
-export interface MCPServer {
+export interface McpServerStatus {
     name: string;
-    command: string;
-    args: string[];
-    env?: Record<string, string>;
-    description: string;
     enabled: boolean;
-    autoStart: boolean;
-    tools?: MCPTool[];
+    connected: boolean;
+    tools: McpTool[];
+    error?: string;
 }
-export interface MCPRegistry {
-    servers: Record<string, MCPServer>;
-    builtIn: string[];
+export interface McpClient {
+    connect(): Promise<McpTool[]>;
+    callTool(name: string, args: Record<string, unknown>, timeout?: number): Promise<string>;
+    close(): void;
+}
+export declare function expandEnvVars(value: string, env: Record<string, string | undefined>): string;
+export declare function expandEnvVarsInEntry(entry: McpServerEntry, env: Record<string, string | undefined>): McpServerEntry;
+export declare function inferTransport(entry: McpServerEntry): McpTransportType;
+export declare function mergeScopes(local: McpScopeConfig, project: McpScopeConfig, user: McpScopeConfig): Record<string, McpServerEntry>;
+export declare function sanitizeMcpName(s: string): string;
+export declare function mcpToolName(server: string, tool: string): string;
+export interface QualifiedTool {
+    server: string;
+    tool: string;
+}
+export declare function buildReverseToolMap(tools: Map<string, McpTool[]>): Map<string, QualifiedTool>;
+export declare function parseClaudeMcpAddCommand(str: string, defaultScope?: 'user' | 'project' | 'local'): {
+    name: string;
+    entry: McpServerEntry;
+    scope: 'user' | 'project' | 'local';
+    scopeExplicit: boolean;
+} | {
+    error: string;
+};
+export declare class LineBuffer {
+    private tail;
+    private lines;
+    push(chunk: string): string[];
+    flush(): string[];
 }
-export declare class MCPManager {
-    private registry;
-    private processes;
-    private messageHandlers;
-    constructor();
-    private ensureMCPDir;
-    private loadRegistry;
-    private saveRegistry;
-    private initializeBuiltInServers;
-    installMCP(config: {
-        name: string;
-        source: string;
-        description?: string;
-        env?: Record<string, string>;
-        autoStart?: boolean;
-    }): Promise<{
-        success: boolean;
-        error?: string;
-        server?: MCPServer;
-    }>;
-    addMCP(config: {
-        name: string;
-        command: string;
-        args: string[];
-        env?: Record<string, string>;
-        description?: string;
-    }): {
-        success: boolean;
-        error?: string;
-        server?: MCPServer;
-    };
-    uninstallMCP(name: string): {
-        success: boolean;
-        error?: string;
-    };
-    startMCP(name: string): Promise<{
-        success: boolean;
-        error?: string;
-        tools?: MCPTool[];
-    }>;
-    stopMCP(name: string): {
-        success: boolean;
-        error?: string;
-    };
-    private initializeMCP;
-    private requestMCPTools;
-    private sendMCPMessage;
-    private handleMCPMessage;
-    callMCPTool(serverName: string, toolName: string, args: Record<string, any>): Promise<{
-        success: boolean;
-        result?: any;
-        error?: string;
-    }>;
-    getAllTools(): Array<{
-        server: string;
-        tool: MCPTool;
-    }>;
-    listMCPs(): Array<{
-        name: string;
-        description: string;
-        enabled: boolean;
-        running: boolean;
-        builtIn: boolean;
-        tools?: MCPTool[];
-    }>;
-    setMCPEnabled(name: string, enabled: boolean): {
-        success: boolean;
-        error?: string;
-    };
-    startAutoStartMCPs(): Promise<void>;
-    stopAllMCPs(): void;
+export declare class McpManager {
+    private clients;
+    private tools;
+    private statuses;
+    private cwd?;
+    private loadScope;
+    private loadUserConfig;
+    private migrateOldRegistry;
+    private resolveEnv;
+    private createClient;
+    connectAll(cwd: string): Promise<void>;
+    private connectServer;
+    private withTimeout;
+    getToolDefsSync(): OpenAI.Chat.ChatCompletionTool[];
+    callTool(qualified: string, args: Record<string, unknown>): Promise<string>;
+    private findServerEntry;
+    listServers(): McpServerStatus[];
+    addServer(name: string, entry: McpServerEntry, scope: 'user' | 'project' | 'local'): Promise<void>;
+    removeServer(name: string, scope: 'user' | 'project' | 'local'): boolean;
+    reconnectServer(name: string): Promise<void>;
+    disconnectAll(): void;
 }
-export declare function getMCPManager(): MCPManager;
+export declare function getMcpManager(): McpManager;