ikie-cli 0.1.27 → 0.1.28

package/dist/agent.js

@@ -1,8 +1,8 @@
 import chalk from 'chalk';
 import * as readline from 'node:readline';
-import { TOOL_DEFS, SAFE_TOOLS, PLAN_TOOLS, formatToolArgs, executeTool, isRestrictedPath } from './tools.js';
+import { TOOL_DEFS, SAFE_TOOLS, PLAN_TOOLS, formatToolArgs, executeTool, isRestrictedPath, validatePathSafety, validateBashCommand } from './tools.js';
 import { renderMarkdown, extractThinkTags } from './renderer.js';
-import { c, toolLine, permissionPrompt, toolSuccessLine, toolErrorLine, toolOutputBlock, toolDiffBlock, InlineSpinner } from './theme.js';
+import { c, toolLine, toolSuccessLine, toolErrorLine, toolOutputBlock, toolDiffBlock, InlineSpinner, CH, toolMeta } from './theme.js';
 export function estimateTokens(chars) {
     return Math.max(1, Math.round(chars / 4));
 }
@@ -569,6 +569,32 @@ export class Agent {
         if (name === 'ask_user') {
             return this.askUser(input);
         }
+        // Safety validation → ask permission on failure
+        if (!opts.autoApprove && !this.config.autoApprove) {
+            let safetyIssue;
+            if (name === 'bash') {
+                const cmd = String(input.command ?? '');
+                const v = validateBashCommand(cmd);
+                if (!v.safe)
+                    safetyIssue = v.error;
+            }
+            if (name === 'read_file' || name === 'write_file' || name === 'edit_file' || name === 'list_dir') {
+                const p = String(input.path ?? input.cwd ?? '.');
+                if (p) {
+                    const v = validatePathSafety(p);
+                    if (!v.safe)
+                        safetyIssue = v.error;
+                }
+            }
+            if (safetyIssue) {
+                if (this.sessionDenyList.has(name))
+                    return `Tool execution denied by user: ${name}`;
+                process.stdout.write(`${this.indent}${c.warning('⚠')} ${c.muted(safetyIssue)} ${c.muted('— asking for permission')}\n`);
+                const allowed = await this.checkPermission(name, input);
+                if (!allowed)
+                    return `Tool execution denied by user: ${name}`;
+            }
+        }
         if (name === 'read_file') {
             const path = String(input.path ?? '');
             if (isRestrictedPath(path) && !opts.autoApprove && !this.config.autoApprove && !this.sessionAllowList.has('read_file')) {
@@ -748,9 +774,28 @@ export class Agent {
             return false;
         if (this.sessionAllowList.has(toolName))
             return true;
-        process.stdout.write(permissionPrompt(toolName, formatToolArgs(toolName, input)));
+        const t0 = Date.now();
+        const preview = formatToolArgs(toolName, input);
+        const { verb, tint } = toolMeta(toolName);
+        const makePrompt = (elapsed) => `\n  ${tint('●')} ${c.white.bold('permission')} ${c.muted(`(${elapsed}s)`)} ${c.muted('·')} ${c.white(verb)} ${c.dim(preview)}\n` +
+            `  ${c.muted('⎿')} ` +
+            `${c.success.bold('y')} ${c.muted('allow')}   ` +
+            `${c.error.bold('n')} ${c.muted('deny')}   ` +
+            `${c.info.bold('a')} ${c.muted('always')}   ` +
+            `${c.muted.bold('!')} ${c.muted('never')}\n` +
+            `  ${c.muted(CH.arrow)} `;
+        process.stdout.write(makePrompt('0.0'));
+        const timerUpdate = () => {
+            const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
+            process.stdout.write(`\x1b[3A\x1b[0J${makePrompt(elapsed)}`);
+        };
+        const timerInterval = setInterval(timerUpdate, 100);
+        const cleanup = () => {
+            clearInterval(timerInterval);
+        };
         return new Promise((resolve) => {
             if (!process.stdin.isTTY) {
+                cleanup();
                 process.stdout.write(chalk.dim('(non-interactive, denying)\n'));
                 resolve(false);
                 return;
@@ -765,6 +810,7 @@ export class Agent {
                 process.stdin.resume();
             }
             const onData = (data) => {
+                cleanup();
                 process.stdin.removeListener('data', onData);
                 // Restore raw mode to what it was (keeps REPL's ESC handler working)
                 if (process.stdin.isTTY) {
@@ -900,6 +946,7 @@ changes they didn't ask for.
 - \`write_file\`: Create new files or full rewrites
 - \`edit_file\`: Replace exact strings (preferred for modifications)
 - \`bash\`: Run shell commands (build, test, git, etc.). Commands ending with & run detached in background.
+  **IMPORTANT:** The bash tool is non-interactive — it cannot handle prompts. For commands that ask questions (create-next-app, npm init, etc.), use \`--yes\`, \`-y\`, or pipe through \`yes\` to skip all prompts. For long-running downloads (npx installs), request \`timeout_ms\` up to 300000.
 - \`list_dir\`: Explore directory structure
 - \`search_files\`: Find files by glob pattern
 - \`grep\`: Search file contents by regex
@@ -957,6 +1004,9 @@ changes they didn't ask for.
 - \`mcp_stop\`: Stop a running MCP server.
 - \`mcp_call\`: Call a tool from a running MCP. Use \`mcp_list\` first to see available tools.
 - \`mcp_uninstall\`: Remove an installed MCP (built-in MCPs cannot be uninstalled).
+- \`mcp_add\`: Add an MCP by specifying the full command directly (Claude/Cline-style). Use when the MCP runs via npx, a script, or any custom command. Example: \`mcp_add(name="magic", commandArgs="npx -y @21st-dev/magic@latest", env={API_KEY: "..."})\`. After adding, you must run \`mcp_start\` to activate it.
+
+**Recognizing MCP config patterns:** When the user says things like "install this MCP", "claude mcp add", "add this MCP", or pastes a Claude-style MCP config, parse it and use \`mcp_add\`. The format is: \`<any-prefix> mcp add <name> [--scope user] [--env KEY=VALUE ...] -- <command> [args...]\`. Everything after \`--\` is the full command string. Translate this to \`mcp_add\` — do NOT try to run it as a bash command.
 
 **Built-in MCPs:**
 - **filesystem**: Enhanced file operations (read multiple files, directory trees)

package/dist/config.d.ts

@@ -28,6 +28,8 @@ export interface IkieConfig {
     frequencyPenalty: number;
     theme: string;
     requestsPerMinute: number;
+    /** Whether the first-time onboarding flow has been completed. */
+    hasCompletedOnboarding?: boolean;
 }
 export declare function ensureHome(): void;
 export declare function loadConfig(): IkieConfig;

package/dist/index.js

@@ -10,9 +10,10 @@ import { buildSystemPrompt, Agent } from './agent.js';
 import { startREPL } from './repl.js';
 import { login, logout } from './auth.js';
 import { c, errorLine } from './theme.js';
+import { runOnboarding, shouldRunOnboarding } from './onboarding.js';
 const argv = minimist(process.argv.slice(2), {
     string: ['model', 'rpm'],
-    boolean: ['help', 'version', 'yes', 'verbose'],
+    boolean: ['help', 'version', 'yes', 'verbose', 'onboarding'],
     alias: { h: 'help', v: 'version', y: 'yes', m: 'model' },
 });
 function printUsage() {
@@ -34,6 +35,7 @@ ${c.primary('Options:')}
   ${c.accent('-y, --yes')}              Auto-approve all tool executions
   ${c.accent('--rpm')} ${c.muted('<number>')}        Max model requests per minute (default: 10)
   ${c.accent('--verbose')}             Debug output
+  ${c.accent('--onboarding')}          Run first-time onboarding again
   ${c.accent('-h, --help')}            Show this help
   ${c.accent('-v, --version')}         Show version
 
@@ -133,7 +135,7 @@ async function main() {
         await runSkillsCli(argv._.slice(1).map(String), Boolean(argv.force));
         process.exit(0);
     }
-    const config = loadConfig();
+    let config = loadConfig();
     if (argv.model)
         config.model = argv.model;
     if (argv.yes)
@@ -162,6 +164,12 @@ async function main() {
             // Silently fall back to DEFAULT_MODEL
         }
     }
+    const oneShot = argv._.length > 0 ? argv._.join(' ') : undefined;
+    // Run onboarding on first launch or when --onboarding is passed
+    if (argv.onboarding || (!oneShot && shouldRunOnboarding(config))) {
+        config = loadConfig(); // reload — onboarding may have saved login
+        await runOnboarding(config);
+    }
     const apiKey = getApiKey(config);
     if (!apiKey) {
         console.error(`
@@ -191,7 +199,6 @@ ${errorLine('Not signed in.')}
         console.log();
     }
     const agent = new Agent(client, config, systemPrompt);
-    const oneShot = argv._.length > 0 ? argv._.join(' ') : undefined;
     await startREPL(agent, config, projectContextStr, oneShot);
 }
 main().catch((err) => {

package/dist/mcp-manager.d.ts

@@ -41,6 +41,17 @@ export declare class MCPManager {
         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;

package/dist/mcp-manager.js

@@ -125,6 +125,23 @@ export class MCPManager {
             };
         }
     }
+    addMCP(config) {
+        if (this.registry.servers[config.name]) {
+            return { success: false, error: `MCP '${config.name}' already exists` };
+        }
+        const server = {
+            name: config.name,
+            command: config.command,
+            args: config.args,
+            env: config.env,
+            description: config.description || 'Custom MCP server',
+            enabled: true,
+            autoStart: false,
+        };
+        this.registry.servers[config.name] = server;
+        this.saveRegistry();
+        return { success: true, server };
+    }
     uninstallMCP(name) {
         if (!this.registry.servers[name]) {
             return { success: false, error: `MCP '${name}' not found` };

package/dist/onboarding.d.ts

@@ -0,0 +1,3 @@
+import { type IkieConfig } from './config.js';
+export declare function runOnboarding(config: IkieConfig): Promise<void>;
+export declare function shouldRunOnboarding(config: IkieConfig): boolean;

package/dist/onboarding.js

@@ -0,0 +1,162 @@
+import { c, successLine, infoLine, errorLine } from './theme.js';
+import { login } from './auth.js';
+import { saveConfig, isLoggedIn } from './config.js';
+import { createInterface } from 'node:readline';
+function waitForEnter(message = 'Press Enter to continue...') {
+    return new Promise((resolve) => {
+        const iface = createInterface({ input: process.stdin, output: process.stdout });
+        iface.question(`\n  ${c.muted('▸')} ${c.dim(message)} `, () => { iface.close(); resolve(); });
+    });
+}
+function askYesNo(question, defaultYes = true) {
+    return new Promise((resolve) => {
+        const iface = createInterface({ input: process.stdin, output: process.stdout });
+        const hint = defaultYes ? `${c.success('Y')}/${c.dim('n')}` : `${c.dim('y')}/${c.error('N')}`;
+        iface.question(`\n  ${c.primary('?')} ${c.white(question)} ${hint} `, (answer) => {
+            iface.close();
+            const a = answer.trim().toLowerCase();
+            if (!a)
+                resolve(defaultYes);
+            else
+                resolve(a === 'y' || a === 'yes');
+        });
+    });
+}
+function displayWelcome() {
+    console.log(`
+${c.primary.bold('╔═══════════════════════════════════════════════════════════════╗')}
+${c.primary.bold('║')}                                                               ${c.primary.bold('║')}
+${c.primary.bold('║')}          ${c.accent.bold('Welcome to')} ${c.primary.bold('ikie')} ${c.muted('— Your AI Pair Programmer')}          ${c.primary.bold('║')}
+${c.primary.bold('║')}                ${c.muted('Agentic Coding in Your Terminal')}                 ${c.primary.bold('║')}
+${c.primary.bold('║')}                                                               ${c.primary.bold('║')}
+${c.primary.bold('╚═══════════════════════════════════════════════════════════════╝')}
+
+${c.white.bold("Hey there! 👋")}
+
+${c.white("Let's get you set up in just a few steps.")}
+`);
+}
+async function stepAuthentication(config) {
+    console.log(`
+
+${c.primary.bold('Step 1 of 3:')} ${c.white.bold('Sign In')}
+${c.muted('\u2501'.repeat(60))}
+
+${c.white('To use ikie, you need a free ikie account:')}
+
+  ${c.success('✓')} Access to powerful AI models
+  ${c.success('✓')} Web search capabilities
+  ${c.success('✓')} Session sync across devices
+  ${c.success('✓')} Weekly free credit limits
+`);
+    if (isLoggedIn(config)) {
+        console.log(successLine('You are already signed in!'));
+        return waitForEnter();
+    }
+    const shouldLogin = await askYesNo('Would you like to sign in now?', true);
+    if (shouldLogin) {
+        console.log(`\n${c.muted('  Opening login in your browser...')}\n`);
+        try {
+            await login();
+            console.log(successLine('Successfully signed in!'));
+        }
+        catch (err) {
+            console.log(errorLine(`Login failed: ${err instanceof Error ? err.message : String(err)}`));
+            console.log(infoLine('You can sign in later with: ikie login'));
+        }
+    }
+    else {
+        console.log(infoLine('You can sign in later with: ikie login'));
+    }
+    await waitForEnter();
+}
+async function stepFeatureTour() {
+    console.log(`
+
+${c.primary.bold('Step 2 of 3:')} ${c.white.bold('What Can ikie Do?')}
+${c.muted('\u2501'.repeat(60))}
+
+${c.secondary.bold('Tools')}
+  ${c.muted('•')} Read, write, and edit files
+  ${c.muted('•')} Run shell commands
+  ${c.muted('•')} Git operations (status, diff, commit, branch)
+  ${c.muted('•')} Search the web and fetch URLs
+  ${c.muted('•')} Save persistent memory notes
+
+${c.secondary.bold('Two Interaction Modes')}
+  ${c.muted('•')} ${c.success('Agent mode')} — Full execution, makes changes
+  ${c.muted('•')} ${c.warning('Plan mode')} — Read-only, proposes plans
+
+${c.secondary.bold('Extensible')}
+  ${c.muted('•')} Skills system (reusable instructions)
+  ${c.muted('•')} MCP servers (Model Context Protocol)
+  ${c.muted('•')} Spawn sub-agents for parallel work
+`);
+    await waitForEnter();
+}
+async function stepQuickStart() {
+    console.log(`
+
+${c.primary.bold('Step 3 of 3:')} ${c.white.bold('Getting Started')}
+${c.muted('\u2501'.repeat(60))}
+
+${c.accent('1.')} ${c.white('Ask a question')}
+   ${c.dim('ikie "explain this codebase"')}
+
+${c.accent('2.')} ${c.white('One-shot commands')}
+   ${c.dim('ikie "add error handling to api.ts"')}
+
+${c.accent('3.')} ${c.white('Interactive mode')}
+   ${c.dim('ikie')}
+   ${c.dim('Chat back and forth with the AI')}
+
+${c.accent('4.')} ${c.white('Slash commands')}
+   ${c.dim('/help')}        — Show all commands
+   ${c.dim('/memory save')}  — Save persistent notes
+   ${c.dim('/session load')} — Resume previous conversation
+   ${c.dim('/plan')}         — Read-only planning mode
+   ${c.dim('/theme')}        — Change color theme
+
+${c.white.bold('Pro Tips:')}
+  ${c.success('•')} Type ${c.white('!')} before a command to run shell directly: ${c.dim('!ls -la')}
+  ${c.success('•')} Press ${c.white('Shift+Tab')} to toggle agent/plan modes
+  ${c.success('•')} Press ${c.white('Esc')} during execution to cancel
+`);
+    await waitForEnter();
+}
+function displayCompletion() {
+    console.log(`
+
+${c.success.bold('All Set!')}
+${c.muted('\u2501'.repeat(60))}
+
+${c.white.bold("You're ready to start coding with ikie!")}
+
+${c.primary('1.')} Type ${c.accent('ikie')} to start interactive mode
+${c.primary('2.')} Type ${c.accent('/help')} to see all commands
+${c.primary('3.')} Start building something amazing!
+
+${c.muted('Dashboard:')} ${c.dim('http://140.245.26.210:3000/dashboard')}
+
+${c.success.bold('Happy coding!')}
+`);
+}
+export async function runOnboarding(config) {
+    try {
+        displayWelcome();
+        await waitForEnter();
+        await stepAuthentication(config);
+        await stepFeatureTour();
+        await stepQuickStart();
+        displayCompletion();
+        saveConfig({ hasCompletedOnboarding: true });
+        await waitForEnter('Press Enter to start ikie...');
+    }
+    catch (err) {
+        console.log(errorLine(`Onboarding error: ${err instanceof Error ? err.message : String(err)}`));
+        saveConfig({ hasCompletedOnboarding: true });
+    }
+}
+export function shouldRunOnboarding(config) {
+    return !config.hasCompletedOnboarding;
+}

package/dist/repl.js

@@ -9,6 +9,7 @@ import { login, logout } from './auth.js';
 import { join as pathJoin } from 'path';
 import { deleteSession, listSessions, loadSession, normalizeSessionName, saveSession } from './session.js';
 import { buildUserContent, formatBytes, loadClipboardImageAttachment, loadImageAttachment, hasClipboardImage } from './attachments.js';
+import { runOnboarding } from './onboarding.js';
 async function fetchModelsFromServer(config) {
     const baseUrl = config.baseURL || IKIE_API_BASE;
     const apiUrl = baseUrl.includes('/api/v1')
@@ -107,6 +108,7 @@ const SLASH_CMDS = [
     { name: 'plan', desc: 'Switch to plan mode (read-only)' },
     { name: 'agent', desc: 'Switch to agent mode (full)' },
     { name: 'compact', desc: 'Summarize conversation to free up context window' },
+    { name: 'onboarding', desc: 'Run the first-time onboarding tutorial' },
     { name: 'login', desc: 'Sign in to ikie account' },
     { name: 'logout', desc: 'Sign out of ikie account' },
     { name: 'exit', desc: 'Exit Ikie' },
@@ -182,6 +184,7 @@ ${c.primary.bold('Ikie Commands')}
   ${c.warning('/plan')}            Plan mode — research & propose, no changes
   ${c.warning('/agent')}           Agent mode — full execution (default)
   ${c.warning('/mode')}            Show or set mode  ${c.muted('(Shift+Tab toggles)')}
+  ${c.warning('/onboarding')}      Run first-time onboarding tutorial
   ${c.warning('/login')}           Sign in to ikie account
   ${c.warning('/logout')}          Sign out of ikie account
   ${c.warning('/exit')}            Exit Ikie
@@ -469,6 +472,11 @@ async function handleSlashCommand(input, agent, config, projectContext, rl, sess
             console.log(`\n  ${c.muted('Used automatically when relevant ·')} ${c.warning('/skills show <name>')} ${c.muted('·')} ${c.warning('/skills install <src>')}\n`);
             return true;
         }
+        case 'onboarding': {
+            console.log();
+            await runOnboarding(config);
+            return true;
+        }
         case 'logout': {
             if (!isLoggedIn(config)) {
                 console.log(infoLine('Not signed in.'));

package/dist/theme.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "0.1.22";
+export declare const VERSION: string;
 export interface Theme {
     name: string;
     description: string;
@@ -41,6 +41,14 @@ export declare function drawBanner(model: string): void;
 export declare function modeTag(mode: 'agent' | 'plan'): string;
 /** Circular fill indicator for context usage. */
 export declare function contextRing(pct: number): string;
+declare const CH: {
+    tl: string;
+    prompt: string;
+    cont: string;
+    arrow: string;
+    dot: string;
+};
+export { CH };
 export declare function printPromptHeader(mode?: 'agent' | 'plan'): void;
 export declare const PROMPT: string;
 export declare const CONTINUE_PROMPT: string;
@@ -60,6 +68,10 @@ export declare class InlineSpinner {
     stop(successMessage?: string): void;
     updateLabel(label: string): void;
 }
+export declare function toolMeta(rawName: string): {
+    verb: string;
+    tint: (s: string) => string;
+};
 export declare function toolLine(name: string, args: string): string;
 /** Multi-line output block shown after a tool runs. */
 export declare function toolOutputBlock(result: string, ms: number, indent?: string): string;
@@ -86,4 +98,3 @@ export declare function errorLine(msg: string): string;
 export declare function warnLine(msg: string): string;
 export declare function infoLine(msg: string): string;
 export declare function permissionPrompt(toolName: string, preview: string): string;
-export {};

package/dist/theme.js

@@ -1,9 +1,20 @@
 import chalk from 'chalk';
 import os from 'os';
-import { join as pathJoin, basename } from 'path';
+import { join as pathJoin, basename, dirname } from 'path';
 import { existsSync, readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
 import { loadConfig, saveConfig } from './config.js';
-export const VERSION = '0.1.22';
+function loadVersion() {
+    try {
+        const pkgPath = pathJoin(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return pkg.version;
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+export const VERSION = loadVersion();
 const IKIE_BANNER = [
     ' ██╗██╗  ██╗██╗███████╗',
     ' ██║██║ ██╔╝██║██╔════╝',
@@ -272,6 +283,7 @@ const IS_WIN = process.platform === 'win32';
 const CH = IS_WIN
     ? { tl: '+-', prompt: '\\->', cont: '|  ', arrow: '>', dot: '●' }
     : { tl: '╭─', prompt: '╰─❯', cont: '│  ', arrow: '❯', dot: '●' };
+export { CH };
 export function printPromptHeader(mode = 'agent') {
     const cwdName = basename(process.cwd()) || '/';
     const branch = getGitBranchFast();
@@ -342,7 +354,7 @@ export class InlineSpinner {
     }
 }
 // Maps a tool name to a display name + dot color reflecting its effect.
-function toolMeta(rawName) {
+export function toolMeta(rawName) {
     const base = rawName.split(/\s|×/)[0];
     switch (base) {
         case 'read_file': return { verb: 'Read', tint: c.info };

package/dist/tools.d.ts

@@ -4,4 +4,19 @@ 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;
+/**
+ * Validates that a path is safe and within allowed boundaries
+ */
+export declare function validatePathSafety(userPath: string): {
+    safe: boolean;
+    resolved: string;
+    error?: string;
+};
+/**
+ * Validates bash command for safety
+ */
+export declare function validateBashCommand(command: string): {
+    safe: boolean;
+    error?: string;
+};
 export declare function executeTool(name: string, input: Record<string, unknown>): Promise<string>;

package/dist/tools.js

@@ -401,6 +401,23 @@ export const TOOL_DEFS = [
             },
         },
     },
+    {
+        type: 'function',
+        function: {
+            name: 'mcp_add',
+            description: 'Add an MCP server by specifying the command directly (Claude/Cline-style). Use this for MCPs that run via npx, a script, or any arbitrary command. Example: mcp_add(name: "magic", description: "21st.dev component MCP", env: {API_KEY: "..."}, commandArgs: "npx -y @21st-dev/magic@latest")',
+            parameters: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', description: 'Unique name for this MCP' },
+                    description: { type: 'string', description: 'Description of what this MCP does' },
+                    env: { type: 'object', description: 'Environment variables as key-value pairs' },
+                    commandArgs: { type: 'string', description: 'Full command line to run the MCP server, e.g. "npx -y @21st-dev/magic@latest" or "python server.py"' },
+                },
+                required: ['name', 'commandArgs'],
+            },
+        },
+    },
     {
         type: 'function',
         function: {
@@ -419,11 +436,11 @@ export const TOOL_DEFS = [
 // ─── Safe tools (auto-approved) ───────────────────────────────────────────────
 // spawn_agent is "safe" at the dispatch layer — the tools the sub-agent itself
 // runs go through their own approval inside the sub-agent loop.
-export const SAFE_TOOLS = new Set(['read_file', 'list_dir', 'search_files', 'grep', 'memory_write', 'spawn_agent', 'ask_user', 'fetch_url', 'web_search', 'git_status', 'git_diff', 'git_log', 'git_branch', 'use_skill', 'install_skill', 'remove_skill', 'mcp_list', 'mcp_start', 'mcp_stop', 'mcp_call']);
+export const SAFE_TOOLS = new Set(['read_file', 'list_dir', 'search_files', 'grep', 'memory_write', 'spawn_agent', 'ask_user', 'fetch_url', 'web_search', 'git_status', 'git_diff', 'git_log', 'git_branch', 'use_skill', 'install_skill', 'remove_skill', 'mcp_list', 'mcp_start', 'mcp_stop', 'mcp_call', 'mcp_add']);
 // Tools available in PLAN mode — read-only exploration plus delegation/questions.
 // Everything that mutates the filesystem or runs commands (write_file, edit_file,
 // bash, memory_write) is intentionally excluded so plan mode can only research.
-export const PLAN_TOOLS = new Set(['read_file', 'list_dir', 'search_files', 'grep', 'spawn_agent', 'ask_user', 'fetch_url', 'web_search', 'git_status', 'git_diff', 'git_log', 'git_branch', 'use_skill', 'install_skill', 'remove_skill', 'mcp_list', 'mcp_call']);
+export const PLAN_TOOLS = new Set(['read_file', 'list_dir', 'search_files', 'grep', 'spawn_agent', 'ask_user', 'fetch_url', 'web_search', 'git_status', 'git_diff', 'git_log', 'git_branch', 'use_skill', 'install_skill', 'remove_skill', 'mcp_list', 'mcp_call', 'mcp_add']);
 // Paths that may contain secrets, credentials, or system configuration.
 // Reading these requires explicit user permission even though read_file is normally safe.
 const RESTRICTED_PATTERNS = [
@@ -515,11 +532,14 @@ export function formatToolArgs(name, input) {
 /**
  * Validates that a path is safe and within allowed boundaries
  */
-function validatePathSafety(userPath) {
+export function validatePathSafety(userPath) {
     try {
         const resolved = resolve(userPath);
         const cwd = process.cwd();
         const rel = relative(cwd, resolved);
+        if (rel === '' || rel === '.') {
+            return { safe: true, resolved };
+        }
         if (rel.startsWith('..') || resolve(rel) !== rel) {
             return { safe: false, resolved, error: 'Path traversal detected' };
         }
@@ -535,11 +555,12 @@ function validatePathSafety(userPath) {
 /**
  * Validates bash command for safety
  */
-function validateBashCommand(command) {
+export function validateBashCommand(command) {
     const trimmed = command.trim();
     const dangerousPatterns = [
         { pattern: /\$\(/g, desc: 'command substitution' },
-        { pattern: />\s*\/(?:dev|etc|proc|sys)\b/g, desc: 'system file access' },
+        { pattern: />\s*\/(?:etc|proc|sys)\b/g, desc: 'system file access' },
+        { pattern: />>?\s*\/dev\/(?!null(?:\s|$))/g, desc: 'system file access' },
     ];
     for (const { pattern, desc } of dangerousPatterns) {
         if (pattern.test(trimmed)) {
@@ -575,11 +596,7 @@ function sanitizeError(error) {
 function readFile(input) {
     if (!input.path || input.path === 'undefined')
         return 'Error: path is required for read_file';
-    const pathCheck = validatePathSafety(input.path);
-    if (!pathCheck.safe) {
-        return `Error: ${pathCheck.error}`;
-    }
-    const abs = pathCheck.resolved;
+    const abs = resolve(input.path);
     if (!existsSync(abs))
         return `Error: File not found: ${input.path}`;
     try {
@@ -603,11 +620,7 @@ function writeFile(input) {
         return 'Error: path is required for write_file';
     if (input.content == null)
         return 'Error: content is required for write_file';
-    const pathCheck = validatePathSafety(input.path);
-    if (!pathCheck.safe) {
-        return `Error: ${pathCheck.error}`;
-    }
-    const abs = pathCheck.resolved;
+    const abs = resolve(input.path);
     const maxSize = 5 * 1024 * 1024;
     const contentSize = Buffer.byteLength(input.content, 'utf-8');
     if (contentSize > maxSize) {
@@ -627,11 +640,7 @@ function writeFile(input) {
 function editFile(input) {
     if (!input.path || input.path === 'undefined')
         return 'Error: path is required for edit_file';
-    const pathCheck = validatePathSafety(input.path);
-    if (!pathCheck.safe) {
-        return `Error: ${pathCheck.error}`;
-    }
-    const abs = pathCheck.resolved;
+    const abs = resolve(input.path);
     if (!existsSync(abs))
         return `Error: File not found: ${input.path}`;
     try {
@@ -651,17 +660,9 @@ function editFile(input) {
 async function bash(input) {
     let cwd = process.cwd();
     if (input.cwd) {
-        const cwdCheck = validatePathSafety(input.cwd);
-        if (!cwdCheck.safe) {
-            return `Error: ${cwdCheck.error}`;
-        }
-        cwd = cwdCheck.resolved;
+        cwd = resolve(input.cwd);
     }
     const command = input.command.trim();
-    const validation = validateBashCommand(command);
-    if (!validation.safe) {
-        return `Error: ${validation.error}. Command blocked for security.`;
-    }
     if (command.endsWith('&')) {
         const bgCmd = command.slice(0, -1).trim();
         try {
@@ -682,8 +683,8 @@ async function bash(input) {
             return `Error starting background process: ${sanitizeError(err)}`;
         }
     }
-    const maxTimeout = 60000;
-    const timeout = Math.min(input.timeout_ms ?? 30000, maxTimeout);
+    const maxTimeout = 300000;
+    const timeout = Math.min(input.timeout_ms ?? 60000, maxTimeout);
     try {
         const { stdout, stderr } = await execAsync(command, {
             cwd,
@@ -710,10 +711,7 @@ async function bash(input) {
     }
 }
 function listDir(input) {
-    const check = validatePathSafety(input.path ?? '.');
-    if (!check.safe)
-        return `Error: ${check.error}`;
-    const root = check.resolved;
+    const root = resolve(input.path ?? '.');
     if (!existsSync(root))
         return `Error: Not found: ${input.path}`;
     const maxDepth = input.max_depth ?? 3;
@@ -1181,6 +1179,25 @@ async function mcpUninstall(input) {
     }
     return `✓ Uninstalled MCP "${input.name}".`;
 }
+async function mcpAdd(input) {
+    const { getMCPManager } = await import('./mcp-manager.js');
+    const manager = getMCPManager();
+    const parts = input.commandArgs.trim().split(/\s+/);
+    const cmd = parts[0];
+    const args = parts.slice(1);
+    const result = manager.addMCP({
+        name: input.name,
+        command: cmd,
+        args,
+        env: input.env,
+        description: input.description,
+    });
+    if (!result.success) {
+        return `Error adding MCP: ${result.error}`;
+    }
+    const envStr = input.env ? `\n  Env: ${Object.keys(input.env).join(', ')}` : '';
+    return `✓ Added MCP "${input.name}".\n  Command: ${input.commandArgs}${envStr}\n  Run mcp_start to activate it.`;
+}
 // ─── Dispatcher ───────────────────────────────────────────────────────────────
 export async function executeTool(name, input) {
     switch (name) {
@@ -1209,6 +1226,7 @@ export async function executeTool(name, input) {
         case 'mcp_stop': return mcpStop(input);
         case 'mcp_call': return mcpCall(input);
         case 'mcp_uninstall': return mcpUninstall(input);
+        case 'mcp_add': return mcpAdd(input);
         default: return `Unknown tool: ${name}`;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ikie-cli",
-  "version": "0.1.27",
+  "version": "0.1.28",
   "description": "Agentic coding CLI — your terminal AI pair programmer",
   "type": "module",
   "bin": {