@mseep/claudian 2.0.25

package/tests/unit/providers/codex/runtime/CodexAppServerProcess.test.ts

@@ -0,0 +1,255 @@
+import type { ChildProcess } from 'child_process';
+import { EventEmitter, Readable, Writable } from 'stream';
+
+jest.mock('child_process', () => ({
+  spawn: jest.fn(),
+}));
+
+import { spawn } from 'child_process';
+
+import { CodexAppServerProcess } from '@/providers/codex/runtime/CodexAppServerProcess';
+import type { CodexLaunchSpec } from '@/providers/codex/runtime/codexLaunchTypes';
+
+const mockSpawn = spawn as jest.MockedFunction<typeof spawn>;
+
+function createLaunchSpec(overrides: Partial<CodexLaunchSpec> = {}): CodexLaunchSpec {
+  return {
+    target: {
+      method: 'host-native',
+      platformFamily: 'unix',
+      platformOs: 'linux',
+    },
+    command: '/usr/bin/codex',
+    args: ['app-server', '--listen', 'stdio://'],
+    spawnCwd: '/workspace',
+    targetCwd: '/workspace',
+    env: {},
+    pathMapper: {
+      target: {
+        method: 'host-native',
+        platformFamily: 'unix',
+        platformOs: 'linux',
+      },
+      toTargetPath: jest.fn(),
+      toHostPath: jest.fn(),
+      mapTargetPathList: jest.fn(),
+      canRepresentHostPath: jest.fn(),
+    },
+    ...overrides,
+  };
+}
+
+function createMockProcess(): ChildProcess {
+  const proc = new EventEmitter() as unknown as ChildProcess;
+  (proc as any).stdin = new Writable({ write: (_chunk, _enc, cb) => cb() });
+  (proc as any).stdout = new Readable({ read() {} });
+  (proc as any).stderr = new Readable({ read() {} });
+  (proc as any).pid = 12345;
+  (proc as any).killed = false;
+  (proc as any).kill = jest.fn().mockReturnValue(true);
+  return proc;
+}
+
+describe('CodexAppServerProcess', () => {
+  const originalPlatform = process.platform;
+  let mockProc: ChildProcess;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockProc = createMockProcess();
+    mockSpawn.mockReturnValue(mockProc);
+  });
+
+  afterEach(() => {
+    Object.defineProperty(process, 'platform', { value: originalPlatform });
+  });
+
+  describe('spawn', () => {
+    it('spawns codex app-server with correct arguments', () => {
+      const server = new CodexAppServerProcess(createLaunchSpec());
+      server.start();
+
+      expect(mockSpawn).toHaveBeenCalledWith(
+        '/usr/bin/codex',
+        ['app-server', '--listen', 'stdio://'],
+        expect.objectContaining({
+          stdio: ['pipe', 'pipe', 'pipe'],
+          cwd: '/workspace',
+        }),
+      );
+    });
+
+    it('wraps Windows .cmd shims through cmd.exe and quotes shell metacharacters', () => {
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+
+      const server = new CodexAppServerProcess(createLaunchSpec({
+        command: 'C:\\Users\\R&D\\AppData\\Roaming\\npm\\codex.cmd',
+      }));
+      server.start();
+
+      expect(mockSpawn).toHaveBeenCalledWith(
+        process.env.ComSpec || process.env.comspec || 'cmd.exe',
+        ['/d', '/s', '/c', '""C:\\Users\\R&D\\AppData\\Roaming\\npm\\codex.cmd" app-server --listen stdio://"'],
+        expect.objectContaining({
+          windowsHide: true,
+          windowsVerbatimArguments: true,
+        }),
+      );
+    });
+
+    it('passes environment variables to the spawned process', () => {
+      const env = { OPENAI_API_KEY: 'sk-test', PATH: '/usr/bin' };
+      const server = new CodexAppServerProcess(createLaunchSpec({ env }));
+      server.start();
+
+      expect(mockSpawn).toHaveBeenCalledWith(
+        '/usr/bin/codex',
+        ['app-server', '--listen', 'stdio://'],
+        expect.objectContaining({
+          env,
+        }),
+      );
+    });
+  });
+
+  describe('stdio accessors', () => {
+    it('exposes stdin, stdout, and stderr from the spawned process', () => {
+      const server = new CodexAppServerProcess(createLaunchSpec());
+      server.start();
+
+      expect(server.stdin).toBe(mockProc.stdin);
+      expect(server.stdout).toBe(mockProc.stdout);
+      expect(server.stderr).toBe(mockProc.stderr);
+    });
+
+    it('throws when accessing stdio before start', () => {
+      const server = new CodexAppServerProcess(createLaunchSpec());
+
+      expect(() => server.stdin).toThrow();
+      expect(() => server.stdout).toThrow();
+      expect(() => server.stderr).toThrow();
+    });
+  });
+
+  describe('isAlive', () => {
+    it('returns true when process is running', () => {
+      const server = new CodexAppServerProcess(createLaunchSpec());
+      server.start();
+
+      expect(server.isAlive()).toBe(true);
+    });
+
+    it('returns false before start', () => {
+      const server = new CodexAppServerProcess(createLaunchSpec());
+
+      expect(server.isAlive()).toBe(false);
+    });
+
+    it('returns false after process exits', () => {
+      const server = new CodexAppServerProcess(createLaunchSpec());
+      server.start();
+
+      mockProc.emit('exit', 0, null);
+
+      expect(server.isAlive()).toBe(false);
+    });
+  });
+
+  describe('onExit', () => {
+    it('calls registered exit callback when process exits', () => {
+      const server = new CodexAppServerProcess(createLaunchSpec());
+      const exitCallback = jest.fn();
+      server.onExit(exitCallback);
+      server.start();
+
+      mockProc.emit('exit', 1, 'SIGTERM');
+
+      expect(exitCallback).toHaveBeenCalledWith(1, 'SIGTERM');
+    });
+
+    it('calls exit callback registered after start', () => {
+      const server = new CodexAppServerProcess(createLaunchSpec());
+      server.start();
+
+      const exitCallback = jest.fn();
+      server.onExit(exitCallback);
+
+      mockProc.emit('exit', 0, null);
+
+      expect(exitCallback).toHaveBeenCalledWith(0, null);
+    });
+  });
+
+  describe('shutdown', () => {
+    it('sends SIGTERM to the process', async () => {
+      const server = new CodexAppServerProcess(createLaunchSpec());
+      server.start();
+
+      const shutdownPromise = server.shutdown();
+      mockProc.emit('exit', 0, 'SIGTERM');
+      await shutdownPromise;
+
+      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
+    });
+
+    it('kills the process tree when shutting down Windows .cmd shims', async () => {
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+      const server = new CodexAppServerProcess(createLaunchSpec({
+        command: 'C:\\Users\\R&D\\AppData\\Roaming\\npm\\codex.cmd',
+      }));
+      server.start();
+
+      const shutdownPromise = server.shutdown();
+
+      expect(mockSpawn).toHaveBeenCalledWith(
+        'taskkill.exe',
+        ['/pid', '12345', '/t', '/f'],
+        expect.objectContaining({
+          stdio: 'ignore',
+          windowsHide: true,
+        }),
+      );
+      expect(mockProc.kill).not.toHaveBeenCalled();
+
+      mockProc.emit('exit', 0, null);
+      await shutdownPromise;
+    });
+
+    it('sends SIGKILL if process does not exit within timeout', async () => {
+      jest.useFakeTimers();
+      const server = new CodexAppServerProcess(createLaunchSpec());
+      server.start();
+
+      const shutdownPromise = server.shutdown();
+
+      // Advance past the SIGKILL timeout
+      jest.advanceTimersByTime(5_000);
+
+      // Now simulate exit after SIGKILL
+      mockProc.emit('exit', 137, 'SIGKILL');
+      await shutdownPromise;
+
+      expect(mockProc.kill).toHaveBeenCalledWith('SIGTERM');
+      expect(mockProc.kill).toHaveBeenCalledWith('SIGKILL');
+
+      jest.useRealTimers();
+    });
+
+    it('resolves immediately if process is not running', async () => {
+      const server = new CodexAppServerProcess(createLaunchSpec());
+      await server.shutdown();
+      expect(server.isAlive()).toBe(false);
+    });
+  });
+
+  describe('error handling', () => {
+    it('marks process as not alive on spawn error', () => {
+      const server = new CodexAppServerProcess(createLaunchSpec());
+      server.start();
+
+      mockProc.emit('error', new Error('spawn failed'));
+
+      expect(server.isAlive()).toBe(false);
+    });
+  });
+});

package/tests/unit/providers/codex/runtime/CodexAuxQueryRunner.test.ts

@@ -0,0 +1,130 @@
+import '@/providers';
+
+const mockTransportRequest = jest.fn();
+const mockTransportNotify = jest.fn();
+const mockTransportOnNotification = jest.fn();
+const mockTransportDispose = jest.fn();
+const mockTransportStart = jest.fn();
+const mockProcessStart = jest.fn();
+const mockProcessShutdown = jest.fn().mockResolvedValue(undefined);
+const mockProcessOnExit = jest.fn();
+const mockProcessOffExit = jest.fn();
+
+const mockResolveLaunchSpec = jest.fn();
+
+jest.mock('@/providers/codex/runtime/CodexRpcTransport', () => ({
+  CodexRpcTransport: jest.fn().mockImplementation(() => ({
+    request: mockTransportRequest,
+    notify: mockTransportNotify,
+    onNotification: mockTransportOnNotification,
+    dispose: mockTransportDispose,
+    start: mockTransportStart,
+  })),
+}));
+
+jest.mock('@/providers/codex/runtime/CodexAppServerProcess', () => ({
+  CodexAppServerProcess: jest.fn().mockImplementation(() => ({
+    start: mockProcessStart,
+    shutdown: mockProcessShutdown,
+    onExit: mockProcessOnExit,
+    offExit: mockProcessOffExit,
+  })),
+}));
+
+jest.mock('@/providers/codex/runtime/codexAppServerSupport', () => ({
+  initializeCodexAppServerTransport: jest.fn().mockImplementation(async (transport: { notify: (method: string) => void }) => {
+    transport.notify('initialized');
+    return {
+      userAgent: 'test/0.1',
+      codexHome: '/home/user/.codex',
+      platformFamily: 'unix',
+      platformOs: 'linux',
+    };
+  }),
+  resolveCodexAppServerLaunchSpec: (...args: unknown[]) => mockResolveLaunchSpec(...args),
+}));
+
+import { CodexAppServerProcess as MockedProcessClass } from '@/providers/codex/runtime/CodexAppServerProcess';
+import { CodexAuxQueryRunner } from '@/providers/codex/runtime/CodexAuxQueryRunner';
+
+describe('CodexAuxQueryRunner', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockResolveLaunchSpec.mockReturnValue({
+      target: { method: 'wsl', platformFamily: 'unix', platformOs: 'linux', distroName: 'Ubuntu' },
+      command: 'wsl.exe',
+      args: ['--distribution', 'Ubuntu', '--cd', '/mnt/c/repo', 'codex', 'app-server', '--listen', 'stdio://'],
+      spawnCwd: 'C:\\repo',
+      targetCwd: '/mnt/c/repo',
+      env: { OPENAI_API_KEY: 'sk-test' },
+      pathMapper: {
+        target: { method: 'wsl', platformFamily: 'unix', platformOs: 'linux', distroName: 'Ubuntu' },
+        toTargetPath: jest.fn(),
+        toHostPath: jest.fn(),
+        mapTargetPathList: jest.fn(),
+        canRepresentHostPath: jest.fn(),
+      },
+    });
+
+    let turnCompletedHandler: ((params: unknown) => void) | undefined;
+    let deltaHandler: ((params: unknown) => void) | undefined;
+    mockTransportOnNotification.mockImplementation((method: string, handler: (params: unknown) => void) => {
+      if (method === 'item/agentMessage/delta') {
+        deltaHandler = handler;
+      }
+      if (method === 'turn/completed') {
+        turnCompletedHandler = handler;
+      }
+    });
+
+    mockTransportRequest.mockImplementation(async (method: string) => {
+      switch (method) {
+        case 'initialize':
+          return {
+            userAgent: 'test/0.1',
+            codexHome: '/home/user/.codex',
+            platformFamily: 'unix',
+            platformOs: 'linux',
+          };
+        case 'thread/start':
+          return { thread: { id: 'thread-1' } };
+        case 'turn/start':
+          setTimeout(() => {
+            deltaHandler?.({ delta: 'Hello from Codex' });
+            turnCompletedHandler?.({ turn: { status: 'completed', error: null } });
+          }, 0);
+          return { turn: { id: 'turn-1' } };
+        default:
+          return {};
+      }
+    });
+  });
+
+  it('uses the launch spec target cwd for auxiliary thread/start calls', async () => {
+    const plugin = {
+      settings: {},
+      getActiveEnvironmentVariables: jest.fn(),
+      app: {
+        vault: {
+          adapter: { basePath: 'C:\\repo' },
+        },
+      },
+    } as any;
+
+    const runner = new CodexAuxQueryRunner(plugin);
+    const result = await runner.query({ systemPrompt: 'You are concise.' }, 'Summarize this');
+
+    expect(result).toBe('Hello from Codex');
+    expect(MockedProcessClass).toHaveBeenCalledWith(expect.objectContaining({
+      command: 'wsl.exe',
+      targetCwd: '/mnt/c/repo',
+    }));
+    expect(mockTransportRequest).toHaveBeenCalledWith(
+      'thread/start',
+      expect.objectContaining({
+        cwd: '/mnt/c/repo',
+        experimentalRawEvents: true,
+      }),
+    );
+  });
+});

package/tests/unit/providers/codex/runtime/CodexBinaryLocator.test.ts

@@ -0,0 +1,90 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+import {
+  findCodexBinaryPath,
+  resolveCodexCliPath,
+} from '@/providers/codex/runtime/CodexBinaryLocator';
+
+describe('CodexBinaryLocator', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-binary-locator-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('finds a codex executable on PATH', () => {
+    const pathDir = path.join(tempDir, 'bin');
+    const pathBinary = path.join(pathDir, 'codex');
+    fs.mkdirSync(pathDir, { recursive: true });
+    fs.writeFileSync(pathBinary, '');
+
+    expect(findCodexBinaryPath(pathDir, 'darwin')).toBe(pathBinary);
+  });
+
+  it('finds a Windows codex.cmd shim on PATH', () => {
+    const pathDir = path.join(tempDir, 'bin');
+    const pathBinary = path.join(pathDir, 'codex.cmd');
+    fs.mkdirSync(pathDir, { recursive: true });
+    fs.writeFileSync(pathBinary, '');
+
+    expect(findCodexBinaryPath(pathDir, 'win32')).toBe(pathBinary);
+  });
+
+  it('prefers a hostname-specific configured path', () => {
+    const hostnamePath = path.join(tempDir, 'hostname-codex');
+    const legacyPath = path.join(tempDir, 'legacy-codex');
+    fs.writeFileSync(hostnamePath, '');
+    fs.writeFileSync(legacyPath, '');
+
+    expect(resolveCodexCliPath(hostnamePath, legacyPath, '')).toBe(hostnamePath);
+  });
+
+  it('falls back to a legacy configured path', () => {
+    const legacyPath = path.join(tempDir, 'legacy-codex');
+    fs.writeFileSync(legacyPath, '');
+
+    expect(resolveCodexCliPath('', legacyPath, '')).toBe(legacyPath);
+  });
+
+  it('falls back to PATH lookup when no configured file exists', () => {
+    const pathDir = path.join(tempDir, 'bin');
+    const pathBinary = path.join(pathDir, 'codex');
+    fs.mkdirSync(pathDir, { recursive: true });
+    fs.writeFileSync(pathBinary, '');
+
+    expect(resolveCodexCliPath('', '', `PATH=${pathDir}`)).toBe(pathBinary);
+  });
+
+  it('uses the configured Linux command directly in WSL mode', () => {
+    expect(resolveCodexCliPath(
+      'codex',
+      '',
+      '',
+      { installationMethod: 'wsl', hostPlatform: 'win32' },
+    )).toBe('codex');
+  });
+
+  it('falls back to the default Linux command in WSL mode', () => {
+    expect(resolveCodexCliPath(
+      '',
+      '',
+      '',
+      { installationMethod: 'wsl', hostPlatform: 'win32' },
+    )).toBe('codex');
+  });
+
+  it('ignores a Windows-native CLI path in WSL mode and falls back to the Linux command', () => {
+    expect(resolveCodexCliPath(
+      'C:\\Users\\user\\AppData\\Roaming\\npm\\codex.exe',
+      '',
+      '',
+      { installationMethod: 'wsl', hostPlatform: 'win32' },
+    )).toBe('codex');
+  });
+});