ai-cli-mcp 2.11.0 → 2.13.0

package/dist/__tests__/wait.test.js

@@ -78,6 +78,7 @@ describe('Wait Tool Tests', () => {
     });
     afterEach(() => {
         vi.clearAllMocks();
+        vi.useRealTimers();
     });
     const createMockProcess = (pid) => {
         const mockProcess = new EventEmitter();
@@ -185,6 +186,36 @@ describe('Wait Tool Tests', () => {
         expect(response.find((r) => r.pid === 101).status).toBe('completed');
         expect(response.find((r) => r.pid === 102).status).toBe('completed');
     });
+    it('should clear timeout timers after wait resolves', async () => {
+        vi.useFakeTimers();
+        const callToolHandler = handlers.get('callTool');
+        const mockProcess = createMockProcess(12348);
+        mockSpawn.mockReturnValue(mockProcess);
+        await callToolHandler({
+            params: {
+                name: 'run',
+                arguments: {
+                    prompt: 'test prompt',
+                    workFolder: '/tmp'
+                }
+            }
+        });
+        const waitPromise = callToolHandler({
+            params: {
+                name: 'wait',
+                arguments: {
+                    pids: [12348],
+                    timeout: 180
+                }
+            }
+        });
+        mockProcess.emit('close', 0);
+        await vi.runAllTicks();
+        const result = await waitPromise;
+        const response = JSON.parse(result.content[0].text);
+        expect(response[0].status).toBe('completed');
+        expect(vi.getTimerCount()).toBe(0);
+    });
     it('should throw error for non-existent PID', async () => {
         const callToolHandler = handlers.get('callTool');
         try {

package/dist/app/cli.js

@@ -0,0 +1,304 @@
+import { runMcpServer } from './mcp.js';
+import { CliProcessService } from '../cli-process-service.js';
+import { getCliDoctorStatus } from '../cli-utils.js';
+import { getModelsPayload } from '../model-catalog.js';
+export const CLI_HELP_TEXT = `Usage: ai-cli <command> [options]
+
+Commands:
+  run       Start an AI CLI process in the background
+  wait      Wait for one or more pids
+  ps        List tracked processes
+  result    Get the current result for a pid
+  kill      Terminate a tracked pid
+  cleanup   Remove completed and failed tracked processes
+  doctor    Check supported AI CLI binaries
+  models    List supported models and aliases
+  mcp       Start the MCP server
+  help      Show this help message
+`;
+export const RUN_HELP_TEXT = `Usage: ai-cli run --cwd <path> [options]
+
+Start an AI CLI process in the background.
+
+Options:
+  --cwd <path>                 Working directory
+  --prompt <text>              Prompt text
+  --prompt-file <path>         Path to a prompt file
+  --model <model>              Model name or alias (e.g. sonnet, claude-ultra, gpt-5.2-codex, codex-ultra, gemini-2.5-pro, gemini-ultra, forge)
+  --session-id <id>            Resume a previous session
+  --reasoning-effort <level>   Reasoning level for Claude/Codex only
+  --help, -h                   Show this help message
+
+Compatibility aliases:
+  --workFolder, --work-folder
+  --prompt_file
+  --session_id
+  --reasoning_effort
+`;
+export const WAIT_HELP_TEXT = `Usage: ai-cli wait <pid...> [options]
+
+Wait for one or more tracked processes to finish.
+
+Options:
+  --timeout <seconds>          Maximum wait time in seconds
+  --help, -h                   Show this help message
+`;
+export const RESULT_HELP_TEXT = `Usage: ai-cli result <pid> [options]
+
+Get the current result for a tracked process.
+
+Options:
+  --verbose                    Include verbose parsed output
+  --help, -h                   Show this help message
+`;
+export const KILL_HELP_TEXT = `Usage: ai-cli kill <pid>
+
+Terminate a tracked process.
+
+Options:
+  --help, -h                   Show this help message
+`;
+export const CLEANUP_HELP_TEXT = `Usage: ai-cli cleanup
+
+Remove completed and failed tracked processes.
+
+Options:
+  --help, -h                   Show this help message
+`;
+export const PS_HELP_TEXT = `Usage: ai-cli ps
+
+List tracked processes.
+
+Options:
+  --help, -h                   Show this help message
+`;
+export const MODELS_HELP_TEXT = `Usage: ai-cli models
+
+List supported models and aliases.
+
+Options:
+  --help, -h                   Show this help message
+`;
+export const DOCTOR_HELP_TEXT = `Usage: ai-cli doctor
+
+Check whether supported AI CLI binaries are available.
+
+Options:
+  --help, -h                   Show this help message
+`;
+export const MCP_HELP_TEXT = `Usage: ai-cli mcp
+
+Start the MCP server.
+`;
+let cliProcessService = null;
+function getCliProcessService() {
+    if (!cliProcessService) {
+        cliProcessService = new CliProcessService();
+    }
+    return cliProcessService;
+}
+const defaultDeps = {
+    stdout: (text) => process.stdout.write(text),
+    stderr: (text) => process.stderr.write(text),
+    startMcpServer: () => runMcpServer(),
+    runProcess: (options) => getCliProcessService().startProcess(options),
+    listProcesses: () => getCliProcessService().listProcesses(),
+    getProcessResult: (pid, verbose) => getCliProcessService().getProcessResult(pid, verbose),
+    waitForProcesses: (pids, timeoutSeconds) => getCliProcessService().waitForProcesses(pids, timeoutSeconds),
+    killProcess: (pid) => getCliProcessService().killProcess(pid),
+    cleanupProcesses: () => getCliProcessService().cleanupProcesses(),
+    getDoctorStatus: () => getCliDoctorStatus(),
+};
+function parseArgs(argv) {
+    const positionals = [];
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '-h') {
+            flags.h = '';
+            continue;
+        }
+        if (!arg.startsWith('--')) {
+            positionals.push(arg);
+            continue;
+        }
+        const eqIdx = arg.indexOf('=');
+        if (eqIdx !== -1) {
+            flags[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+            continue;
+        }
+        const next = argv[i + 1];
+        if (next !== undefined && !next.startsWith('--')) {
+            flags[arg.slice(2)] = next;
+            i++;
+        }
+        else {
+            flags[arg.slice(2)] = '';
+        }
+    }
+    return { positionals, flags };
+}
+function getFirstFlag(flags, names) {
+    for (const name of names) {
+        if (name in flags) {
+            return flags[name];
+        }
+    }
+    return undefined;
+}
+function parsePositivePid(value) {
+    const pid = Number(value);
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return null;
+    }
+    return pid;
+}
+function writeJson(stdout, value) {
+    stdout(`${JSON.stringify(value, null, 2)}\n`);
+}
+function hasHelpFlag(flags) {
+    return 'help' in flags || 'h' in flags;
+}
+export async function runCli(argv, deps = {}) {
+    const { stdout, stderr, startMcpServer, runProcess, listProcesses, getProcessResult, waitForProcesses, killProcess, cleanupProcesses, getDoctorStatus, } = { ...defaultDeps, ...deps };
+    const [command] = argv;
+    if (!command || command === 'help' || command === '--help' || command === '-h') {
+        stdout(CLI_HELP_TEXT);
+        return 0;
+    }
+    if (command === 'mcp') {
+        const { flags } = parseArgs(argv.slice(1));
+        if (hasHelpFlag(flags)) {
+            stdout(MCP_HELP_TEXT);
+            return 0;
+        }
+        await startMcpServer();
+        return 0;
+    }
+    if (command === 'run') {
+        const { flags } = parseArgs(argv.slice(1));
+        if (hasHelpFlag(flags)) {
+            stdout(RUN_HELP_TEXT);
+            return 0;
+        }
+        const cwd = getFirstFlag(flags, ['cwd', 'workFolder', 'work-folder']);
+        if (!cwd) {
+            stderr('Missing required option: --cwd\n');
+            stdout(CLI_HELP_TEXT);
+            return 1;
+        }
+        const prompt = getFirstFlag(flags, ['prompt']);
+        const promptFile = getFirstFlag(flags, ['prompt-file', 'prompt_file']);
+        if (!prompt && !promptFile) {
+            stderr('Missing required option: --prompt or --prompt-file\n');
+            stdout(CLI_HELP_TEXT);
+            return 1;
+        }
+        const result = await runProcess({
+            cwd,
+            prompt: prompt || undefined,
+            prompt_file: promptFile || undefined,
+            model: getFirstFlag(flags, ['model']) || undefined,
+            session_id: getFirstFlag(flags, ['session-id', 'session_id']) || undefined,
+            reasoning_effort: getFirstFlag(flags, ['reasoning-effort', 'reasoning_effort']) || undefined,
+        });
+        writeJson(stdout, result);
+        return 0;
+    }
+    if (command === 'ps') {
+        const { flags } = parseArgs(argv.slice(1));
+        if (hasHelpFlag(flags)) {
+            stdout(PS_HELP_TEXT);
+            return 0;
+        }
+        writeJson(stdout, await listProcesses());
+        return 0;
+    }
+    if (command === 'result') {
+        const { positionals, flags } = parseArgs(argv.slice(1));
+        if (hasHelpFlag(flags)) {
+            stdout(RESULT_HELP_TEXT);
+            return 0;
+        }
+        const pid = parsePositivePid(positionals[0]);
+        if (pid === null) {
+            stderr('Missing required pid argument\n');
+            stdout(CLI_HELP_TEXT);
+            return 1;
+        }
+        writeJson(stdout, await getProcessResult(pid, 'verbose' in flags));
+        return 0;
+    }
+    if (command === 'wait') {
+        const { positionals, flags } = parseArgs(argv.slice(1));
+        if (hasHelpFlag(flags)) {
+            stdout(WAIT_HELP_TEXT);
+            return 0;
+        }
+        const pids = positionals.map((value) => parsePositivePid(value));
+        if (pids.length === 0) {
+            stderr('Missing required pid arguments\n');
+            stdout(CLI_HELP_TEXT);
+            return 1;
+        }
+        if (pids.some((pid) => pid === null)) {
+            stderr('All pid arguments must be positive integers\n');
+            stdout(CLI_HELP_TEXT);
+            return 1;
+        }
+        const timeoutRaw = getFirstFlag(flags, ['timeout']);
+        const timeout = timeoutRaw ? Number(timeoutRaw) : undefined;
+        if (timeout !== undefined && (!Number.isFinite(timeout) || timeout <= 0)) {
+            stderr('Invalid --timeout value\n');
+            stdout(CLI_HELP_TEXT);
+            return 1;
+        }
+        writeJson(stdout, await waitForProcesses(pids, timeout));
+        return 0;
+    }
+    if (command === 'kill') {
+        const { positionals, flags } = parseArgs(argv.slice(1));
+        if (hasHelpFlag(flags)) {
+            stdout(KILL_HELP_TEXT);
+            return 0;
+        }
+        const pid = parsePositivePid(positionals[0]);
+        if (pid === null) {
+            stderr('Missing required pid argument\n');
+            stdout(CLI_HELP_TEXT);
+            return 1;
+        }
+        writeJson(stdout, await killProcess(pid));
+        return 0;
+    }
+    if (command === 'cleanup') {
+        const { flags } = parseArgs(argv.slice(1));
+        if (hasHelpFlag(flags)) {
+            stdout(CLEANUP_HELP_TEXT);
+            return 0;
+        }
+        writeJson(stdout, await cleanupProcesses());
+        return 0;
+    }
+    if (command === 'models') {
+        const { flags } = parseArgs(argv.slice(1));
+        if (hasHelpFlag(flags)) {
+            stdout(MODELS_HELP_TEXT);
+            return 0;
+        }
+        writeJson(stdout, getModelsPayload());
+        return 0;
+    }
+    if (command === 'doctor') {
+        const { flags } = parseArgs(argv.slice(1));
+        if (hasHelpFlag(flags)) {
+            stdout(DOCTOR_HELP_TEXT);
+            return 0;
+        }
+        writeJson(stdout, getDoctorStatus());
+        return 0;
+    }
+    stderr(`Unknown subcommand: ${command}\n`);
+    stdout(CLI_HELP_TEXT);
+    return 1;
+}