ai-cli-mcp 2.14.0 → 2.14.1

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [2.14.1](https://github.com/mkXultra/ai-cli-mcp/compare/v2.14.0...v2.14.1) (2026-04-07)
+
+
+### Bug Fixes
+
+* 削除済み作業フォルダでのプロセス操作クラッシュを修正 ([02d765f](https://github.com/mkXultra/ai-cli-mcp/commit/02d765ff76ebd295118e16a112ea3e7ac6fab111))
+
 # [2.14.0](https://github.com/mkXultra/ai-cli-mcp/compare/v2.13.0...v2.14.0) (2026-04-07)
 
 

package/dist/__tests__/cli-process-service.test.js

@@ -294,6 +294,90 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
         expect(stored.status).toBe('running');
         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, signal) => {
+            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);

package/dist/cli-process-service.js

@@ -1,6 +1,6 @@
 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';
@@ -77,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(),
@@ -196,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++;
@@ -233,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));
     }
@@ -257,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-cli-mcp",
-  "version": "2.14.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__/cli-process-service.test.ts

@@ -334,6 +334,111 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
     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);

package/src/cli-process-service.ts

@@ -12,7 +12,7 @@ import {
   unlinkSync,
   writeFileSync,
 } from 'node:fs';
-import { join } from 'node:path';
+import { join, basename, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { buildCliCommand, type BuildCliCommandOptions } from './cli-builder.js';
 import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
@@ -24,6 +24,7 @@ interface StoredProcess {
   pid: number;
   prompt: string;
   workFolder: string;
+  cwdKey?: string;
   model?: string;
   toolType: AgentType;
   startTime: string;
@@ -128,6 +129,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(),
@@ -260,7 +262,7 @@ export class CliProcessService {
         continue;
       }
 
-      const processDir = this.resolveProcessDir(refreshed.workFolder, refreshed.pid);
+      const processDir = this.resolveStoredProcessDir(refreshed);
       if (existsSync(processDir)) {
         rmSync(processDir, { recursive: true, force: true });
         removed++;
@@ -304,11 +306,15 @@ export class CliProcessService {
   }
 
   private parseProcessFile(metaPath: string): StoredProcess {
-    return JSON.parse(readFileSync(metaPath, 'utf-8')) as StoredProcess;
+    const process = JSON.parse(readFileSync(metaPath, 'utf-8')) as StoredProcess;
+    if (!process.cwdKey) {
+      process.cwdKey = basename(dirname(dirname(metaPath)));
+    }
+    return process;
   }
 
   private writeProcess(process: StoredProcess): void {
-    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));
   }
@@ -333,7 +339,18 @@ export class CliProcessService {
   }
 
   private resolveProcessDir(cwd: string, pid: number): string {
-    return join(this.resolveCwdsDir(), normalizeCwdForStorage(realpathSync(cwd)), String(pid));
+    return join(this.resolveCwdsDir(), this.resolveCwdKey(cwd), String(pid));
+  }
+
+  private resolveStoredProcessDir(process: StoredProcess): string {
+    if (!process.cwdKey) {
+      process.cwdKey = this.resolveCwdKey(process.workFolder);
+    }
+    return join(this.resolveCwdsDir(), process.cwdKey, String(process.pid));
+  }
+
+  private resolveCwdKey(cwd: string): string {
+    return normalizeCwdForStorage(realpathSync(cwd));
   }
 
   private resolveMetaPath(processDir: string): string {