ai-cli-mcp 2.14.1 → 2.16.0

package/dist/model-catalog.js

@@ -20,6 +20,7 @@ export const GEMINI_MODELS = [
     'gemini-3-flash-preview',
 ];
 export const FORGE_MODELS = ['forge'];
+export const OPENCODE_MODELS = ['opencode'];
 export const MODEL_ALIASES = {
     'claude-ultra': 'opus',
     'codex-ultra': 'gpt-5.4',
@@ -37,10 +38,12 @@ export function getSupportedModelsDescription() {
         ...CODEX_MODELS.map((model) => `"${model}"`),
         ...GEMINI_MODELS.map((model) => `"${model}"`),
         ...FORGE_MODELS.map((model) => `"${model}"`),
+        ...OPENCODE_MODELS.map((model) => `"${model}"`),
+        '"oc-<provider/model>"',
     ].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].map((model) => `"${model}"`).join(', ')}. "forge" is a provider key, not a Forge model family selector.`;
+    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.`;
 }
 export function getModelsPayload() {
     return {
@@ -49,5 +52,14 @@ export function getModelsPayload() {
         codex: CODEX_MODELS,
         gemini: GEMINI_MODELS,
         forge: FORGE_MODELS,
+        opencode: OPENCODE_MODELS,
+        dynamicModelBackends: {
+            opencode: {
+                explicitPrefix: 'oc-',
+                explicitPattern: 'oc-<provider/model>',
+                discoveryCommand: 'opencode models',
+                modelsAreDynamic: true,
+            },
+        },
     };
 }

package/dist/parsers.js

@@ -1,7 +1,102 @@
 import { debugLog } from './cli-utils.js';
-/**
- * Parse Codex NDJSON output to extract the last agent message and token count
- */
+function isGeminiAssistantMessageEvent(parsed) {
+    return parsed.type === 'message' && parsed.role === 'assistant' && typeof parsed.content === 'string';
+}
+const GEMINI_STREAM_EVENT_TYPES = new Set([
+    'init',
+    'message',
+    'tool_use',
+    'tool_result',
+    'result',
+    'error',
+    'stats',
+]);
+function isGeminiStreamJsonEvent(parsed) {
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) && GEMINI_STREAM_EVENT_TYPES.has(parsed.type);
+}
+function extractPeekMessagesFromParsedEvent(agent, parsed, observedAt) {
+    if (agent === 'codex') {
+        if (parsed.item?.type === 'agent_message' && typeof parsed.item.text === 'string' && parsed.item.text.trim()) {
+            return [{ ts: observedAt, text: parsed.item.text }];
+        }
+        if (parsed.msg?.type === 'agent_message' && typeof parsed.msg.message === 'string' && parsed.msg.message.trim()) {
+            return [{ ts: observedAt, text: parsed.msg.message }];
+        }
+        return [];
+    }
+    if (agent === 'claude' && parsed.type === 'assistant' && Array.isArray(parsed.message?.content)) {
+        return parsed.message.content
+            .filter((content) => content?.type === 'text' && typeof content.text === 'string' && content.text.trim())
+            .map((content) => ({ ts: observedAt, text: content.text }));
+    }
+    if (agent === 'opencode' && parsed.type === 'text' && parsed.part?.type === 'text' && typeof parsed.part.text === 'string' && parsed.part.text.trim()) {
+        return [{ ts: observedAt, text: parsed.part.text }];
+    }
+    return [];
+}
+export class PeekMessageExtractor {
+    agent;
+    pending = '';
+    geminiAssistantBuffer = '';
+    constructor(agent) {
+        this.agent = agent;
+    }
+    push(chunk, observedAt = new Date().toISOString()) {
+        if (!chunk) {
+            return [];
+        }
+        const lines = `${this.pending}${chunk}`.split(/\r?\n/);
+        this.pending = lines.pop() || '';
+        return this.extractLines(lines, observedAt);
+    }
+    flush(observedAt = new Date().toISOString()) {
+        const messages = [];
+        if (this.pending) {
+            const line = this.pending;
+            this.pending = '';
+            messages.push(...this.extractLines([line], observedAt));
+        }
+        messages.push(...this.flushGeminiAssistantBuffer(observedAt));
+        return messages;
+    }
+    extractLines(lines, observedAt) {
+        const messages = [];
+        for (const line of lines) {
+            if (!line.trim()) {
+                continue;
+            }
+            try {
+                messages.push(...this.extractParsedEvent(JSON.parse(line), observedAt));
+            }
+            catch {
+                debugLog(`[Debug] Skipping invalid peek JSON line: ${line}`);
+                messages.push(...this.flushGeminiAssistantBuffer(observedAt));
+            }
+        }
+        return messages;
+    }
+    extractParsedEvent(parsed, observedAt) {
+        if (this.agent !== 'gemini') {
+            return extractPeekMessagesFromParsedEvent(this.agent, parsed, observedAt);
+        }
+        if (isGeminiAssistantMessageEvent(parsed)) {
+            this.geminiAssistantBuffer += parsed.content;
+            return [];
+        }
+        return this.flushGeminiAssistantBuffer(observedAt);
+    }
+    flushGeminiAssistantBuffer(observedAt) {
+        if (this.agent !== 'gemini' || !this.geminiAssistantBuffer) {
+            return [];
+        }
+        const text = this.geminiAssistantBuffer;
+        this.geminiAssistantBuffer = '';
+        if (!text.trim()) {
+            return [];
+        }
+        return [{ ts: observedAt, text }];
+    }
+}
 export function parseCodexOutput(stdout) {
     if (!stdout)
         return null;
@@ -25,7 +120,6 @@ export function parseCodexOutput(stdout) {
                         lastMessage = parsed.msg.message;
                     }
                     else if (parsed.item?.type === 'reasoning') {
-                        // Ignore reasoning-only items for message selection.
                     }
                     else if (parsed.msg?.type === 'token_count') {
                         tokenCount = parsed.msg;
@@ -34,7 +128,7 @@ export function parseCodexOutput(stdout) {
                         tools.push({
                             server: parsed.item.server,
                             tool: parsed.item.tool,
-                            input: parsed.item.arguments, // Map arguments to input to match common patterns
+                            input: parsed.item.arguments,
                             output: parsed.item.result
                         });
                     }
@@ -48,7 +142,6 @@ export function parseCodexOutput(stdout) {
                     }
                 }
                 catch (e) {
-                    // Skip invalid JSON lines
                     debugLog(`[Debug] Skipping invalid JSON line: ${line}`);
                 }
             }
@@ -67,56 +160,46 @@ export function parseCodexOutput(stdout) {
     }
     return null;
 }
-/**
- * Parse Claude Output (supports both JSON and stream-json/NDJSON)
- */
 export function parseClaudeOutput(stdout) {
     if (!stdout)
         return null;
-    // First try parsing as a single JSON object (backward compatibility)
     try {
         return JSON.parse(stdout);
     }
     catch (e) {
-        // If not valid single JSON, proceed to parse as NDJSON
     }
     try {
         const lines = stdout.trim().split('\n');
         let lastMessage = null;
         let sessionId = null;
-        const toolsMap = new Map(); // Map by tool_use id for matching results
+        const toolsMap = new Map();
         for (const line of lines) {
             if (!line.trim())
                 continue;
             try {
                 const parsed = JSON.parse(line);
-                // Extract session ID from any message that has it
                 if (parsed.session_id) {
                     sessionId = parsed.session_id;
                 }
-                // Extract final result message
                 if (parsed.type === 'result' && parsed.result) {
                     lastMessage = parsed.result;
                 }
-                // Extract tool usage from assistant messages
                 if (parsed.type === 'assistant' && parsed.message?.content) {
                     for (const content of parsed.message.content) {
                         if (content.type === 'tool_use') {
                             toolsMap.set(content.id, {
                                 tool: content.name,
                                 input: content.input,
-                                output: null // Will be filled when tool_result is found
+                                output: null
                             });
                         }
                     }
                 }
-                // Match tool results from user messages
                 if (parsed.type === 'user' && parsed.message?.content) {
                     for (const content of parsed.message.content) {
                         if (content.type === 'tool_result' && content.tool_use_id) {
                             const tool = toolsMap.get(content.tool_use_id);
                             if (tool) {
-                                // Extract text from content array
                                 if (Array.isArray(content.content)) {
                                     const textContent = content.content.find((c) => c.type === 'text');
                                     tool.output = textContent?.text || null;
@@ -133,11 +216,10 @@ export function parseClaudeOutput(stdout) {
                 debugLog(`[Debug] Skipping invalid JSON line in Claude output: ${line}`);
             }
         }
-        // Convert Map to array
         const tools = Array.from(toolsMap.values());
         if (lastMessage || sessionId || tools.length > 0) {
             return {
-                message: lastMessage, // This is the final result text
+                message: lastMessage,
                 session_id: sessionId,
                 tools: tools.length > 0 ? tools : undefined
             };
@@ -149,23 +231,102 @@ export function parseClaudeOutput(stdout) {
     }
     return null;
 }
-/**
- * Parse Gemini JSON output
- */
 export function parseGeminiOutput(stdout) {
     if (!stdout)
         return null;
     try {
-        return JSON.parse(stdout);
+        const parsed = JSON.parse(stdout.trim());
+        if (!isGeminiStreamJsonEvent(parsed)) {
+            return parsed;
+        }
     }
     catch (e) {
         debugLog(`[Debug] Failed to parse Gemini JSON output: ${e}`);
-        return null;
     }
+    let sessionId = null;
+    let assistantBuffer = '';
+    let lastMessage = null;
+    let stats = null;
+    const toolsById = new Map();
+    const toolsWithoutId = [];
+    const flushAssistantMessage = () => {
+        if (assistantBuffer.trim()) {
+            lastMessage = assistantBuffer;
+        }
+        assistantBuffer = '';
+    };
+    for (const line of stdout.split('\n')) {
+        if (!line.trim()) {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (e) {
+            debugLog(`[Debug] Skipping invalid Gemini stream-json line: ${line}`);
+            flushAssistantMessage();
+            continue;
+        }
+        if (parsed.type === 'init' && typeof parsed.session_id === 'string' && parsed.session_id) {
+            sessionId = parsed.session_id;
+            continue;
+        }
+        if (isGeminiAssistantMessageEvent(parsed)) {
+            assistantBuffer += parsed.content;
+            continue;
+        }
+        flushAssistantMessage();
+        if (parsed.type === 'result') {
+            if (parsed.stats) {
+                stats = parsed.stats;
+            }
+            continue;
+        }
+        if (parsed.type === 'tool_use') {
+            const tool = {
+                tool: parsed.tool_name || parsed.name || 'tool_use',
+                input: parsed.parameters ?? parsed.input ?? null,
+                output: null,
+                status: null,
+            };
+            if (typeof parsed.tool_id === 'string' && parsed.tool_id) {
+                toolsById.set(parsed.tool_id, tool);
+            }
+            else {
+                toolsWithoutId.push(tool);
+            }
+            continue;
+        }
+        if (parsed.type === 'tool_result') {
+            const toolId = typeof parsed.tool_id === 'string' ? parsed.tool_id : '';
+            const tool = toolId ? toolsById.get(toolId) : null;
+            if (tool) {
+                tool.output = parsed.output ?? parsed.result ?? null;
+                tool.status = parsed.status ?? null;
+            }
+            else {
+                toolsWithoutId.push({
+                    tool: 'tool_result',
+                    input: null,
+                    output: parsed.output ?? parsed.result ?? null,
+                    status: parsed.status ?? null,
+                });
+            }
+        }
+    }
+    flushAssistantMessage();
+    const tools = [...toolsById.values(), ...toolsWithoutId];
+    if (lastMessage || sessionId || stats || tools.length > 0) {
+        return {
+            message: lastMessage,
+            session_id: sessionId,
+            stats: stats || undefined,
+            tools: tools.length > 0 ? tools : undefined,
+        };
+    }
+    return null;
 }
-/**
- * Parse Forge output framed by Initialize/Continue/Finished markers.
- */
 export function parseForgeOutput(stdout) {
     if (!stdout)
         return null;
@@ -218,3 +379,56 @@ export function parseForgeOutput(stdout) {
         session_id: lastConversationId,
     };
 }
+export function parseOpenCodeOutput(stdout) {
+    if (!stdout) {
+        return null;
+    }
+    let sessionId = null;
+    let currentStepBuffer = '';
+    let latestCompletedStep = null;
+    let hasStepFinish = false;
+    let hasParseableAssistantText = false;
+    for (const line of stdout.split('\n')) {
+        if (!line.trim()) {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (typeof parsed.sessionID === 'string' && parsed.sessionID) {
+            sessionId = parsed.sessionID;
+        }
+        if (parsed.type === 'step_start') {
+            currentStepBuffer = '';
+            continue;
+        }
+        if (parsed.type === 'text' && parsed.part?.type === 'text' && typeof parsed.part.text === 'string') {
+            currentStepBuffer += parsed.part.text;
+            hasParseableAssistantText = true;
+            continue;
+        }
+        if (parsed.type === 'step_finish') {
+            hasStepFinish = true;
+            latestCompletedStep = {
+                message: currentStepBuffer,
+                session_id: sessionId || undefined,
+                tokens: parsed.part?.tokens,
+                cost: parsed.part?.cost,
+            };
+        }
+    }
+    if (hasStepFinish && latestCompletedStep) {
+        return latestCompletedStep;
+    }
+    if (hasParseableAssistantText) {
+        return {
+            message: currentStepBuffer,
+            session_id: sessionId || undefined,
+        };
+    }
+    return null;
+}

package/dist/peek.js

@@ -0,0 +1,56 @@
+export const DEFAULT_PEEK_TIME_SEC = 10;
+export const MAX_PEEK_TIME_SEC = 60;
+export const MAX_PEEK_PIDS = 32;
+export const PEEK_MESSAGE_CAP = 50;
+export function validatePeekPids(value) {
+    if (!Array.isArray(value)) {
+        throw new Error('Missing or invalid required parameter: pids (must be an array of positive safe integers)');
+    }
+    const deduped = [];
+    const seen = new Set();
+    for (const pid of value) {
+        if (typeof pid !== 'number' || !Number.isSafeInteger(pid) || pid <= 0) {
+            throw new Error('All pids must be positive safe integers');
+        }
+        if (!seen.has(pid)) {
+            seen.add(pid);
+            deduped.push(pid);
+        }
+    }
+    if (deduped.length === 0 || deduped.length > MAX_PEEK_PIDS) {
+        throw new Error(`pids must contain 1..${MAX_PEEK_PIDS} entries after dedupe`);
+    }
+    return deduped;
+}
+export function validatePeekTimeSec(value) {
+    if (value === undefined || value === null) {
+        return DEFAULT_PEEK_TIME_SEC;
+    }
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0 || value > MAX_PEEK_TIME_SEC) {
+        throw new Error(`peek_time_sec must be a positive integer no greater than ${MAX_PEEK_TIME_SEC}`);
+    }
+    return value;
+}
+export function buildNotFoundPeekProcess(pid) {
+    return {
+        pid,
+        agent: null,
+        status: 'not_found',
+        messages: [],
+        truncated: false,
+        error: 'process not found',
+    };
+}
+export function appendPeekMessages(target, messages) {
+    for (const message of messages) {
+        if (target.messages.length < PEEK_MESSAGE_CAP) {
+            target.messages.push(message);
+        }
+        else {
+            target.truncated = true;
+        }
+    }
+}
+export function observedDurationSec(startedAtMs, endedAtMs = Date.now()) {
+    return Number(((endedAtMs - startedAtMs) / 1000).toFixed(2));
+}

package/dist/process-result.js

@@ -23,6 +23,9 @@ function hasMeaningfulParsedOutput(agentOutput) {
         return true;
     });
 }
+function shouldPreserveRawFailureOutput(context) {
+    return context.agent === 'opencode' && context.status === 'failed';
+}
 export function buildProcessResult(context, agentOutput, verbose = false) {
     const response = {
         pid: context.pid,
@@ -40,12 +43,16 @@ export function buildProcessResult(context, agentOutput, verbose = false) {
         response.session_id = agentOutput.session_id;
     }
     const shapedAgentOutput = verbose ? agentOutput : compactAgentOutput(agentOutput);
-    if (hasMeaningfulParsedOutput(shapedAgentOutput)) {
+    const preserveRawFailureOutput = shouldPreserveRawFailureOutput(context);
+    if (hasMeaningfulParsedOutput(shapedAgentOutput) && (verbose || !preserveRawFailureOutput)) {
         response.agentOutput = shapedAgentOutput;
     }
-    if (!response.agentOutput) {
+    if (!response.agentOutput || preserveRawFailureOutput) {
         response.stdout = context.stdout;
         response.stderr = context.stderr;
     }
+    if (verbose && preserveRawFailureOutput && hasMeaningfulParsedOutput(shapedAgentOutput)) {
+        response.agentOutput = shapedAgentOutput;
+    }
     return response;
 }

package/dist/process-service.js

@@ -1,7 +1,29 @@
 import { spawn } from 'node:child_process';
 import { buildCliCommand } from './cli-builder.js';
-import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput, PeekMessageExtractor } from './parsers.js';
+import { appendPeekMessages, buildNotFoundPeekProcess, observedDurationSec, validatePeekPids, validatePeekTimeSec, } from './peek.js';
 import { buildProcessResult } from './process-result.js';
+function parseAgentOutput(agent, stdout, stderr) {
+    if (agent === 'codex') {
+        return parseCodexOutput(`${stdout || ''}\n${stderr || ''}`);
+    }
+    if (!stdout) {
+        return null;
+    }
+    if (agent === 'claude') {
+        return parseClaudeOutput(stdout);
+    }
+    if (agent === 'gemini') {
+        return parseGeminiOutput(stdout);
+    }
+    if (agent === 'forge') {
+        return parseForgeOutput(stdout);
+    }
+    if (agent === 'opencode') {
+        return parseOpenCodeOutput(stdout);
+    }
+    return null;
+}
 export class ProcessService {
     processManager = new Map();
     cliPaths;
@@ -85,22 +107,7 @@ export class ProcessService {
         if (!process) {
             throw new Error(`Process with PID ${pid} not found`);
         }
-        let agentOutput = null;
-        if (process.toolType === 'codex') {
-            const combinedOutput = (process.stdout || '') + '\n' + (process.stderr || '');
-            agentOutput = parseCodexOutput(combinedOutput);
-        }
-        else if (process.stdout) {
-            if (process.toolType === 'claude') {
-                agentOutput = parseClaudeOutput(process.stdout);
-            }
-            else if (process.toolType === 'gemini') {
-                agentOutput = parseGeminiOutput(process.stdout);
-            }
-            else if (process.toolType === 'forge') {
-                agentOutput = parseForgeOutput(process.stdout);
-            }
-        }
+        const agentOutput = parseAgentOutput(process.toolType, process.stdout, process.stderr);
         return buildProcessResult({
             pid,
             agent: process.toolType,
@@ -149,6 +156,85 @@ export class ProcessService {
             }
         }
     }
+    async peekProcesses(pids, peekTimeSec = 10) {
+        const targetPids = validatePeekPids(pids);
+        const targetPeekTimeSec = validatePeekTimeSec(peekTimeSec);
+        const processes = [];
+        const observers = [];
+        for (const pid of targetPids) {
+            const entry = this.processManager.get(pid);
+            if (!entry) {
+                processes.push(buildNotFoundPeekProcess(pid));
+                continue;
+            }
+            const result = {
+                pid,
+                agent: entry.toolType,
+                status: entry.status,
+                messages: [],
+                truncated: false,
+                error: null,
+            };
+            processes.push(result);
+            const stdoutExtractor = new PeekMessageExtractor(entry.toolType);
+            const stderrExtractor = new PeekMessageExtractor(entry.toolType);
+            const onStdout = (data) => {
+                appendPeekMessages(result, stdoutExtractor.push(data.toString(), new Date().toISOString()));
+            };
+            const onStderr = (data) => {
+                appendPeekMessages(result, stderrExtractor.push(data.toString(), new Date().toISOString()));
+            };
+            if (entry.status === 'running') {
+                entry.process.stdout?.on('data', onStdout);
+                entry.process.stderr?.on('data', onStderr);
+            }
+            observers.push({ entry, result, stdoutExtractor, stderrExtractor, onStdout, onStderr });
+        }
+        const startedAt = new Date();
+        const startedAtMs = Date.now();
+        const runningObservers = observers.filter((observer) => observer.entry.status === 'running');
+        const terminalPromise = Promise.all(runningObservers.map((observer) => this.waitForProcessTerminal(observer.entry)));
+        let timeoutHandle;
+        const timeoutPromise = new Promise((resolve) => {
+            timeoutHandle = setTimeout(resolve, targetPeekTimeSec * 1000);
+            timeoutHandle.unref?.();
+        });
+        try {
+            await Promise.race([terminalPromise, timeoutPromise]);
+        }
+        finally {
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+            const flushTs = new Date().toISOString();
+            for (const observer of observers) {
+                observer.entry.process.stdout?.off('data', observer.onStdout);
+                observer.entry.process.stderr?.off('data', observer.onStderr);
+                appendPeekMessages(observer.result, observer.stdoutExtractor.flush(flushTs));
+                appendPeekMessages(observer.result, observer.stderrExtractor.flush(flushTs));
+                observer.result.status = observer.entry.status;
+            }
+        }
+        return {
+            peek_started_at: startedAt.toISOString(),
+            observed_duration_sec: observedDurationSec(startedAtMs),
+            processes,
+        };
+    }
+    waitForProcessTerminal(processEntry) {
+        if (processEntry.status !== 'running') {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            const done = () => {
+                processEntry.process.off('close', done);
+                processEntry.process.off('error', done);
+                resolve();
+            };
+            processEntry.process.once('close', done);
+            processEntry.process.once('error', done);
+        });
+    }
     killProcess(pid) {
         const processEntry = this.processManager.get(pid);
         if (!processEntry) {

package/dist/server.js

@@ -1,5 +1,4 @@
-#!/usr/bin/env node
-export { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
+export { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli, findOpencodeCli } from './cli-utils.js';
 export { resolveModelAlias } from './cli-builder.js';
 export { ClaudeCodeServer, runMcpServer, spawnAsync } from './app/mcp.js';
 import { runMcpServer } from './app/mcp.js';

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "ai-cli-mcp",
-  "version": "2.14.1",
+  "version": "2.16.0",
   "mcpName": "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",
   "author": "mkXultra",
   "license": "MIT",
   "main": "dist/server.js",
@@ -25,21 +25,24 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.11.2",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "zod": "^3.24.4"
   },
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
   "type": "module",
   "devDependencies": {
     "@eslint/js": "^9.26.0",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@types/node": "^22.15.17",
-    "@vitest/coverage-v8": "^2.1.8",
+    "@vitest/coverage-v8": "^4.1.3",
     "husky": "^9.1.7",
-    "semantic-release": "^25.0.2",
+    "semantic-release": "^25.0.3",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3",
-    "vitest": "^2.1.8"
+    "vitest": "^4.1.3"
   },
   "repository": {
     "type": "git",