ikie-cli 0.1.39 → 0.1.41

package/dist/tools.js

@@ -5,7 +5,130 @@ import { promisify } from 'util';
 import { glob } from 'glob';
 import { getMcpManager, parseClaudeMcpAddCommand } from './mcp-manager.js';
 const execAsync = promisify(exec);
-// ─── OpenAI-format Tool Definitions ──────────────────────────────────────────
+const sessions = new Map();
+let sidAcc = 0;
+const sessionId = () => `s_${Date.now().toString(36)}_${(++sidAcc).toString(36)}`;
+function closeSession(id) {
+    const s = sessions.get(id);
+    if (s && !s.done) {
+        s.done = true;
+        try {
+            s.child.kill();
+        }
+        catch { }
+    }
+    sessions.delete(id);
+}
+// GC stale sessions every 30s
+setInterval(() => {
+    const now = Date.now();
+    for (const [id, s] of sessions)
+        if (s.done || now - s.at > 300_000)
+            closeSession(id);
+}, 30_000).unref();
+/**
+ * Spawn a command with pipes.  If it exits before `graceMs`, resolve normally
+ * (no session).  If it stays alive, stash the session and return a tagged
+ * result so the agent can continue sending input.
+ */
+async function trySession(command, cwd, graceMs, signal) {
+    const isWin = process.platform === 'win32';
+    const child = spawn(isWin ? 'cmd.exe' : 'bash', isWin ? ['/d', '/s', '/c', command] : ['-c', command], { cwd, stdio: ['pipe', 'pipe', 'pipe'] });
+    let out = '';
+    let exited = false;
+    let exitCode = null;
+    child.stdout.on('data', (d) => { out += d.toString(); });
+    child.stderr.on('data', (d) => { out += d.toString(); });
+    const exitPromise = new Promise(r => {
+        child.on('exit', (c) => { exited = true; exitCode = c; r(); });
+        child.on('error', () => { exited = true; exitCode = 1; r(); });
+    });
+    // Abort during initial wait kills the child.
+    if (signal?.aborted) {
+        child.kill();
+        return 'Interrupted.';
+    }
+    const abortKill = () => { try {
+        child.kill();
+    }
+    catch { } };
+    if (signal)
+        signal.addEventListener('abort', abortKill, { once: true });
+    // Wait grace period — if the process finishes, return output directly.
+    await Promise.race([
+        exitPromise,
+        new Promise(r => setTimeout(r, graceMs)),
+    ]);
+    if (signal)
+        signal.removeEventListener('abort', abortKill);
+    if (exited) {
+        const parts = [];
+        if (out.trim())
+            parts.push(out.trim());
+        const output = parts.join('\n') || '(no output)';
+        return exitCode === 0 ? output : `Exit ${exitCode ?? 1}\n${output}`;
+    }
+    // Still alive — create a session.
+    const id = sessionId();
+    sessions.set(id, { child, lastOutput: out, at: Date.now(), done: false });
+    // Also kill the session on abort.
+    if (signal) {
+        signal.addEventListener('abort', () => closeSession(id), { once: true });
+    }
+    // Continue accumulating output into lastOutput.
+    child.stdout.on('data', (d) => {
+        const s = sessions.get(id);
+        if (s)
+            s.lastOutput += d.toString();
+    });
+    child.stderr.on('data', (d) => {
+        const s = sessions.get(id);
+        if (s)
+            s.lastOutput += d.toString();
+    });
+    child.on('exit', () => {
+        const s = sessions.get(id);
+        if (s)
+            s.done = true;
+    });
+    return `[session ${id}]\n${out.trimEnd() || '(awaiting input)'}`;
+}
+/**
+ * Send input to an active session and wait up to `waitMs` for more output.
+ * Returns new output accumulated since the last call.
+ */
+async function continueSession(id, stdin, waitMs, signal) {
+    const s = sessions.get(id);
+    if (!s)
+        return '[session not found]';
+    if (s.done)
+        return s.lastOutput || '(process already exited)';
+    const beforeLen = s.lastOutput.length;
+    s.child.stdin.write(stdin);
+    s.child.stdin.write('\n');
+    // Abort mid-wait → kill the session.
+    if (signal?.aborted) {
+        closeSession(id);
+        return 'Interrupted.';
+    }
+    const abortKill = () => closeSession(id);
+    if (signal)
+        signal.addEventListener('abort', abortKill, { once: true });
+    // Wait for exit or timeout and collect whatever output came in.
+    await Promise.race([
+        new Promise(r => s.child.once('exit', () => r())),
+        new Promise(r => setTimeout(r, waitMs)),
+    ]);
+    if (signal)
+        signal.removeEventListener('abort', abortKill);
+    s.at = Date.now();
+    const newPart = s.lastOutput.slice(beforeLen).trim();
+    if (s.done) {
+        closeSession(id);
+        return newPart || '(process exited)';
+    }
+    return newPart || '(no new output)';
+}
 export const TOOL_DEFS = [
     {
         type: 'function',
@@ -62,12 +185,15 @@ export const TOOL_DEFS = [
             parameters: {
                 type: 'object',
                 properties: {
-                    command: { type: 'string', description: 'Shell command' },
+                    command: { type: 'string', description: 'Shell command. Omit when continuing an interactive session (provide session_id instead).' },
                     timeout_ms: { type: 'number', description: 'Timeout ms (default 30000)' },
                     cwd: { type: 'string', description: 'Working directory' },
                     interactive: { type: 'boolean', description: 'Set true for commands that need an interactive terminal — ones that show arrow-key menus or prompts that cannot be skipped with flags (e.g. `shadcn init`, `create-next-app`, `npm init` without -y). The command is connected to the real terminal so the USER answers the prompts directly. Output is shown live, not captured, so the result only reports the exit status — read any files it creates afterward.' },
+                    allow_interaction: { type: 'boolean', description: 'Set true to let the AGENT handle interactive prompts programmatically. If the command prompts for input (stays alive >2s), a session is created — the result includes a session_id and the prompt text. Send input by calling bash with the same session_id + stdin. If the command runs to completion without prompting, it returns normally with no session.' },
+                    session_id: { type: 'string', description: 'Session ID from an `allow_interaction` bash call. Provide to continue answering prompts — set `stdin` to send input, or omit `stdin` to poll for more output.' },
+                    stdin: { type: 'string', description: 'Input to send to an active session\'s stdin. Only valid when `session_id` is set. The input is sent followed by a newline.' },
                 },
-                required: ['command'],
+                required: [],
             },
         },
     },
@@ -154,21 +280,6 @@ export const TOOL_DEFS = [
             },
         },
     },
-    {
-        type: 'function',
-        function: {
-            name: 'spawn_agent',
-            description: 'Delegate a self-contained subtask to a focused, autonomous sub-agent that has the same tools (it cannot spawn further sub-agents). The sub-agent does NOT see the current conversation, so the task and context must be self-contained. It returns a concise summary of what it did. Use for isolating research or parallelizable chunks of work. Multiple subagents can run in parallel.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    task: { type: 'string', description: 'A clear, complete description of the task for the sub-agent to accomplish.' },
-                    context: { type: 'string', description: 'Optional background the sub-agent needs (file paths, constraints, prior findings).' },
-                },
-                required: ['task'],
-            },
-        },
-    },
     {
         type: 'function',
         function: {
@@ -365,14 +476,12 @@ export function getMcpToolDefs() {
     return getMcpManager().getToolDefsSync();
 }
 // ─── 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']);
-// Tools available in PLAN mode — read-only exploration plus delegation/questions.
+export const SAFE_TOOLS = new Set(['read_file', 'list_dir', 'search_files', 'grep', 'memory_write', 'ask_user', 'fetch_url', 'web_search', 'git_status', 'git_diff', 'git_log', 'git_branch', 'use_skill', 'install_skill', 'remove_skill', 'mcp_list']);
+// Tools available in PLAN mode — read-only exploration plus 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.
 // MCP tools are also excluded because we cannot prove they are read-only.
-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']);
+export const PLAN_TOOLS = new Set(['read_file', 'list_dir', 'search_files', 'grep', 'ask_user', 'fetch_url', 'web_search', 'git_status', 'git_diff', 'git_log', 'git_branch', 'use_skill', 'install_skill', 'remove_skill', 'mcp_list']);
 // 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 = [
@@ -428,10 +537,6 @@ export function formatToolArgs(name, input) {
             const q = String(input.question ?? '');
             return `"${q.length > 56 ? q.slice(0, 56) + '…' : q}"`;
         }
-        case 'spawn_agent': {
-            const task = String(input.task ?? '');
-            return `"${task.length > 56 ? task.slice(0, 56) + '…' : task}"`;
-        }
         case 'git_status':
             return input.path ? `"${p(input.path)}"` : '(cwd)';
         case 'git_diff':
@@ -558,14 +663,24 @@ function editFile(input) {
         return `Error: ${sanitizeError(e)}`;
     }
 }
-async function bash(input) {
+async function bash(input, signal) {
     let cwd = process.cwd();
     if (input.cwd) {
         cwd = resolve(input.cwd);
     }
-    const command = input.command.trim();
+    // Session continuation: send stdin to an active session.
+    if (input.session_id) {
+        return continueSession(input.session_id, input.stdin ?? '', 5000, signal);
+    }
+    const command = (input.command ?? '').trim();
+    if (!command)
+        return 'Error: command is required for bash';
     if (input.interactive) {
-        return bashInteractive(command, cwd);
+        return bashInteractive(command, cwd, signal);
+    }
+    // Agent-controlled interactive session.
+    if (input.allow_interaction) {
+        return trySession(command, cwd, 2500, signal);
     }
     if (command.endsWith('&')) {
         const bgCmd = command.slice(0, -1).trim();
@@ -592,34 +707,48 @@ async function bash(input) {
     // For build commands or when stream is enabled, use streaming output
     const shouldStream = input.stream || /\b(build|compile|test|deploy|install)\b/i.test(command);
     if (shouldStream) {
-        return bashStreaming(command, cwd, timeout);
+        return bashStreaming(command, cwd, timeout, signal);
     }
-    try {
-        const { stdout, stderr } = await execAsync(command, {
-            cwd,
-            timeout,
-            maxBuffer: 2 * 1024 * 1024,
+    return bashSpawn(command, cwd, timeout, signal);
+}
+/**
+ * Spawn a command, capture output, and kill it on abort signal.
+ */
+function bashSpawn(command, cwd, timeout, signal) {
+    return new Promise((resolve) => {
+        const isWindows = process.platform === 'win32';
+        const child = spawn(isWindows ? 'cmd.exe' : 'bash', isWindows ? ['/d', '/s', '/c', command] : ['-c', command], { cwd, timeout });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (data) => { stdout += data.toString(); });
+        child.stderr?.on('data', (data) => { stderr += data.toString(); });
+        const kill = () => { try {
+            child.kill();
+        }
+        catch { /* ignore */ } };
+        if (signal) {
+            if (signal.aborted) {
+                kill();
+                resolve('Interrupted.');
+                return;
+            }
+            signal.addEventListener('abort', kill, { once: true });
+        }
+        child.on('error', () => { });
+        child.on('exit', (code) => {
+            if (signal)
+                signal.removeEventListener('abort', kill);
+            const parts = [];
+            if (stdout.trim())
+                parts.push(stdout.trim());
+            if (stderr.trim())
+                parts.push(`[stderr]\n${stderr.trim()}`);
+            const output = parts.join('\n') || '(no output)';
+            resolve(code === 0 ? output : `Exit ${code ?? 1}\n${output}`);
         });
-        const parts = [];
-        if (stdout.trim())
-            parts.push(stdout.trim());
-        if (stderr.trim())
-            parts.push(`[stderr]\n${stderr.trim()}`);
-        return parts.join('\n') || '(no output)';
-    }
-    catch (err) {
-        const e = err;
-        const parts = [];
-        if (e.stdout?.trim())
-            parts.push(e.stdout.trim());
-        if (e.stderr?.trim())
-            parts.push(`[stderr]\n${e.stderr.trim()}`);
-        if (!parts.length)
-            parts.push(sanitizeError(e.message ?? 'Command failed'));
-        return `Exit ${e.code ?? 1}\n${parts.join('\n')}`;
-    }
+    });
 }
-function bashStreaming(command, cwd, timeout) {
+function bashStreaming(command, cwd, timeout, signal) {
     return new Promise((resolve, reject) => {
         const isWindows = process.platform === 'win32';
         const child = spawn(isWindows ? 'cmd.exe' : 'bash', isWindows ? ['/d', '/s', '/c', command] : ['-c', command], { cwd, timeout });
@@ -629,8 +758,25 @@ function bashStreaming(command, cwd, timeout) {
         const MAX_LINES_SHOWN = 3;
         let linesShown = 0;
         let totalLines = 0;
+        const kill = () => { try {
+            child.kill();
+        }
+        catch { /* ignore */ } };
+        if (signal) {
+            if (signal.aborted) {
+                kill();
+                resolve('Interrupted.');
+                return;
+            }
+            signal.addEventListener('abort', kill, { once: true });
+        }
+        const cleanup = () => { if (signal)
+            signal.removeEventListener('abort', kill); };
         // Print a blank line before streaming output
-        process.stdout.write('\n');
+        const print = (text) => {
+            process.stdout.write(text);
+        };
+        print('\n');
         // Stream stdout line by line - show only first few lines
         child.stdout?.on('data', (data) => {
             const text = data.toString();
@@ -639,7 +785,7 @@ function bashStreaming(command, cwd, timeout) {
             for (const line of lines) {
                 totalLines++;
                 if (linesShown < MAX_LINES_SHOWN) {
-                    process.stdout.write(`${indent}${line}\n`);
+                    print(`${indent}${line}\n`);
                     linesShown++;
                 }
             }
@@ -651,19 +797,21 @@ function bashStreaming(command, cwd, timeout) {
             for (const line of lines) {
                 totalLines++;
                 if (linesShown < MAX_LINES_SHOWN) {
-                    process.stdout.write(`${indent}${line}\n`);
+                    print(`${indent}${line}\n`);
                     linesShown++;
                 }
             }
         });
         child.on('error', (err) => {
+            cleanup();
             reject(new Error(`Failed to execute command: ${sanitizeError(err)}`));
         });
         child.on('exit', (code) => {
+            cleanup();
             // Show truncation message if there are hidden lines
             const hiddenLines = totalLines - linesShown;
             if (hiddenLines > 0) {
-                process.stdout.write(`${indent}... +${hiddenLines} lines\n`);
+                print(`${indent}... +${hiddenLines} lines\n`);
             }
             const parts = [];
             if (stdout.trim())
@@ -688,7 +836,7 @@ function bashStreaming(command, cwd, timeout) {
  * listeners and raw mode while the child owns the terminal, then restores them.
  * Output is not captured — only the exit status is reported back to the agent.
  */
-function bashInteractive(command, cwd) {
+function bashInteractive(command, cwd, signal) {
     return new Promise((resolvePromise) => {
         const stdin = process.stdin;
         const isTTY = Boolean(stdin.isTTY);
@@ -719,14 +867,29 @@ function bashInteractive(command, cwd) {
                 process.stdout.write('\x1b[?2004l'); // disable bracketed paste for the child
         }
         process.stdout.write('\n');
+        let child;
+        const kill = () => { try {
+            child?.kill();
+        }
+        catch { /* ignore */ } };
+        if (signal) {
+            if (signal.aborted) {
+                restore();
+                resolvePromise('Interrupted.');
+                return;
+            }
+            signal.addEventListener('abort', () => { kill(); restore(); }, { once: true });
+        }
         try {
             const isWindows = process.platform === 'win32';
-            const child = spawn(isWindows ? 'cmd.exe' : 'bash', isWindows ? ['/d', '/s', '/c', command] : ['-c', command], { cwd, stdio: 'inherit' });
+            child = spawn(isWindows ? 'cmd.exe' : 'bash', isWindows ? ['/d', '/s', '/c', command] : ['-c', command], { cwd, stdio: 'inherit' });
             child.on('error', (err) => {
+                signal?.removeEventListener('abort', kill);
                 restore();
                 resolvePromise(`Error running interactive command: ${sanitizeError(err)}`);
             });
             child.on('exit', (code) => {
+                signal?.removeEventListener('abort', kill);
                 restore();
                 resolvePromise(code === 0
                     ? '(interactive command completed — output was shown to the user; read any created/changed files to see the result)'
@@ -734,6 +897,7 @@ function bashInteractive(command, cwd) {
             });
         }
         catch (err) {
+            signal?.removeEventListener('abort', kill);
             restore();
             resolvePromise(`Error running interactive command: ${sanitizeError(err)}`);
         }
@@ -1005,7 +1169,7 @@ function htmlToText(html) {
         .replace(/\n{3,}/g, '\n\n')
         .trim();
 }
-async function fetchUrl(input) {
+async function fetchUrl(input, signal) {
     let url = (input.url ?? '').trim();
     if (!url || url === 'undefined')
         return 'Error: url is required for fetch_url';
@@ -1014,6 +1178,13 @@ async function fetchUrl(input) {
     const maxChars = input.max_chars && input.max_chars > 0 ? input.max_chars : 10000;
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), 15000);
+    if (signal) {
+        if (signal.aborted) {
+            clearTimeout(timer);
+            return 'Interrupted.';
+        }
+        signal.addEventListener('abort', () => controller.abort(), { once: true });
+    }
     try {
         const res = await fetch(url, {
             redirect: 'follow',
@@ -1038,15 +1209,18 @@ async function fetchUrl(input) {
     }
     catch (err) {
         const e = err;
-        if (e.name === 'AbortError')
+        if (e.name === 'AbortError') {
+            if (signal?.aborted)
+                return 'Interrupted.';
             return `Error: request to ${url} timed out after 15s`;
+        }
         return `Error fetching ${url}: ${sanitizeError(e)}`;
     }
     finally {
         clearTimeout(timer);
     }
 }
-async function webSearch(input) {
+async function webSearch(input, signal) {
     const query = (input.query ?? '').trim();
     if (!query || query === 'undefined')
         return 'Error: query is required for web_search';
@@ -1056,11 +1230,18 @@ async function webSearch(input) {
     if (!apiKey) {
         return 'web_search requires an ikie account. Sign in with `ikie login` — search is included with your account.';
     }
+    const controller = new AbortController();
+    if (signal) {
+        if (signal.aborted)
+            return 'Interrupted.';
+        signal.addEventListener('abort', () => controller.abort(), { once: true });
+    }
     try {
         const u = new URL(`${IKIE_API_BASE}/search`);
         u.searchParams.set('q', query);
         u.searchParams.set('count', String(count));
         const res = await fetch(u, {
+            signal: controller.signal,
             headers: { Authorization: `Bearer ${apiKey}`, Accept: 'application/json' },
         });
         if (!res.ok) {
@@ -1170,13 +1351,13 @@ async function mcpAdd(input) {
     }
 }
 // ─── Dispatcher ───────────────────────────────────────────────────────────────
-export async function executeTool(name, input) {
+export async function executeTool(name, input, signal) {
     switch (name) {
         case 'read_file': return readFile(input);
         case 'switch_mode': return 'Error: switch_mode is handled by the agent, not the tool executor.';
         case 'write_file': return writeFile(input);
         case 'edit_file': return editFile(input);
-        case 'bash': return bash(input);
+        case 'bash': return bash(input, signal);
         case 'list_dir': return listDir(input);
         case 'search_files': return searchFiles(input);
         case 'grep': return grepFiles(input);
@@ -1186,8 +1367,8 @@ export async function executeTool(name, input) {
         case 'git_log': return gitLog(input);
         case 'git_commit': return gitCommit(input);
         case 'git_branch': return gitBranch(input);
-        case 'fetch_url': return fetchUrl(input);
-        case 'web_search': return webSearch(input);
+        case 'fetch_url': return fetchUrl(input, signal);
+        case 'web_search': return webSearch(input, signal);
         case 'use_skill': return useSkill(input);
         case 'install_skill': return installSkill(input);
         case 'remove_skill': return removeSkill(input);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ikie-cli",
-  "version": "0.1.39",
+  "version": "0.1.41",
   "description": "Agentic coding CLI — your terminal AI pair programmer",
   "type": "module",
   "bin": {
@@ -24,7 +24,7 @@
     "url": "git+https://github.com/ikie-cli/ikie.git"
   },
   "homepage": "https://ikie-cli.com",
-  "bugs": "https://github.com/anomalyco/opencode/issues",
+  "bugs": "https://github.com/ikie-cli/ikie/issues",
   "scripts": {
     "build": "tsc",
     "dev": "tsx src/index.ts",