ai-cli-mcp 2.18.0 → 2.20.0

package/dist/cli-process-service.js

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { appendFileSync, chmodSync, closeSync, existsSync, mkdirSync, openSync, readSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
 import { join, basename, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { buildCliCommand } from './cli-builder.js';
@@ -7,6 +7,7 @@ import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli, findOpencodeC
 import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput, PeekEventExtractor } from './parsers.js';
 import { buildProcessResult } from './process-result.js';
 import { appendPeekEvents, buildNotFoundPeekProcess, observedDurationSec, validatePeekPids, validatePeekTimeSec, } from './peek.js';
+const SIGTERM_EXIT_CODE = 143;
 function resolveDefaultStateDir() {
     return process.env.AI_CLI_STATE_DIR || join(homedir(), '.local', 'state', 'ai-cli');
 }
@@ -73,65 +74,7 @@ export class CliProcessService {
             reasoning_effort: options.reasoning_effort,
             cliPaths: this.cliPaths,
         });
-        if (cmd.agent === 'opencode') {
-            return this.startDetachedOpenCodeProcess(cmd, options.model);
-        }
-        const stdoutPath = this.resolveStdoutPathForPidPlaceholder();
-        const stderrPath = this.resolveStderrPathForPidPlaceholder();
-        let stdoutFd;
-        let stderrFd;
-        try {
-            stdoutFd = openSync(stdoutPath, 'w');
-            stderrFd = openSync(stderrPath, 'w');
-            const childProcess = spawn(cmd.cliPath, cmd.args, {
-                cwd: cmd.cwd,
-                detached: true,
-                stdio: ['ignore', stdoutFd, stderrFd],
-            });
-            const pid = childProcess.pid;
-            childProcess.unref();
-            if (!pid) {
-                throw new Error(`Failed to start ${cmd.agent} CLI process`);
-            }
-            const processDir = this.resolveProcessDir(cmd.cwd, pid);
-            mkdirSync(processDir, { recursive: true });
-            const finalStdoutPath = this.resolveStdoutPath(processDir);
-            const finalStderrPath = this.resolveStderrPath(processDir);
-            this.renamePlaceholderFile(stdoutPath, finalStdoutPath);
-            this.renamePlaceholderFile(stderrPath, finalStderrPath);
-            const storedProcess = {
-                pid,
-                prompt: cmd.prompt,
-                workFolder: cmd.cwd,
-                cwdKey: this.resolveCwdKey(cmd.cwd),
-                model: options.model,
-                toolType: cmd.agent,
-                startTime: new Date().toISOString(),
-                stdoutPath: finalStdoutPath,
-                stderrPath: finalStderrPath,
-                status: 'running',
-            };
-            this.writeProcess(storedProcess);
-            return {
-                pid,
-                status: 'started',
-                agent: cmd.agent,
-                message: `${cmd.agent} process started successfully`,
-            };
-        }
-        catch (error) {
-            this.removeFileIfExists(stdoutPath);
-            this.removeFileIfExists(stderrPath);
-            throw error;
-        }
-        finally {
-            if (stdoutFd !== undefined) {
-                closeSync(stdoutFd);
-            }
-            if (stderrFd !== undefined) {
-                closeSync(stderrFd);
-            }
-        }
+        return this.startDetachedTrackedProcess(cmd, options.model);
     }
     async listProcesses() {
         return this.readAllProcesses().map((process) => ({
@@ -201,8 +144,8 @@ export class CliProcessService {
             observers.push({
                 process,
                 result,
-                stdoutExtractor: new PeekEventExtractor(process.toolType, { includeToolCalls }),
-                stderrExtractor: new PeekEventExtractor(process.toolType, { includeToolCalls }),
+                stdoutExtractor: new PeekEventExtractor(process.toolType, { includeToolCalls, source: 'stdout' }),
+                stderrExtractor: new PeekEventExtractor(process.toolType, { includeToolCalls, source: 'stderr' }),
                 stdoutOffset: this.fileSizeSafe(process.stdoutPath),
                 stderrOffset: this.fileSizeSafe(process.stderrPath),
             });
@@ -239,8 +182,9 @@ export class CliProcessService {
         for (const observer of observers) {
             observer.process = this.refreshStatus(this.readProcess(observer.process.pid));
             observer.result.status = observer.process.status;
-            appendPeekEvents(observer.result, observer.stdoutExtractor.flush(flushTs));
-            appendPeekEvents(observer.result, observer.stderrExtractor.flush(flushTs));
+            const terminal = observer.process.status !== 'running';
+            appendPeekEvents(observer.result, observer.stdoutExtractor.flush(flushTs, { terminal }));
+            appendPeekEvents(observer.result, observer.stderrExtractor.flush(flushTs, { terminal }));
         }
         return {
             peek_started_at: startedAt.toISOString(),
@@ -267,7 +211,16 @@ export class CliProcessService {
                 message: 'Signal sent but process is still running',
             };
         }
-        refreshed.status = 'failed';
+        const exitStatus = this.readExitStatus(refreshed);
+        if (exitStatus) {
+            refreshed.status = exitStatus.status;
+            refreshed.exitCode = exitStatus.exitCode;
+        }
+        else {
+            refreshed.status = 'failed';
+            refreshed.exitCode = SIGTERM_EXIT_CODE;
+            this.writeExitStatus(refreshed, { status: 'failed', exitCode: SIGTERM_EXIT_CODE });
+        }
         this.writeProcess(refreshed);
         return {
             pid,
@@ -294,9 +247,9 @@ export class CliProcessService {
             message: `Removed ${removed} processes`,
         };
     }
-    async startDetachedOpenCodeProcess(cmd, model) {
+    async startDetachedTrackedProcess(cmd, model) {
         const cwdKey = this.resolveCwdKey(cmd.cwd);
-        const wrapperPath = this.ensureOpenCodeWrapperScript();
+        const wrapperPath = this.ensureDetachedWrapperScript();
         const childProcess = spawn(wrapperPath, [this.stateDir, cwdKey, cmd.cliPath, ...cmd.args], {
             cwd: cmd.cwd,
             detached: true,
@@ -311,12 +264,8 @@ export class CliProcessService {
         mkdirSync(processDir, { recursive: true });
         const stdoutPath = this.resolveStdoutPath(processDir);
         const stderrPath = this.resolveStderrPath(processDir);
-        if (!existsSync(stdoutPath)) {
-            writeFileSync(stdoutPath, '');
-        }
-        if (!existsSync(stderrPath)) {
-            writeFileSync(stderrPath, '');
-        }
+        this.touchFile(stdoutPath);
+        this.touchFile(stderrPath);
         const storedProcess = {
             pid,
             prompt: cmd.prompt,
@@ -385,15 +334,13 @@ export class CliProcessService {
             return process;
         }
         if (!isProcessRunning(process.pid)) {
-            process.status = 'completed';
+            process.status = 'failed';
+            this.appendTextFileSafe(process.stderrPath, '\nProcess exited without exit-status metadata; marking as failed.\n');
             this.writeProcess(process);
         }
         return process;
     }
     readExitStatus(process) {
-        if (process.toolType !== 'opencode') {
-            return null;
-        }
         const exitMetaPath = this.resolveExitStatusPath(this.resolveStoredProcessDir(process));
         if (!existsSync(exitMetaPath)) {
             return null;
@@ -409,12 +356,28 @@ export class CliProcessService {
         }
         return null;
     }
+    writeExitStatus(process, exitStatus) {
+        const exitStatusPath = this.resolveExitStatusPath(this.resolveStoredProcessDir(process));
+        const tempPath = `${exitStatusPath}.${process.pid}.${Date.now()}.tmp`;
+        writeFileSync(tempPath, JSON.stringify(exitStatus, null, 2) + '\n');
+        renameSync(tempPath, exitStatusPath);
+    }
     readTextFileSafe(filePath) {
         if (!existsSync(filePath)) {
             return '';
         }
         return readFileSync(filePath, 'utf-8');
     }
+    touchFile(filePath) {
+        closeSync(openSync(filePath, 'a'));
+    }
+    appendTextFileSafe(filePath, text) {
+        try {
+            appendFileSync(filePath, text);
+        }
+        catch {
+        }
+    }
     fileSizeSafe(filePath) {
         if (!existsSync(filePath)) {
             return 0;
@@ -470,17 +433,12 @@ export class CliProcessService {
     resolveExitStatusPath(processDir) {
         return join(processDir, 'exit-status.json');
     }
-    resolveOpenCodeWrapperPath() {
-        return join(this.stateDir, 'opencode-detached-wrapper.sh');
-    }
-    resolveStdoutPathForPidPlaceholder() {
-        return join(this.stateDir, `pending-${Date.now()}-${Math.random().toString(36).slice(2)}.stdout.log`);
+    resolveDetachedWrapperPath() {
+        return join(this.stateDir, 'detached-runner-v2.sh');
     }
-    resolveStderrPathForPidPlaceholder() {
-        return join(this.stateDir, `pending-${Date.now()}-${Math.random().toString(36).slice(2)}.stderr.log`);
-    }
-    ensureOpenCodeWrapperScript() {
-        const wrapperPath = this.resolveOpenCodeWrapperPath();
+    ensureDetachedWrapperScript() {
+        const wrapperPath = this.resolveDetachedWrapperPath();
+        this.removeLegacyDetachedWrappers();
         if (existsSync(wrapperPath)) {
             return wrapperPath;
         }
@@ -497,24 +455,52 @@ exit_meta_path="$process_dir/exit-status.json"
 mkdir -p "$process_dir"
 : > "$stdout_path"
 : > "$stderr_path"
-"$@" >> "$stdout_path" 2>> "$stderr_path"
+write_exit_status() {
+  status="$1"
+  exit_code="$2"
+  tmp_exit_meta_path="$exit_meta_path.$$"
+  printf '{\n  "status": "%s",\n  "exitCode": %s\n}\n' "$status" "$exit_code" > "$tmp_exit_meta_path"
+  mv "$tmp_exit_meta_path" "$exit_meta_path"
+}
+handle_signal() {
+  signal="$1"
+  exit_code="$2"
+  if [ -n "\${child_pid:-}" ]; then
+    kill "-$signal" "$child_pid" 2>/dev/null || true
+    wait "$child_pid" 2>/dev/null
+  fi
+  write_exit_status "failed" "$exit_code"
+  exit "$exit_code"
+}
+trap 'handle_signal TERM 143' TERM
+trap 'handle_signal INT 130' INT
+trap 'handle_signal HUP 129' HUP
+"$@" >> "$stdout_path" 2>> "$stderr_path" &
+child_pid="$!"
+wait "$child_pid"
 exit_code="$?"
+trap - TERM INT HUP
 status="completed"
 if [ "$exit_code" -ne 0 ]; then
   status="failed"
 fi
-printf '{\n  "status": "%s",\n  "exitCode": %s\n}\n' "$status" "$exit_code" > "$exit_meta_path"
+write_exit_status "$status" "$exit_code"
 exit "$exit_code"
 `);
         chmodSync(wrapperPath, 0o755);
         return wrapperPath;
     }
-    renamePlaceholderFile(fromPath, toPath) {
-        renameSync(fromPath, toPath);
-    }
-    removeFileIfExists(filePath) {
-        if (existsSync(filePath)) {
-            unlinkSync(filePath);
+    removeLegacyDetachedWrappers() {
+        for (const fileName of ['detached-runner-v1.sh']) {
+            const legacyPath = join(this.stateDir, fileName);
+            if (!existsSync(legacyPath)) {
+                continue;
+            }
+            try {
+                rmSync(legacyPath, { force: true });
+            }
+            catch {
+            }
         }
     }
     killPidOrGroup(pid, signal) {

package/dist/cli-utils.js

@@ -153,6 +153,12 @@ function getCliBinaryStatus(name) {
 }
 export function getCliDoctorStatus() {
     return {
+        checks: {
+            binaryAvailability: true,
+            pathResolution: true,
+            loginState: false,
+            termsAcceptance: false,
+        },
         claude: getCliBinaryStatus('claude'),
         codex: getCliBinaryStatus('codex'),
         gemini: getCliBinaryStatus('gemini'),

package/dist/cli.js

@@ -40,7 +40,7 @@ Options:
   --prompt             Prompt string (mutually exclusive with --prompt_file)
   --prompt_file        Path to a file containing the prompt
   --session_id         Session ID to resume, including OpenCode in-place resumes
-  --reasoning_effort   Claude/Codex only: Claude=low|medium|high, Codex=low|medium|high|xhigh; unsupported for Gemini, Forge, and OpenCode
+  --reasoning_effort   Claude/Codex only: Claude=low|medium|high|xhigh|max, Codex=low|medium|high|xhigh; unsupported for Gemini, Forge, and OpenCode
   --help               Show this help message
 
 Raw CLI output goes to stdout. Use cli.run.parse to parse the output:

package/dist/model-catalog.js

@@ -1,5 +1,6 @@
 export const CLAUDE_MODELS = ['sonnet', 'sonnet[1m]', 'opus', 'opusplan', 'haiku'];
 export const CODEX_MODELS = [
+    'codex',
     'gpt-5.4',
     'gpt-5.3-codex',
     'gpt-5.2-codex',
@@ -27,7 +28,7 @@ export const MODEL_ALIASES = {
     'gemini-ultra': 'gemini-3.1-pro-preview',
 };
 export const MODEL_ALIAS_DETAILS = [
-    { name: 'claude-ultra', resolvesTo: 'opus', agent: 'claude', defaultReasoningEffort: 'high' },
+    { name: 'claude-ultra', resolvesTo: 'opus', agent: 'claude', defaultReasoningEffort: 'max' },
     { name: 'codex-ultra', resolvesTo: 'gpt-5.4', agent: 'codex', defaultReasoningEffort: 'xhigh' },
     { name: 'gemini-ultra', resolvesTo: 'gemini-3.1-pro-preview', agent: 'gemini' },
 ];
@@ -43,7 +44,7 @@ export function getSupportedModelsDescription() {
     ].join(', ');
 }
 export function getModelParameterDescription() {
-    return `The model to use. Aliases: "claude-ultra" (auto high effort), "codex-ultra" (auto xhigh reasoning), "gemini-ultra". Standard: ${[...CLAUDE_MODELS, ...CODEX_MODELS, ...GEMINI_MODELS, ...FORGE_MODELS, ...OPENCODE_MODELS].map((model) => `"${model}"`).join(', ')}. OpenCode also accepts explicit dynamic models using "oc-<provider/model>". "forge" is a provider key, not a Forge model family selector.`;
+    return `The model to use. Aliases: "claude-ultra" (auto max effort), "codex-ultra" (auto xhigh reasoning), "gemini-ultra". Standard: ${[...CLAUDE_MODELS, ...CODEX_MODELS, ...GEMINI_MODELS, ...FORGE_MODELS, ...OPENCODE_MODELS].map((model) => `"${model}"`).join(', ')}. OpenCode also accepts explicit dynamic models using "oc-<provider/model>". "forge" is a provider key, not a Forge model family selector.`;
 }
 export function getModelsPayload() {
     return {

package/dist/parsers.js

@@ -1,5 +1,7 @@
 import { debugLog } from './cli-utils.js';
 const PEEK_TOOL_SUMMARY_MAX_LENGTH = 200;
+const FORGE_EXECUTE_PATTERN = /^● \[[^\]]+\] Execute \[([^\]]*)\]\s+(.+)$/;
+const FORGE_FINISHED_PATTERN = /^● \[[^\]]+\] Finished(?:\s+\S+)?\s*$/;
 function isGeminiAssistantMessageEvent(parsed) {
     return parsed.type === 'message' && parsed.role === 'assistant' && typeof parsed.content === 'string';
 }
@@ -253,12 +255,19 @@ export class PeekEventExtractor {
     pending = '';
     geminiAssistantBuffer = '';
     includeToolCalls;
+    source;
     toolMemory = new Map();
+    forgePendingTool = null;
+    forgeToolSequence = 0;
     constructor(agent, options = {}) {
         this.agent = agent;
         this.includeToolCalls = options.includeToolCalls === true;
+        this.source = options.source || 'stdout';
     }
     push(chunk, observedAt = new Date().toISOString()) {
+        if (this.agent === 'forge' && this.source === 'stderr') {
+            return [];
+        }
         if (!chunk) {
             return [];
         }
@@ -266,17 +275,27 @@ export class PeekEventExtractor {
         this.pending = lines.pop() || '';
         return this.extractLines(lines, observedAt);
     }
-    flush(observedAt = new Date().toISOString()) {
+    flush(observedAt = new Date().toISOString(), options = {}) {
+        if (this.agent === 'forge' && this.source === 'stderr') {
+            this.pending = '';
+            return [];
+        }
         const events = [];
         if (this.pending) {
-            const line = this.pending;
-            this.pending = '';
-            events.push(...this.extractLines([line], observedAt));
+            if (this.agent !== 'forge' || options.terminal === true) {
+                const line = this.pending;
+                this.pending = '';
+                events.push(...this.extractLines([line], observedAt));
+            }
         }
         events.push(...this.flushGeminiAssistantBuffer(observedAt));
+        events.push(...this.flushForgePendingTool(observedAt, options.terminal === true));
         return events;
     }
     extractLines(lines, observedAt) {
+        if (this.agent === 'forge') {
+            return this.extractForgeLines(lines, observedAt);
+        }
         const events = [];
         for (const line of lines) {
             if (!line.trim()) {
@@ -292,6 +311,58 @@ export class PeekEventExtractor {
         }
         return events;
     }
+    extractForgeLines(lines, observedAt) {
+        const events = [];
+        for (const line of lines) {
+            if (!line.trim()) {
+                continue;
+            }
+            const summary = this.extractForgeMessage(line, 'Summary:');
+            if (summary !== null) {
+                events.push({ kind: 'message', ts: observedAt, text: summary });
+                continue;
+            }
+            const completed = this.extractForgeMessage(line, 'Completed successfully:');
+            if (completed !== null) {
+                events.push({ kind: 'message', ts: observedAt, text: completed });
+                continue;
+            }
+            if (this.includeToolCalls) {
+                const executeMatch = line.match(FORGE_EXECUTE_PATTERN);
+                if (executeMatch) {
+                    events.push(...this.completeForgePendingTool(observedAt));
+                    const [, rawTool, rawSummary] = executeMatch;
+                    const tool = rawTool.trim() && !/\s/.test(rawTool.trim()) ? rawTool.trim() : 'shell';
+                    const event = createToolCallEvent({
+                        ts: observedAt,
+                        phase: 'started',
+                        id: `forge_${this.forgeToolSequence++}`,
+                        tool,
+                        command: rawSummary,
+                    });
+                    this.forgePendingTool = {
+                        id: event.id,
+                        tool: event.tool,
+                        summary: event.summary,
+                        summary_truncated: event.summary_truncated,
+                    };
+                    events.push(event);
+                    continue;
+                }
+                if (FORGE_FINISHED_PATTERN.test(line)) {
+                    events.push(...this.completeForgePendingTool(observedAt));
+                }
+            }
+        }
+        return events;
+    }
+    extractForgeMessage(line, prefix) {
+        if (!line.startsWith(prefix)) {
+            return null;
+        }
+        const text = line.slice(prefix.length).trim();
+        return text || null;
+    }
     extractParsedEvent(parsed, observedAt) {
         if (this.agent === 'gemini') {
             const events = this.extractGeminiParsedEvent(parsed, observedAt);
@@ -339,6 +410,32 @@ export class PeekEventExtractor {
         }
         return [{ kind: 'message', ts: observedAt, text }];
     }
+    completeForgePendingTool(observedAt) {
+        if (!this.forgePendingTool) {
+            return [];
+        }
+        const pending = this.forgePendingTool;
+        this.forgePendingTool = null;
+        const event = createToolCallEvent({
+            ts: observedAt,
+            phase: 'completed',
+            id: pending.id,
+            tool: pending.tool,
+            status: 'unknown',
+            defaultStatus: 'unknown',
+        });
+        event.summary = pending.summary;
+        if (pending.summary_truncated) {
+            event.summary_truncated = true;
+        }
+        return [event];
+    }
+    flushForgePendingTool(observedAt, terminal) {
+        if (this.agent !== 'forge' || !terminal) {
+            return [];
+        }
+        return this.completeForgePendingTool(observedAt);
+    }
 }
 export class PeekMessageExtractor {
     extractor;
@@ -348,8 +445,8 @@ export class PeekMessageExtractor {
     push(chunk, observedAt = new Date().toISOString()) {
         return this.toMessages(this.extractor.push(chunk, observedAt));
     }
-    flush(observedAt = new Date().toISOString()) {
-        return this.toMessages(this.extractor.flush(observedAt));
+    flush(observedAt = new Date().toISOString(), options = {}) {
+        return this.toMessages(this.extractor.flush(observedAt, options));
     }
     toMessages(events) {
         return events
@@ -431,6 +528,7 @@ export function parseClaudeOutput(stdout) {
     try {
         const lines = stdout.trim().split('\n');
         let lastMessage = null;
+        let assistantTextBuffer = '';
         let sessionId = null;
         const toolsMap = new Map();
         for (const line of lines) {
@@ -446,6 +544,9 @@ export function parseClaudeOutput(stdout) {
                 }
                 if (parsed.type === 'assistant' && parsed.message?.content) {
                     for (const content of parsed.message.content) {
+                        if (content.type === 'text' && typeof content.text === 'string') {
+                            assistantTextBuffer += content.text;
+                        }
                         if (content.type === 'tool_use') {
                             toolsMap.set(content.id, {
                                 tool: content.name,
@@ -477,9 +578,11 @@ export function parseClaudeOutput(stdout) {
             }
         }
         const tools = Array.from(toolsMap.values());
-        if (lastMessage || sessionId || tools.length > 0) {
+        const fallbackMessage = assistantTextBuffer.trim() ? assistantTextBuffer : null;
+        const message = lastMessage || fallbackMessage;
+        if (message || sessionId || tools.length > 0) {
             return {
-                message: lastMessage,
+                message,
                 session_id: sessionId,
                 tools: tools.length > 0 ? tools : undefined
             };

package/dist/process-service.js

@@ -176,8 +176,8 @@ export class ProcessService {
                 error: null,
             };
             processes.push(result);
-            const stdoutExtractor = new PeekEventExtractor(entry.toolType, { includeToolCalls });
-            const stderrExtractor = new PeekEventExtractor(entry.toolType, { includeToolCalls });
+            const stdoutExtractor = new PeekEventExtractor(entry.toolType, { includeToolCalls, source: 'stdout' });
+            const stderrExtractor = new PeekEventExtractor(entry.toolType, { includeToolCalls, source: 'stderr' });
             const onStdout = (data) => {
                 appendPeekEvents(result, stdoutExtractor.push(data.toString(), new Date().toISOString()));
             };
@@ -210,8 +210,9 @@ export class ProcessService {
             for (const observer of observers) {
                 observer.entry.process.stdout?.off('data', observer.onStdout);
                 observer.entry.process.stderr?.off('data', observer.onStderr);
-                appendPeekEvents(observer.result, observer.stdoutExtractor.flush(flushTs));
-                appendPeekEvents(observer.result, observer.stderrExtractor.flush(flushTs));
+                const terminal = observer.entry.status !== 'running';
+                appendPeekEvents(observer.result, observer.stdoutExtractor.flush(flushTs, { terminal }));
+                appendPeekEvents(observer.result, observer.stderrExtractor.flush(flushTs, { terminal }));
                 observer.result.status = observer.entry.status;
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-cli-mcp",
-  "version": "2.18.0",
+  "version": "2.20.0",
   "mcpName": "io.github.mkXultra/ai-cli-mcp",
   "description": "MCP server for AI CLI tools (Claude, Codex, Gemini, Forge, and OpenCode) with background process management",
   "author": "mkXultra",
@@ -10,14 +10,38 @@
     "ai-cli": "dist/bin/ai-cli.js",
     "ai-cli-mcp": "dist/bin/ai-cli-mcp.js"
   },
+  "files": [
+    "dist/app",
+    "dist/bin",
+    "dist/cli-builder.js",
+    "dist/cli-parse.js",
+    "dist/cli-process-service.js",
+    "dist/cli-utils.js",
+    "dist/cli.js",
+    "dist/model-catalog.js",
+    "dist/parsers.js",
+    "dist/peek.js",
+    "dist/process-result.js",
+    "dist/process-service.js",
+    "dist/server.js",
+    "server.json",
+    "README.ja.md",
+    "CHANGELOG.md"
+  ],
   "scripts": {
     "build": "tsc",
     "start": "node dist/server.js",
     "dev": "tsx src/server.ts",
-    "test": "npm run build && vitest run",
+    "test": "npm run build && npm run test:run",
+    "test:run": "vitest run",
     "test:unit": "vitest run --config vitest.config.unit.ts",
     "test:e2e": "npm run build && vitest run --config vitest.config.e2e.ts",
     "test:e2e:local": "npm run build && vitest run --config vitest.config.e2e.ts",
+    "test:live": "npm run build && npm run test:live:run",
+    "test:live:run": "vitest run --config vitest.config.live.ts",
+    "test:package": "npm run build && npm run test:package:run",
+    "test:package:run": "vitest run --config vitest.config.package.ts",
+    "test:release": "npm run build && npm run test:run && npm run test:live:run && npm run test:package:run",
     "test:coverage": "npm run build && vitest --coverage --config vitest.config.unit.ts",
     "test:watch": "vitest --watch",
     "cli.run": "tsx src/cli.ts",

package/server.json

@@ -1,17 +1,17 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.mkXultra/ai-cli-mcp",
-  "description": "MCP server for AI CLI tools (Claude, Codex, Gemini, and Forge) with background process management",
+  "description": "MCP server for AI CLI tools (Claude, Codex, Gemini, Forge, and OpenCode) with background process management",
   "repository": {
     "url": "https://github.com/mkXultra/ai-cli-mcp",
     "source": "github"
   },
-  "version": "2.8.2",
+  "version": "2.20.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "ai-cli-mcp",
-      "version": "2.8.2",
+      "version": "2.20.0",
       "transport": {
         "type": "stdio"
       }

package/.gemini/settings.json

@@ -1,11 +0,0 @@
-{
-  "mcpServers": {
-    "acm-dev": {
-      "command": "npm",
-      "args": [
-        "run",
-        "dev"
-      ]
-    }
-  }
-}

package/.github/dependabot.yml

@@ -1,28 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "npm"
-    directory: "/"
-    target-branch: "develop"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 5
-    groups:
-      npm-production:
-        dependency-type: "production"
-        patterns:
-          - "*"
-      npm-development:
-        dependency-type: "development"
-        patterns:
-          - "*"
-
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    target-branch: "develop"
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 2
-    groups:
-      github-actions:
-        patterns:
-          - "*"