tlc-claude-code 2.3.0 → 2.4.1

package/bin/setup-autoupdate.test.js

@@ -1,88 +1,430 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import {
-  generateLaunchdPlist,
-  generateCronEntry,
   generateUpdateScript,
+  generateCronEntry,
+  generateLaunchdPlist,
   enable,
   disable,
   writeTimestamp,
   readTimestamp,
   isStale,
+  checkForUpdate,
+  CLI_PACKAGES,
+  TLC_PACKAGE,
 } from './setup-autoupdate.js';
 
 describe('setup-autoupdate', () => {
-  describe('generateLaunchdPlist', () => {
-    it('returns valid XML plist with daily interval', () => {
-      const plist = generateLaunchdPlist('/path/to/update-script.sh');
-      expect(plist).toContain('<?xml');
-      expect(plist).toContain('com.tlc.autoupdate');
-      expect(plist).toContain('<integer>86400</integer>');
-      expect(plist).toContain('/path/to/update-script.sh');
+  // ───────────────────────────────────────────────────
+  // CLI_PACKAGES constant
+  // ───────────────────────────────────────────────────
+  describe('CLI_PACKAGES', () => {
+    it('maps claude to its npm and homebrew package names', () => {
+      expect(CLI_PACKAGES.claude).toEqual({
+        npm: '@anthropic-ai/claude-code',
+        brew: 'claude-code',
+        selfUpdate: 'claude update',
+      });
     });
-  });
 
-  describe('generateCronEntry', () => {
-    it('returns valid crontab line running at 4am daily', () => {
-      const entry = generateCronEntry('/path/to/update-script.sh');
-      expect(entry).toMatch(/^0 4 \* \* \*/);
-      expect(entry).toContain('/path/to/update-script.sh');
+    it('maps codex to its npm and homebrew package names', () => {
+      expect(CLI_PACKAGES.codex).toEqual({
+        npm: '@openai/codex',
+        brew: 'codex',
+        selfUpdate: null,
+      });
+    });
+
+    it('maps gemini to its npm and homebrew package names', () => {
+      expect(CLI_PACKAGES.gemini).toEqual({
+        npm: '@google/gemini-cli',
+        brew: 'gemini-cli',
+        selfUpdate: null,
+      });
     });
   });
 
+  // ───────────────────────────────────────────────────
+  // generateUpdateScript — self-contained bash script
+  // ───────────────────────────────────────────────────
   describe('generateUpdateScript', () => {
-    it('includes claude update command', () => {
+    it('starts with bash shebang and strict mode', () => {
+      const script = generateUpdateScript();
+      expect(script).toMatch(/^#!\/usr\/bin\/env bash\n/);
+      expect(script).toContain('set -euo pipefail');
+    });
+
+    it('defines a detect_install_method function', () => {
+      const script = generateUpdateScript();
+      expect(script).toContain('detect_install_method');
+      expect(script).toContain('brew list --formula');
+      expect(script).toContain('npm list -g');
+    });
+
+    it('defines an update_cli function that dispatches by install method', () => {
+      const script = generateUpdateScript();
+      expect(script).toContain('update_cli');
+      expect(script).toContain('brew upgrade');
+      expect(script).toContain('npm update -g');
+    });
+
+    it('includes update blocks for all three CLIs', () => {
+      const script = generateUpdateScript();
+      expect(script).toContain('claude');
+      expect(script).toContain('codex');
+      expect(script).toContain('gemini');
+    });
+
+    it('handles claude self-update for standalone installs', () => {
       const script = generateUpdateScript();
       expect(script).toContain('claude update');
     });
 
-    it('includes codex update command', () => {
+    it('includes homebrew detection for each CLI', () => {
       const script = generateUpdateScript();
-      expect(script).toContain('npm update -g @openai/codex');
+      expect(script).toContain('claude-code');
+      expect(script).toContain('@openai/codex');
+      expect(script).toContain('@google/gemini-cli');
     });
 
-    it('logs to autoupdate.log', () => {
+    it('logs to autoupdate.log with timestamps', () => {
       const script = generateUpdateScript();
       expect(script).toContain('autoupdate.log');
+      expect(script).toContain('date -u');
     });
 
-    it('writes timestamp to .last-update', () => {
+    it('writes completion timestamp to .last-update', () => {
       const script = generateUpdateScript();
       expect(script).toContain('.last-update');
     });
+
+    it('continues on individual CLI failure without aborting', () => {
+      const script = generateUpdateScript();
+      // Each update command should have || error handling, not abort on failure
+      const updateLines = script.split('\n').filter(l => l.includes('>> "$LOG_FILE" 2>&1'));
+      for (const line of updateLines) {
+        expect(line).toContain('||');
+      }
+    });
+
+    it('skips CLIs that are not installed', () => {
+      const script = generateUpdateScript();
+      // Each CLI block should check command -v before attempting update
+      expect(script).toContain('command -v claude');
+      expect(script).toContain('command -v codex');
+      expect(script).toContain('command -v gemini');
+    });
+
+    it('loads shell profile to find brew and npm in PATH', () => {
+      const script = generateUpdateScript();
+      // Cron jobs have minimal PATH — script must source profile
+      expect(script).toMatch(/source.*profile|\.zshrc|\.bashrc|PATH.*homebrew|\/opt\/homebrew|\/usr\/local/);
+    });
+
+    it('sources version managers (nvm, volta, asdf) for PATH', () => {
+      const script = generateUpdateScript();
+      expect(script).toContain('.nvm/nvm.sh');
+      expect(script).toContain('.volta/bin');
+      expect(script).toContain('.asdf/shims');
+    });
+
+    it('updates TLC itself via npm', () => {
+      const script = generateUpdateScript();
+      expect(script).toContain('tlc-claude-code');
+      expect(script).toContain('npm update -g');
+    });
+
+    it('checks for TLC update availability and writes notification file', () => {
+      const script = generateUpdateScript();
+      expect(script).toContain('.update-available');
+      expect(script).toContain('npm show tlc-claude-code version');
+    });
   });
 
+  // ───────────────────────────────────────────────────
+  // generateCronEntry
+  // ───────────────────────────────────────────────────
+  describe('generateCronEntry', () => {
+    it('returns a valid crontab line running at 4am daily', () => {
+      const entry = generateCronEntry('/path/to/script.sh');
+      expect(entry).toMatch(/^0 4 \* \* \*/);
+      expect(entry).toContain('/path/to/script.sh');
+    });
+
+    it('includes a comment marker for identification', () => {
+      const entry = generateCronEntry('/path/to/script.sh');
+      expect(entry).toContain('# tlc-autoupdate');
+    });
+  });
+
+  // ───────────────────────────────────────────────────
+  // enable — launchd on macOS, cron on Linux
+  // ───────────────────────────────────────────────────
   describe('enable', () => {
-    it('creates launchd plist on macOS', () => {
-      const fs = { writeFileSync: vi.fn(), mkdirSync: vi.fn(), existsSync: vi.fn(() => false), chmodSync: vi.fn() };
+    it('uses launchd on macOS', () => {
+      const fs = {
+        writeFileSync: vi.fn(),
+        mkdirSync: vi.fn(),
+        chmodSync: vi.fn(),
+      };
       const result = enable({ platform: 'darwin', fs });
       expect(result.type).toBe('launchd');
-      expect(fs.writeFileSync).toHaveBeenCalled();
+      expect(result.plistPath).toContain('com.tlc.autoupdate.plist');
     });
 
-    it('creates cron entry on Linux', () => {
+    it('writes valid launchd plist with daily interval on macOS', () => {
+      const fs = {
+        writeFileSync: vi.fn(),
+        mkdirSync: vi.fn(),
+        chmodSync: vi.fn(),
+      };
+      enable({ platform: 'darwin', fs });
+
+      const plistCall = fs.writeFileSync.mock.calls.find(c => c[0].endsWith('.plist'));
+      expect(plistCall).toBeDefined();
+      expect(plistCall[1]).toContain('<?xml');
+      expect(plistCall[1]).toContain('<integer>86400</integer>');
+      expect(plistCall[1]).toContain('autoupdate.sh');
+    });
+
+    it('uses cron on Linux', () => {
       const execSync = vi.fn(() => '');
-      const fs = { writeFileSync: vi.fn(), mkdirSync: vi.fn(), existsSync: vi.fn(() => false), chmodSync: vi.fn() };
+      const fs = {
+        writeFileSync: vi.fn(),
+        mkdirSync: vi.fn(),
+        chmodSync: vi.fn(),
+      };
       const result = enable({ platform: 'linux', fs, execSync });
       expect(result.type).toBe('cron');
     });
+
+    it('writes the update script and makes it executable', () => {
+      const fs = {
+        writeFileSync: vi.fn(),
+        mkdirSync: vi.fn(),
+        chmodSync: vi.fn(),
+      };
+      enable({ platform: 'darwin', fs });
+
+      const scriptCall = fs.writeFileSync.mock.calls.find(c => c[0].endsWith('autoupdate.sh'));
+      expect(scriptCall).toBeDefined();
+      expect(scriptCall[1]).toContain('#!/usr/bin/env bash');
+
+      expect(fs.chmodSync).toHaveBeenCalledWith(
+        expect.stringContaining('autoupdate.sh'),
+        0o755
+      );
+    });
+
+    it('creates TLC directories', () => {
+      const fs = {
+        writeFileSync: vi.fn(),
+        mkdirSync: vi.fn(),
+        chmodSync: vi.fn(),
+      };
+      enable({ platform: 'darwin', fs });
+
+      const dirs = fs.mkdirSync.mock.calls.map(c => c[0]);
+      expect(dirs.some(d => d.endsWith('.tlc'))).toBe(true);
+      expect(dirs.some(d => d.includes('logs'))).toBe(true);
+    });
+
+    it('appends cron entry to existing crontab on Linux', () => {
+      const existingCrontab = '30 2 * * * /usr/bin/backup\n';
+      const execSync = vi.fn((cmd) => {
+        if (cmd.startsWith('crontab -l')) return existingCrontab;
+        return '';
+      });
+      const fs = {
+        writeFileSync: vi.fn(),
+        mkdirSync: vi.fn(),
+        chmodSync: vi.fn(),
+      };
+      enable({ platform: 'linux', fs, execSync });
+
+      // crontab content is piped via { input } option, not in the command string
+      const installCall = execSync.mock.calls.find(c =>
+        typeof c[0] === 'string' && c[0] === 'crontab -'
+      );
+      expect(installCall).toBeDefined();
+      expect(installCall[1].input).toContain('backup');
+      expect(installCall[1].input).toContain('tlc-autoupdate');
+    });
+
+    it('does not duplicate if cron entry already exists', () => {
+      const existingCrontab = '0 4 * * * /home/user/.tlc/autoupdate.sh # tlc-autoupdate\n';
+      const execSync = vi.fn((cmd) => {
+        if (cmd.startsWith('crontab -l')) return existingCrontab;
+        return '';
+      });
+      const fs = {
+        writeFileSync: vi.fn(),
+        mkdirSync: vi.fn(),
+        chmodSync: vi.fn(),
+      };
+      const result = enable({ platform: 'linux', fs, execSync });
+
+      expect(result.type).toBe('cron');
+      const installCalls = execSync.mock.calls.filter(c =>
+        typeof c[0] === 'string' && c[0].includes('crontab') && !c[0].includes('-l')
+      );
+      expect(installCalls).toHaveLength(0);
+    });
+
+    it('handles empty crontab gracefully on Linux', () => {
+      const execSync = vi.fn((cmd) => {
+        if (cmd.startsWith('crontab -l')) throw new Error('no crontab for user');
+        return '';
+      });
+      const fs = {
+        writeFileSync: vi.fn(),
+        mkdirSync: vi.fn(),
+        chmodSync: vi.fn(),
+      };
+      const result = enable({ platform: 'linux', fs, execSync });
+      expect(result.type).toBe('cron');
+    });
+
+    it('returns the script path', () => {
+      const fs = {
+        writeFileSync: vi.fn(),
+        mkdirSync: vi.fn(),
+        chmodSync: vi.fn(),
+      };
+      const result = enable({ platform: 'darwin', fs });
+      expect(result.scriptPath).toContain('autoupdate.sh');
+    });
+
+    it('replaces legacy unmarked cron entry with marked one on Linux', () => {
+      const home = process.env.HOME || '/home/user';
+      const legacyCrontab = `30 2 * * * /usr/bin/backup\n0 4 * * * ${home}/.tlc/autoupdate.sh\n`;
+      const execSync = vi.fn((cmd) => {
+        if (cmd.startsWith('crontab -l')) return legacyCrontab;
+        return '';
+      });
+      const fs = {
+        writeFileSync: vi.fn(),
+        mkdirSync: vi.fn(),
+        chmodSync: vi.fn(),
+      };
+      enable({ platform: 'linux', fs, execSync });
+
+      const installCall = execSync.mock.calls.find(c =>
+        typeof c[0] === 'string' && c[0] === 'crontab -'
+      );
+      expect(installCall).toBeDefined();
+      const input = installCall[1].input;
+      expect(input).toContain('tlc-autoupdate');
+      expect(input).toContain('backup');
+      const lines = input.split('\n').filter(l => l.includes('autoupdate.sh'));
+      expect(lines).toHaveLength(1);
+    });
   });
 
+  // ───────────────────────────────────────────────────
+  // disable — launchd on macOS, cron on Linux
+  // ───────────────────────────────────────────────────
   describe('disable', () => {
     it('removes launchd plist on macOS', () => {
-      const fs = { unlinkSync: vi.fn(), existsSync: vi.fn(() => true) };
+      const fs = {
+        existsSync: vi.fn(() => true),
+        unlinkSync: vi.fn(),
+      };
       const result = disable({ platform: 'darwin', fs });
       expect(result.removed).toBe(true);
-      expect(fs.unlinkSync).toHaveBeenCalled();
+      expect(fs.unlinkSync).toHaveBeenCalledWith(
+        expect.stringContaining('com.tlc.autoupdate.plist')
+      );
     });
 
-    it('removes cron entry on Linux', () => {
-      const execSync = vi.fn(() => '0 4 * * * /path/to/script\nother job');
-      const fs = { existsSync: vi.fn(() => false) };
-      const result = disable({ platform: 'linux', fs, execSync });
+    it('returns removed: false on macOS when no plist exists', () => {
+      const fs = {
+        existsSync: vi.fn(() => false),
+      };
+      const result = disable({ platform: 'darwin', fs });
+      expect(result.removed).toBe(false);
+    });
+
+    it('removes the tlc-autoupdate cron entry on Linux', () => {
+      const existingCrontab = '30 2 * * * /usr/bin/backup\n0 4 * * * /home/user/.tlc/autoupdate.sh # tlc-autoupdate\n';
+      const execSync = vi.fn((cmd) => {
+        if (cmd.startsWith('crontab -l')) return existingCrontab;
+        return '';
+      });
+      disable({ platform: 'linux', execSync });
+
+      const installCall = execSync.mock.calls.find(c =>
+        typeof c[0] === 'string' && c[0] === 'crontab -'
+      );
+      expect(installCall).toBeDefined();
+      expect(installCall[1].input).toContain('backup');
+      expect(installCall[1].input).not.toContain('tlc-autoupdate');
+    });
+
+    it('returns removed: true when cron entry was found on Linux', () => {
+      const existingCrontab = '0 4 * * * /home/user/.tlc/autoupdate.sh # tlc-autoupdate\n';
+      const execSync = vi.fn((cmd) => {
+        if (cmd.startsWith('crontab -l')) return existingCrontab;
+        return '';
+      });
+      const result = disable({ platform: 'linux', execSync });
       expect(result.removed).toBe(true);
     });
+
+    it('returns removed: false when no cron entry exists on Linux', () => {
+      const execSync = vi.fn((cmd) => {
+        if (cmd.startsWith('crontab -l')) return '30 2 * * * /usr/bin/backup\n';
+        return '';
+      });
+      const result = disable({ platform: 'linux', execSync });
+      expect(result.removed).toBe(false);
+    });
+
+    it('preserves other cron entries on Linux', () => {
+      const existingCrontab = '30 2 * * * /usr/bin/backup\n0 4 * * * /home/user/.tlc/autoupdate.sh # tlc-autoupdate\n15 3 * * 1 /usr/bin/weekly\n';
+      const execSync = vi.fn((cmd) => {
+        if (cmd.startsWith('crontab -l')) return existingCrontab;
+        return '';
+      });
+      disable({ platform: 'linux', execSync });
+
+      const installCall = execSync.mock.calls.find(c =>
+        typeof c[0] === 'string' && c[0] === 'crontab -'
+      );
+      expect(installCall[1].input).toContain('backup');
+      expect(installCall[1].input).toContain('weekly');
+    });
+
+    it('handles empty crontab gracefully on Linux', () => {
+      const execSync = vi.fn((cmd) => {
+        if (cmd.startsWith('crontab -l')) throw new Error('no crontab for user');
+        return '';
+      });
+      const result = disable({ platform: 'linux', execSync });
+      expect(result.removed).toBe(false);
+    });
+
+    it('removes legacy unmarked cron entries from old versions', () => {
+      const home = process.env.HOME || '/home/user';
+      const legacyCrontab = `30 2 * * * /usr/bin/backup\n0 4 * * * ${home}/.tlc/autoupdate.sh\n`;
+      const execSync = vi.fn((cmd) => {
+        if (cmd.startsWith('crontab -l')) return legacyCrontab;
+        return '';
+      });
+      const result = disable({ platform: 'linux', execSync });
+      expect(result.removed).toBe(true);
+
+      const installCall = execSync.mock.calls.find(c =>
+        typeof c[0] === 'string' && c[0] === 'crontab -'
+      );
+      expect(installCall).toBeDefined();
+      expect(installCall[1].input).toContain('backup');
+      expect(installCall[1].input).not.toContain('autoupdate.sh');
+    });
   });
 
+  // ───────────────────────────────────────────────────
+  // writeTimestamp / readTimestamp
+  // ───────────────────────────────────────────────────
   describe('writeTimestamp / readTimestamp', () => {
     it('writes ISO timestamp to .last-update', () => {
       const fs = { writeFileSync: vi.fn(), mkdirSync: vi.fn() };
@@ -106,14 +448,17 @@ describe('setup-autoupdate', () => {
     });
   });
 
+  // ───────────────────────────────────────────────────
+  // isStale
+  // ───────────────────────────────────────────────────
   describe('isStale', () => {
     it('returns false for fresh timestamp (<24h)', () => {
-      const recent = new Date(Date.now() - 3600_000).toISOString(); // 1h ago
+      const recent = new Date(Date.now() - 3600_000).toISOString();
       expect(isStale(recent)).toBe(false);
     });
 
     it('returns true for stale timestamp (>24h)', () => {
-      const old = new Date(Date.now() - 90_000_000).toISOString(); // 25h ago
+      const old = new Date(Date.now() - 90_000_000).toISOString();
       expect(isStale(old)).toBe(true);
     });
 
@@ -121,4 +466,79 @@ describe('setup-autoupdate', () => {
       expect(isStale(null)).toBe(true);
     });
   });
+
+  // ───────────────────────────────────────────────────
+  // TLC_PACKAGE constant
+  // ───────────────────────────────────────────────────
+  describe('TLC_PACKAGE', () => {
+    it('has the correct npm package name', () => {
+      expect(TLC_PACKAGE).toBe('tlc-claude-code');
+    });
+  });
+
+  // ───────────────────────────────────────────────────
+  // checkForUpdate — version check + notification
+  // ───────────────────────────────────────────────────
+  describe('checkForUpdate', () => {
+    it('returns null when installed version matches latest', () => {
+      const execSync = vi.fn(() => '2.3.0');
+      const result = checkForUpdate({ execSync, installedVersion: '2.3.0' });
+      expect(result).toBeNull();
+    });
+
+    it('returns update info when a newer version is available', () => {
+      const execSync = vi.fn(() => '2.4.0\n');
+      const result = checkForUpdate({ execSync, installedVersion: '2.3.0' });
+      expect(result).toEqual({
+        current: '2.3.0',
+        latest: '2.4.0',
+      });
+    });
+
+    it('returns null when npm show fails', () => {
+      const execSync = vi.fn(() => { throw new Error('network error'); });
+      const result = checkForUpdate({ execSync, installedVersion: '2.3.0' });
+      expect(result).toBeNull();
+    });
+
+    it('returns null when latest is older than installed (pre-release)', () => {
+      const execSync = vi.fn(() => '2.2.0');
+      const result = checkForUpdate({ execSync, installedVersion: '2.3.0' });
+      expect(result).toBeNull();
+    });
+
+    it('writes notification file when update is available', () => {
+      const execSync = vi.fn(() => '2.5.0');
+      const fs = { writeFileSync: vi.fn(), mkdirSync: vi.fn() };
+      checkForUpdate({ execSync, installedVersion: '2.3.0', fs, dir: '/tmp/.tlc' });
+
+      const writeCall = fs.writeFileSync.mock.calls.find(c => c[0].includes('.update-available'));
+      expect(writeCall).toBeDefined();
+      expect(writeCall[1]).toContain('2.5.0');
+    });
+
+    it('removes notification file when up to date', () => {
+      const execSync = vi.fn(() => '2.3.0');
+      const fs = {
+        existsSync: vi.fn(() => true),
+        unlinkSync: vi.fn(),
+      };
+      checkForUpdate({ execSync, installedVersion: '2.3.0', fs, dir: '/tmp/.tlc' });
+
+      expect(fs.unlinkSync).toHaveBeenCalledWith(
+        expect.stringContaining('.update-available')
+      );
+    });
+
+    it('formats notification message with versions and command', () => {
+      const execSync = vi.fn(() => '3.0.0');
+      const fs = { writeFileSync: vi.fn(), mkdirSync: vi.fn() };
+      checkForUpdate({ execSync, installedVersion: '2.3.0', fs, dir: '/tmp/.tlc' });
+
+      const content = fs.writeFileSync.mock.calls.find(c => c[0].includes('.update-available'))[1];
+      expect(content).toContain('2.3.0');
+      expect(content).toContain('3.0.0');
+      expect(content).toContain('npm update -g tlc-claude-code');
+    });
+  });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tlc-claude-code",
-  "version": "2.3.0",
+  "version": "2.4.1",
   "description": "TLC - Test Led Coding for Claude Code",
   "bin": {
     "tlc-claude-code": "./bin/install.js",

package/scripts/project-docs.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 /**
  * Project Documentation Maintenance
  *

package/server/lib/cli-dispatcher.js

@@ -0,0 +1,98 @@
+/**
+ * CLI Dispatcher
+ *
+ * Generic dispatcher for shelling out to any CLI-based LLM provider.
+ * Spawns the process, pipes the prompt via stdin, captures stdout/stderr,
+ * handles timeouts.
+ *
+ * @module cli-dispatcher
+ */
+
+/**
+ * Dispatch a command to a CLI process.
+ * @param {Object} opts - Dispatch options
+ * @param {string} opts.command - CLI executable name (e.g., "codex", "gemini")
+ * @param {string[]} opts.args - CLI arguments
+ * @param {string} opts.prompt - Prompt text to pipe via stdin
+ * @param {number} [opts.timeout=120000] - Timeout in ms
+ * @param {string} [opts.cwd] - Working directory
+ * @param {Function} opts.spawn - Injected child_process.spawn
+ * @returns {Promise<{stdout: string, stderr: string, exitCode: number, duration: number}>}
+ */
+function dispatch({ command, args = [], prompt = '', timeout = 120000, cwd, spawn = require('child_process').spawn }) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+
+    const spawnOpts = {};
+    if (cwd) spawnOpts.cwd = cwd;
+
+    const proc = spawn(command, args, spawnOpts);
+
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+
+    const finish = (exitCode, stderrOverride) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({
+        stdout,
+        stderr: stderrOverride !== undefined ? stderrOverride : stderr,
+        exitCode,
+        duration: Date.now() - start,
+      });
+    };
+
+    const timer = setTimeout(() => {
+      proc.kill();
+      finish(-1, 'Process timed out');
+    }, timeout);
+
+    proc.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      finish(code);
+    });
+
+    proc.on('error', (err) => {
+      finish(-1, err.message || 'Failed to spawn process');
+    });
+
+    // Suppress broken pipe if child exits before stdin is consumed
+    proc.stdin.on('error', () => {});
+
+    // Write prompt to stdin then close
+    if (prompt) {
+      proc.stdin.write(prompt);
+    }
+    proc.stdin.end();
+  });
+}
+
+/**
+ * Build command and args from a provider config object.
+ * @param {Object} provider - Provider config from model_providers
+ * @param {string} provider.type - Provider type ("cli", "inline", etc.)
+ * @param {string} provider.command - CLI executable name
+ * @param {string[]} [provider.flags] - CLI flags
+ * @returns {{command: string, args: string[]}|null} Command spec, or null for non-CLI types
+ */
+function buildProviderCommand(provider) {
+  if (provider.type !== 'cli') {
+    return null;
+  }
+
+  return {
+    command: provider.command,
+    args: provider.flags || [],
+  };
+}
+
+module.exports = { dispatch, buildProviderCommand };