ai-cli-mcp 2.13.0 → 2.14.1

package/dist/app/mcp.js

@@ -165,7 +165,7 @@ ${getSupportedModelsDescription()}
                 },
                 {
                     name: 'get_result',
-                    description: 'Get the current output and status of an AI agent process by PID. Returns the output from the agent including session_id (if applicable), along with process metadata.',
+                    description: 'Get the current output and status of an AI agent process by PID. Defaults to a compact result shape; set verbose to true for full metadata and detailed parsed output.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -175,7 +175,7 @@ ${getSupportedModelsDescription()}
                             },
                             verbose: {
                                 type: 'boolean',
-                                description: 'Optional: If true, returns detailed execution information including tool usage history. Defaults to false.',
+                                description: 'Optional: If true, returns the full result shape including metadata fields and detailed parsed output such as tool usage history. Defaults to false.',
                             }
                         },
                         required: ['pid'],
@@ -183,7 +183,7 @@ ${getSupportedModelsDescription()}
                 },
                 {
                     name: 'wait',
-                    description: 'Wait for multiple AI agent processes to complete and return their results. Blocks until all specified PIDs finish or timeout occurs.',
+                    description: 'Wait for multiple AI agent processes to complete and return their results. Defaults to compact result items; set verbose to true for full metadata and detailed parsed output.',
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -196,6 +196,10 @@ ${getSupportedModelsDescription()}
                                 type: 'number',
                                 description: 'Optional: Maximum time to wait in seconds. Defaults to 180 (3 minutes).',
                             },
+                            verbose: {
+                                type: 'boolean',
+                                description: 'Optional: If true, each result item uses the full result shape including metadata fields and detailed parsed output. Defaults to false.',
+                            },
                         },
                         required: ['pids'],
                     },
@@ -305,7 +309,7 @@ ${getSupportedModelsDescription()}
             throw new McpError(ErrorCode.InvalidParams, 'Missing or invalid required parameter: pids (must be a non-empty array of numbers)');
         }
         try {
-            const results = await this.processService.waitForProcesses(toolArguments.pids, typeof toolArguments.timeout === 'number' ? toolArguments.timeout : 180);
+            const results = await this.processService.waitForProcesses(toolArguments.pids, typeof toolArguments.timeout === 'number' ? toolArguments.timeout : 180, !!toolArguments.verbose);
             return {
                 content: [{
                         type: 'text',

package/dist/cli-process-service.js

@@ -1,10 +1,11 @@
 import { spawn } from 'node:child_process';
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, unlinkSync, writeFileSync, } from 'node:fs';
-import { join } from 'node:path';
+import { join, basename, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { buildCliCommand } from './cli-builder.js';
 import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
 import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
+import { buildProcessResult } from './process-result.js';
 function resolveDefaultStateDir() {
     return process.env.AI_CLI_STATE_DIR || join(homedir(), '.local', 'state', 'ai-cli');
 }
@@ -76,6 +77,7 @@ export class CliProcessService {
                 pid,
                 prompt: cmd.prompt,
                 workFolder: cmd.cwd,
+                cwdKey: this.resolveCwdKey(cmd.cwd),
                 model: options.model,
                 toolType: cmd.agent,
                 startTime: new Date().toISOString(),
@@ -132,7 +134,7 @@ export class CliProcessService {
                 agentOutput = parseForgeOutput(stdout);
             }
         }
-        const response = {
+        return buildProcessResult({
             pid,
             agent: refreshed.toolType,
             status: refreshed.status,
@@ -141,26 +143,11 @@ export class CliProcessService {
             workFolder: refreshed.workFolder,
             prompt: refreshed.prompt,
             model: refreshed.model,
-        };
-        if (agentOutput) {
-            if (!verbose && agentOutput.tools) {
-                const { tools, ...rest } = agentOutput;
-                response.agentOutput = rest;
-            }
-            else {
-                response.agentOutput = agentOutput;
-            }
-            if (agentOutput.session_id) {
-                response.session_id = agentOutput.session_id;
-            }
-        }
-        else {
-            response.stdout = stdout;
-            response.stderr = stderr;
-        }
-        return response;
+            stdout,
+            stderr,
+        }, agentOutput, verbose);
     }
-    async waitForProcesses(pids, timeoutSeconds = 180) {
+    async waitForProcesses(pids, timeoutSeconds = 180, verbose = false) {
         const start = Date.now();
         for (const pid of pids) {
             this.readProcess(pid);
@@ -168,7 +155,7 @@ export class CliProcessService {
         while (true) {
             const statuses = pids.map((pid) => this.refreshStatus(this.readProcess(pid)).status);
             if (statuses.every((status) => status !== 'running')) {
-                return Promise.all(pids.map((pid) => this.getProcessResult(pid, false)));
+                return Promise.all(pids.map((pid) => this.getProcessResult(pid, verbose)));
             }
             if (Date.now() - start >= timeoutSeconds * 1000) {
                 throw new Error(`Timed out after ${timeoutSeconds} seconds waiting for processes`);
@@ -210,7 +197,7 @@ export class CliProcessService {
             if (refreshed.status === 'running') {
                 continue;
             }
-            const processDir = this.resolveProcessDir(refreshed.workFolder, refreshed.pid);
+            const processDir = this.resolveStoredProcessDir(refreshed);
             if (existsSync(processDir)) {
                 rmSync(processDir, { recursive: true, force: true });
                 removed++;
@@ -247,10 +234,14 @@ export class CliProcessService {
         return process;
     }
     parseProcessFile(metaPath) {
-        return JSON.parse(readFileSync(metaPath, 'utf-8'));
+        const process = JSON.parse(readFileSync(metaPath, 'utf-8'));
+        if (!process.cwdKey) {
+            process.cwdKey = basename(dirname(dirname(metaPath)));
+        }
+        return process;
     }
     writeProcess(process) {
-        const processDir = this.resolveProcessDir(process.workFolder, process.pid);
+        const processDir = this.resolveStoredProcessDir(process);
         mkdirSync(processDir, { recursive: true });
         writeFileSync(this.resolveMetaPath(processDir), JSON.stringify(process, null, 2));
     }
@@ -271,7 +262,16 @@ export class CliProcessService {
         return join(this.stateDir, 'cwds');
     }
     resolveProcessDir(cwd, pid) {
-        return join(this.resolveCwdsDir(), normalizeCwdForStorage(realpathSync(cwd)), String(pid));
+        return join(this.resolveCwdsDir(), this.resolveCwdKey(cwd), String(pid));
+    }
+    resolveStoredProcessDir(process) {
+        if (!process.cwdKey) {
+            process.cwdKey = this.resolveCwdKey(process.workFolder);
+        }
+        return join(this.resolveCwdsDir(), process.cwdKey, String(process.pid));
+    }
+    resolveCwdKey(cwd) {
+        return normalizeCwdForStorage(realpathSync(cwd));
     }
     resolveMetaPath(processDir) {
         return join(processDir, 'meta.json');

package/dist/process-result.js

@@ -0,0 +1,51 @@
+function compactAgentOutput(agentOutput) {
+    if (!agentOutput || typeof agentOutput !== 'object') {
+        return null;
+    }
+    const { tools: _tools, ...rest } = agentOutput;
+    const compact = Object.fromEntries(Object.entries(rest).filter(([, value]) => value !== undefined && value !== null));
+    return Object.keys(compact).length > 0 ? compact : null;
+}
+function hasMeaningfulParsedOutput(agentOutput) {
+    if (!agentOutput || typeof agentOutput !== 'object') {
+        return false;
+    }
+    return Object.entries(agentOutput).some(([key, value]) => {
+        if (value === undefined || value === null) {
+            return false;
+        }
+        if (key === 'session_id') {
+            return false;
+        }
+        if (key === 'tools') {
+            return Array.isArray(value) ? value.length > 0 : true;
+        }
+        return true;
+    });
+}
+export function buildProcessResult(context, agentOutput, verbose = false) {
+    const response = {
+        pid: context.pid,
+        agent: context.agent,
+        status: context.status,
+        exitCode: context.exitCode ?? null,
+        model: context.model ?? null,
+    };
+    if (verbose) {
+        response.startTime = context.startTime;
+        response.workFolder = context.workFolder;
+        response.prompt = context.prompt;
+    }
+    if (agentOutput?.session_id) {
+        response.session_id = agentOutput.session_id;
+    }
+    const shapedAgentOutput = verbose ? agentOutput : compactAgentOutput(agentOutput);
+    if (hasMeaningfulParsedOutput(shapedAgentOutput)) {
+        response.agentOutput = shapedAgentOutput;
+    }
+    if (!response.agentOutput) {
+        response.stdout = context.stdout;
+        response.stderr = context.stderr;
+    }
+    return response;
+}

package/dist/process-service.js

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import { buildCliCommand } from './cli-builder.js';
 import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
+import { buildProcessResult } from './process-result.js';
 export class ProcessService {
     processManager = new Map();
     cliPaths;
@@ -100,7 +101,7 @@ export class ProcessService {
                 agentOutput = parseForgeOutput(process.stdout);
             }
         }
-        const response = {
+        return buildProcessResult({
             pid,
             agent: process.toolType,
             status: process.status,
@@ -109,26 +110,11 @@ export class ProcessService {
             workFolder: process.workFolder,
             prompt: process.prompt,
             model: process.model,
-        };
-        if (agentOutput) {
-            if (!verbose && agentOutput.tools) {
-                const { tools, ...rest } = agentOutput;
-                response.agentOutput = rest;
-            }
-            else {
-                response.agentOutput = agentOutput;
-            }
-            if (agentOutput.session_id) {
-                response.session_id = agentOutput.session_id;
-            }
-        }
-        else {
-            response.stdout = process.stdout;
-            response.stderr = process.stderr;
-        }
-        return response;
+            stdout: process.stdout,
+            stderr: process.stderr,
+        }, agentOutput, verbose);
     }
-    async waitForProcesses(pids, timeoutSeconds = 180) {
+    async waitForProcesses(pids, timeoutSeconds = 180, verbose = false) {
         for (const pid of pids) {
             if (!this.processManager.has(pid)) {
                 throw new Error(`Process with PID ${pid} not found`);
@@ -155,7 +141,7 @@ export class ProcessService {
         });
         try {
             await Promise.race([Promise.all(waitPromises), timeoutPromise]);
-            return pids.map((pid) => this.getProcessResult(pid, false));
+            return pids.map((pid) => this.getProcessResult(pid, verbose));
         }
         finally {
             if (timeoutHandle) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-cli-mcp",
-  "version": "2.13.0",
+  "version": "2.14.1",
   "mcpName": "io.github.mkXultra/ai-cli-mcp",
   "description": "MCP server for AI CLI tools (Claude, Codex, Gemini, and Forge) with background process management",
   "author": "mkXultra",

package/src/__tests__/app-cli.test.ts

@@ -3,6 +3,7 @@ import {
   CLI_HELP_TEXT,
   DOCTOR_HELP_TEXT,
   MODELS_HELP_TEXT,
+  RESULT_HELP_TEXT,
   RUN_HELP_TEXT,
   WAIT_HELP_TEXT,
   runCli,
@@ -142,10 +143,28 @@ describe('ai-cli app', () => {
     );
 
     expect(exitCode).toBe(0);
-    expect(waitForProcesses).toHaveBeenCalledWith([123, 456], 5);
+    expect(waitForProcesses).toHaveBeenCalledWith([123, 456], 5, false);
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"status": "completed"'));
   });
 
+  it('passes verbose through to wait', async () => {
+    const stdout = vi.fn();
+    const stderr = vi.fn();
+    const waitForProcesses = vi.fn().mockResolvedValue([{ pid: 123, status: 'completed' }]);
+
+    const exitCode = await runCli(
+      ['wait', '123', '--verbose'],
+      {
+        stdout,
+        stderr,
+        waitForProcesses,
+      }
+    );
+
+    expect(exitCode).toBe(0);
+    expect(waitForProcesses).toHaveBeenCalledWith([123], undefined, true);
+  });
+
   it('rejects invalid wait timeout values', async () => {
     const stdout = vi.fn();
     const stderr = vi.fn();
@@ -291,6 +310,19 @@ describe('ai-cli app', () => {
     expect(stderr).not.toHaveBeenCalled();
   });
 
+  it('prints detailed help for result --help', async () => {
+    const stdout = vi.fn();
+    const stderr = vi.fn();
+
+    const exitCode = await runCli(['result', '--help'], { stdout, stderr });
+
+    expect(exitCode).toBe(0);
+    expect(stdout).toHaveBeenCalledWith(RESULT_HELP_TEXT);
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('compact result shape'));
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('--verbose'));
+    expect(stderr).not.toHaveBeenCalled();
+  });
+
   it('prints detailed help for wait --help', async () => {
     const stdout = vi.fn();
     const stderr = vi.fn();
@@ -299,6 +331,8 @@ describe('ai-cli app', () => {
 
     expect(exitCode).toBe(0);
     expect(stdout).toHaveBeenCalledWith(WAIT_HELP_TEXT);
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('compact shape'));
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('--verbose'));
     expect(stderr).not.toHaveBeenCalled();
   });
 

package/src/__tests__/cli-process-service.test.ts

@@ -84,8 +84,18 @@ describe('CliProcessService', () => {
 
     const waitResult = await service.waitForProcesses([runResult.pid], 5);
     expect(waitResult).toHaveLength(1);
-    expect(waitResult[0].pid).toBe(runResult.pid);
-    expect(waitResult[0].status).toBe('completed');
+    expect(waitResult[0]).toMatchObject({
+      pid: runResult.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: null,
+      model: 'sonnet',
+      stdout: expect.any(String),
+      stderr: expect.any(String),
+    });
+    expect(waitResult[0]).not.toHaveProperty('startTime');
+    expect(waitResult[0]).not.toHaveProperty('workFolder');
+    expect(waitResult[0]).not.toHaveProperty('prompt');
 
     const listed = await service.listProcesses();
     expect(listed).toContainEqual({
@@ -95,12 +105,141 @@ describe('CliProcessService', () => {
     });
 
     const result = await service.getProcessResult(runResult.pid, false);
-    expect(result.pid).toBe(runResult.pid);
-    expect(result.status).toBe('completed');
-    expect(result.stdout).toContain('Command executed successfully');
+    expect(result).toMatchObject({
+      pid: runResult.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: null,
+      model: 'sonnet',
+      stdout: expect.stringContaining('Command executed successfully'),
+      stderr: expect.any(String),
+    });
+    expect(result).not.toHaveProperty('startTime');
+    expect(result).not.toHaveProperty('workFolder');
+    expect(result).not.toHaveProperty('prompt');
     expect(readFileSync(join(processDir, 'meta.json'), 'utf-8')).toContain('"status": "completed"');
   });
 
+  it('returns compact results by default and full results when verbose is true', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+    tempDirs.push(root);
+    const scriptPath = join(root, 'mock-claude-json');
+    writeFileSync(
+      scriptPath,
+      `#!/bin/bash
+printf '%s\n' '{"type":"assistant","message":{"content":[{"type":"tool_use","id":"tool-1","name":"Read","input":{"file_path":"/tmp/demo.txt"}}]}}'
+printf '%s\n' '{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"tool-1","content":[{"type":"text","text":"demo output"}]}]}}'
+printf '%s\n' '{"type":"result","result":"Completed cli-process-service test"}'
+printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
+`
+    );
+    chmodSync(scriptPath, 0o755);
+    const stateDir = join(root, 'state');
+    const workFolder = join(root, 'work');
+    mkdirSync(workFolder, { recursive: true });
+
+    const service = new CliProcessService({
+      stateDir,
+      cliPaths: {
+        claude: scriptPath,
+        codex: scriptPath,
+        gemini: scriptPath,
+        forge: scriptPath,
+      },
+    });
+
+    const runResult = await service.startProcess({
+      prompt: 'hello structured output',
+      cwd: workFolder,
+    });
+
+    const compactWait = await service.waitForProcesses([runResult.pid], 5);
+    expect(compactWait).toHaveLength(1);
+    expect(compactWait[0]).toMatchObject({
+      pid: runResult.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: null,
+      model: null,
+      session_id: 'session-cli-1',
+      agentOutput: {
+        message: 'Completed cli-process-service test',
+        session_id: 'session-cli-1',
+      },
+    });
+    expect(compactWait[0]).not.toHaveProperty('startTime');
+    expect(compactWait[0]).not.toHaveProperty('workFolder');
+    expect(compactWait[0]).not.toHaveProperty('prompt');
+    expect(compactWait[0].agentOutput).not.toHaveProperty('tools');
+
+    const compactResult = await service.getProcessResult(runResult.pid, false);
+    expect(compactResult).toMatchObject({
+      pid: runResult.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: null,
+      model: null,
+      session_id: 'session-cli-1',
+      agentOutput: {
+        message: 'Completed cli-process-service test',
+        session_id: 'session-cli-1',
+      },
+    });
+    expect(compactResult).not.toHaveProperty('startTime');
+    expect(compactResult).not.toHaveProperty('workFolder');
+    expect(compactResult).not.toHaveProperty('prompt');
+    expect(compactResult.agentOutput).not.toHaveProperty('tools');
+
+    const verboseWait = await service.waitForProcesses([runResult.pid], 5, true);
+    expect(verboseWait).toHaveLength(1);
+    expect(verboseWait[0]).toMatchObject({
+      pid: runResult.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: null,
+      model: null,
+      startTime: expect.any(String),
+      workFolder,
+      prompt: 'hello structured output',
+      session_id: 'session-cli-1',
+      agentOutput: {
+        message: 'Completed cli-process-service test',
+        session_id: 'session-cli-1',
+        tools: [
+          {
+            tool: 'Read',
+            input: { file_path: '/tmp/demo.txt' },
+            output: 'demo output',
+          },
+        ],
+      },
+    });
+
+    const verboseResult = await service.getProcessResult(runResult.pid, true);
+    expect(verboseResult).toMatchObject({
+      pid: runResult.pid,
+      agent: 'claude',
+      status: 'completed',
+      exitCode: null,
+      model: null,
+      startTime: expect.any(String),
+      workFolder,
+      prompt: 'hello structured output',
+      session_id: 'session-cli-1',
+      agentOutput: {
+        message: 'Completed cli-process-service test',
+        session_id: 'session-cli-1',
+        tools: [
+          {
+            tool: 'Read',
+            input: { file_path: '/tmp/demo.txt' },
+            output: 'demo output',
+          },
+        ],
+      },
+    });
+  });
+
   it('can terminate a tracked process', async () => {
     const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
     tempDirs.push(root);
@@ -195,6 +334,111 @@ describe('CliProcessService', () => {
     killSpy.mockRestore();
   });
 
+  it('lists processes without crashing when a tracked work folder has been deleted', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+    tempDirs.push(root);
+    const stateDir = join(root, 'state');
+    const workFolder = join(root, 'deleted-project');
+    mkdirSync(workFolder, { recursive: true });
+
+    const pid = 45678;
+    const processDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)), String(pid));
+    mkdirSync(processDir, { recursive: true });
+
+    writeFileSync(
+      join(processDir, 'meta.json'),
+      JSON.stringify({
+        pid,
+        prompt: 'deleted cwd',
+        workFolder,
+        toolType: 'claude',
+        startTime: new Date().toISOString(),
+        stdoutPath: join(processDir, 'stdout.log'),
+        stderrPath: join(processDir, 'stderr.log'),
+        status: 'running',
+      })
+    );
+
+    rmSync(workFolder, { recursive: true, force: true });
+
+    const service = new CliProcessService({
+      stateDir,
+      cliPaths: {
+        claude: '/bin/sh',
+        codex: '/bin/sh',
+        gemini: '/bin/sh',
+        forge: '/bin/sh',
+      },
+    });
+
+    const killSpy = vi.spyOn(globalThis.process, 'kill').mockImplementation((target: number, signal?: string | number) => {
+      if (signal === 0 && target === pid) {
+        throw Object.assign(new Error('not running'), { code: 'ESRCH' });
+      }
+      return true;
+    });
+
+    const listed = await service.listProcesses();
+
+    expect(listed).toEqual([
+      {
+        pid,
+        agent: 'claude',
+        status: 'completed',
+      },
+    ]);
+    expect(JSON.parse(readFileSync(join(processDir, 'meta.json'), 'utf-8')).status).toBe('completed');
+    killSpy.mockRestore();
+  });
+
+  it('cleans up finished process directories even when their work folder has been deleted', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+    tempDirs.push(root);
+    const stateDir = join(root, 'state');
+    const workFolder = join(root, 'deleted-finished-project');
+    mkdirSync(workFolder, { recursive: true });
+
+    const pid = 56789;
+    const cwdDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)));
+    const processDir = join(cwdDir, String(pid));
+    mkdirSync(processDir, { recursive: true });
+
+    writeFileSync(
+      join(processDir, 'meta.json'),
+      JSON.stringify({
+        pid,
+        prompt: 'done',
+        workFolder,
+        toolType: 'claude',
+        startTime: new Date().toISOString(),
+        stdoutPath: join(processDir, 'stdout.log'),
+        stderrPath: join(processDir, 'stderr.log'),
+        status: 'completed',
+      })
+    );
+
+    rmSync(workFolder, { recursive: true, force: true });
+
+    const service = new CliProcessService({
+      stateDir,
+      cliPaths: {
+        claude: '/bin/sh',
+        codex: '/bin/sh',
+        gemini: '/bin/sh',
+        forge: '/bin/sh',
+      },
+    });
+
+    const result = await service.cleanupProcesses();
+
+    expect(result).toEqual({
+      removed: 1,
+      message: 'Removed 1 processes',
+    });
+    expect(existsSync(processDir)).toBe(false);
+    expect(existsSync(cwdDir)).toBe(false);
+  });
+
   it('cleans up completed and failed process directories but preserves running ones', async () => {
     const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
     tempDirs.push(root);