agent-pool-mcp 1.0.0

package/src/cli.js

@@ -0,0 +1,298 @@
+/**
+ * CLI commands — doctor check, config init, version display.
+ *
+ * Runs in human-readable stdout mode (not MCP stdio).
+ *
+ * @module agent-pool/cli
+ */
+
+import { execFileSync, execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { homedir } from 'node:os';
+import { loadConfig } from './runner/config.js';
+
+const PACKAGE_JSON = JSON.parse(
+  fs.readFileSync(new URL('../package.json', import.meta.url), 'utf-8')
+);
+
+const GEMINI_NPM_PACKAGE = '@google/gemini-cli';
+const MIN_NODE_VERSION = 20;
+
+// ─── Colors (ANSI) ──────────────────────────────────────────
+
+const color = {
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+};
+
+const ok = (msg) => console.log(`  ${color.green('✅')} ${msg}`);
+const fail = (msg) => console.log(`  ${color.red('❌')} ${msg}`);
+const warn = (msg) => console.log(`  ${color.yellow('⚠️')}  ${msg}`);
+
+// ─── Check command ──────────────────────────────────────────
+
+/**
+ * Run comprehensive diagnostics (doctor mode).
+ * Checks prerequisites, runners, and config.
+ */
+export function runCheck() {
+  console.log('');
+  console.log(color.bold('🔍 Agent Pool Doctor'));
+  console.log(color.dim(`   v${PACKAGE_JSON.version}`));
+  console.log('');
+
+  let issues = 0;
+
+  // — Node.js version
+  console.log(color.cyan('Prerequisites:'));
+  const nodeVersion = parseInt(process.versions.node);
+  if (nodeVersion >= MIN_NODE_VERSION) {
+    ok(`Node.js v${process.versions.node} ${color.dim(`(>= ${MIN_NODE_VERSION})`)}`);
+  } else {
+    fail(`Node.js v${process.versions.node} — requires >= ${MIN_NODE_VERSION}`);
+    issues++;
+  }
+
+  // — Gemini CLI binary
+  let geminiPath = null;
+  try {
+    geminiPath = execFileSync('which', ['gemini'], { encoding: 'utf-8' }).trim();
+  } catch {
+    // not found
+  }
+
+  if (geminiPath) {
+    let geminiVersion = 'unknown';
+    try {
+      geminiVersion = execFileSync('gemini', ['--version'], {
+        encoding: 'utf-8',
+        timeout: 5000,
+      }).trim();
+    } catch {
+      // version check failed
+    }
+    ok(`Gemini CLI v${geminiVersion} ${color.dim(geminiPath)}`);
+  } else {
+    fail(`Gemini CLI — not found in PATH`);
+    console.log(color.dim(`     Install: npm install -g ${GEMINI_NPM_PACKAGE}`));
+    console.log(color.dim(`     Then run: gemini (to authenticate)`));
+    issues++;
+  }
+
+  // — Runners
+  console.log('');
+  console.log(color.cyan('Runners:'));
+  const config = loadConfig();
+  const configSource = findConfigPath();
+
+  for (const runner of config.runners) {
+    if (runner.type === 'local') {
+      if (geminiPath) {
+        ok(`${color.bold(runner.id)} — local ${runner.id === config.defaultRunner ? color.dim('(default)') : ''}`);
+      } else {
+        fail(`${color.bold(runner.id)} — local (gemini not found)`);
+        issues++;
+      }
+    } else if (runner.type === 'ssh') {
+      const sshResult = testSshRunner(runner);
+      if (sshResult.ok) {
+        ok(`${color.bold(runner.id)} — ssh:${runner.host} ${color.dim(`gemini v${sshResult.version}`)} ${runner.id === config.defaultRunner ? color.dim('(default)') : ''}`);
+      } else {
+        fail(`${color.bold(runner.id)} — ssh:${runner.host} — ${sshResult.error}`);
+        issues++;
+      }
+    }
+  }
+
+  // — Config source
+  console.log('');
+  console.log(color.cyan('Config:'));
+  if (configSource) {
+    ok(configSource);
+  } else {
+    console.log(`  ${color.dim('  No config file (using defaults)')}`);
+    console.log(color.dim(`     Create one with: npx agent-pool-mcp --init`));
+  }
+
+  // — MCP config snippet
+  console.log('');
+  console.log(color.cyan('MCP config snippet (copy to your IDE):'));
+  console.log('');
+  console.log(color.dim('  {'));
+  console.log(color.dim('    "mcpServers": {'));
+  console.log(color.dim('      "agent-pool": {'));
+  console.log(color.dim('        "command": "npx",'));
+  console.log(color.dim('        "args": ["-y", "agent-pool-mcp"]'));
+  console.log(color.dim('      }'));
+  console.log(color.dim('    }'));
+  console.log(color.dim('  }'));
+
+  // — Summary
+  console.log('');
+  if (issues === 0) {
+    console.log(color.green(color.bold('All checks passed! ✨')));
+  } else {
+    console.log(color.yellow(`${issues} issue(s) found. Fix them and run --check again.`));
+  }
+  console.log('');
+
+  return issues;
+}
+
+// ─── Init command ───────────────────────────────────────────
+
+/**
+ * Generate a template agent-pool.config.json in current directory.
+ */
+export function runInit() {
+  const targetPath = path.join(process.cwd(), 'agent-pool.config.json');
+
+  if (fs.existsSync(targetPath)) {
+    console.log(color.yellow(`⚠️  ${targetPath} already exists. Not overwriting.`));
+    return;
+  }
+
+  const template = {
+    runners: [
+      { id: 'local', type: 'local' },
+      { id: 'remote', type: 'ssh', host: 'your-server', cwd: '/home/dev/project' },
+    ],
+    defaultRunner: 'local',
+    defaultModel: 'gemini-3.1-pro-preview',
+  };
+
+  fs.writeFileSync(targetPath, JSON.stringify(template, null, 2) + '\n');
+  console.log(color.green(`✅ Created ${targetPath}`));
+  console.log(color.dim('   Edit the file and update SSH host/cwd for remote runners.'));
+  console.log(color.dim('   Remove the "remote" runner if you only need local execution.'));
+}
+
+// ─── Version command ────────────────────────────────────────
+
+export function printVersion() {
+  console.log(`agent-pool-mcp v${PACKAGE_JSON.version}`);
+}
+
+// ─── Startup validation (fast, for MCP mode) ────────────────
+
+/**
+ * Quick prerequisite check before MCP server starts.
+ * Only checks gemini binary existence (< 50ms).
+ * Outputs to stderr (MCP protocol compatibility).
+ *
+ * @returns {boolean} true if prerequisites met
+ */
+export function validateStartup() {
+  try {
+    execFileSync('which', ['gemini'], { encoding: 'utf-8', timeout: 2000 });
+    return true;
+  } catch {
+    console.error('[agent-pool] ❌ Gemini CLI not found in PATH.');
+    console.error(`[agent-pool] Install: npm install -g ${GEMINI_NPM_PACKAGE}`);
+    console.error('[agent-pool] Then run: gemini (to authenticate)');
+    console.error('[agent-pool] Docs: https://github.com/google-gemini/gemini-cli');
+    return false;
+  }
+}
+
+// ─── Helpers ─────────────────────────────────────────────────
+
+/**
+ * Test if an SSH runner can connect and run gemini.
+ */
+function testSshRunner(runner) {
+  try {
+    const output = execSync(
+      `ssh -o ConnectTimeout=5 -o BatchMode=yes ${runner.host} 'gemini --version' 2>/dev/null`,
+      { encoding: 'utf-8', timeout: 10000 }
+    ).trim();
+    return { ok: true, version: output || 'unknown' };
+  } catch (err) {
+    const msg = err.message || '';
+    if (msg.includes('timed out') || msg.includes('ETIMEDOUT')) {
+      return { ok: false, error: 'connection timeout' };
+    }
+    if (msg.includes('Permission denied') || msg.includes('publickey')) {
+      return { ok: false, error: 'auth failed (check SSH keys)' };
+    }
+    if (msg.includes('Could not resolve')) {
+      return { ok: false, error: 'host not found' };
+    }
+    return { ok: false, error: 'connection failed' };
+  }
+}
+
+/**
+ * Find which config file is actually loaded.
+ */
+function findConfigPath() {
+  const candidates = [
+    path.join(process.cwd(), 'agent-pool.config.json'),
+    path.join(homedir(), '.config', 'agent-pool', 'config.json'),
+  ];
+  return candidates.find((f) => fs.existsSync(f)) ?? null;
+}
+
+// ─── CLI Router ──────────────────────────────────────────────
+
+/**
+ * Parse argv and run CLI command.
+ * Returns true if a CLI command was handled (don't start MCP server).
+ */
+export function handleCli(argv) {
+  const args = argv.slice(2);
+
+  if (args.includes('--version') || args.includes('-v')) {
+    printVersion();
+    return true;
+  }
+
+  if (args.includes('--check') || args.includes('--doctor')) {
+    const issues = runCheck();
+    process.exit(issues > 0 ? 1 : 0);
+    return true;
+  }
+
+  if (args.includes('--init')) {
+    runInit();
+    return true;
+  }
+
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp();
+    return true;
+  }
+
+  return false;
+}
+
+function printHelp() {
+  console.log(`
+${color.bold('agent-pool-mcp')} v${PACKAGE_JSON.version}
+${color.dim('MCP server for multi-agent orchestration via Gemini CLI')}
+
+${color.cyan('Usage:')}
+  agent-pool-mcp              Start MCP server (stdio transport)
+  agent-pool-mcp --check      Run diagnostics (doctor mode)
+  agent-pool-mcp --init       Create template config file
+  agent-pool-mcp --version    Show version
+  agent-pool-mcp --help       Show this help
+
+${color.cyan('MCP config (paste into your IDE):')}
+  {
+    "mcpServers": {
+      "agent-pool": {
+        "command": "npx",
+        "args": ["-y", "agent-pool-mcp"]
+      }
+    }
+  }
+
+${color.cyan('Docs:')} https://github.com/rnd-pro/agent-pool-mcp
+`);
+}

package/src/runner/config.js

@@ -0,0 +1,92 @@
+/**
+ * Runner configuration — loads and resolves runner definitions.
+ *
+ * Supports local and SSH runners. SSH config (keys, ports, jump hosts)
+ * is handled by ~/.ssh/config — we only store host and remote cwd.
+ *
+ * @module agent-pool/runner/config
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { homedir } from 'node:os';
+
+/**
+ * @typedef {object} RunnerDef
+ * @property {string} id - Runner identifier
+ * @property {'local'|'ssh'} type - Runner type
+ * @property {string} [host] - SSH host (for type=ssh)
+ * @property {string} [cwd] - Remote working directory (for type=ssh)
+ */
+
+/** Default model for all delegated tasks */
+const DEFAULT_MODEL = 'gemini-3.1-pro-preview';
+
+const DEFAULT_CONFIG = {
+  runners: [{ id: 'local', type: 'local' }],
+  defaultRunner: 'local',
+  defaultModel: DEFAULT_MODEL,
+};
+
+/** @type {{runners: RunnerDef[], defaultRunner: string}|null} */
+let cachedConfig = null;
+
+/**
+ * Load runner config from agent-pool.config.json.
+ * Search order: CWD, ~/.config/agent-pool/, fallback to default (local only).
+ *
+ * @returns {{runners: RunnerDef[], defaultRunner: string}}
+ */
+export function loadConfig() {
+  if (cachedConfig) return cachedConfig;
+
+  const candidates = [
+    path.join(process.cwd(), 'agent-pool.config.json'),
+    path.join(homedir(), '.config', 'agent-pool', 'config.json'),
+  ];
+
+  for (const filePath of candidates) {
+    if (fs.existsSync(filePath)) {
+      try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        cachedConfig = {
+          runners: parsed.runners ?? DEFAULT_CONFIG.runners,
+          defaultRunner: parsed.defaultRunner ?? 'local',
+          defaultModel: parsed.defaultModel ?? DEFAULT_MODEL,
+        };
+        console.error(`[agent-pool] Config loaded from ${filePath}`);
+        return cachedConfig;
+      } catch (err) {
+        console.error(`[agent-pool] Failed to parse ${filePath}: ${err.message}`);
+      }
+    }
+  }
+
+  cachedConfig = DEFAULT_CONFIG;
+  return cachedConfig;
+}
+
+/**
+ * Get a specific runner by ID.
+ *
+ * @param {string} [runnerId] - Runner ID, defaults to defaultRunner
+ * @returns {RunnerDef}
+ */
+export function getRunner(runnerId) {
+  const config = loadConfig();
+  const id = runnerId ?? config.defaultRunner;
+  const runner = config.runners.find((r) => r.id === id);
+  if (!runner) {
+    console.error(`[agent-pool] Runner "${id}" not found, falling back to local`);
+    return { id: 'local', type: 'local' };
+  }
+  return runner;
+}
+
+/**
+ * Invalidate cached config (for testing or hot reload).
+ */
+export function resetConfig() {
+  cachedConfig = null;
+}

package/src/runner/gemini-runner.js

@@ -0,0 +1,273 @@
+/**
+ * Gemini CLI runner — spawns Gemini CLI processes with streaming JSON output.
+ *
+ * Uses process-manager for PID tracking and group kill on timeout.
+ *
+ * @module agent-pool/runner/gemini-runner
+ */
+
+import { spawn, execFile } from 'node:child_process';
+import { trackChild, killGroup, untrackChild } from './process-manager.js';
+import { getRunner, loadConfig } from './config.js';
+import { buildSshSpawn, parseRemotePid } from './ssh.js';
+import { setTaskPid, updateTaskResult, pushTaskEvent } from '../tools/results.js';
+
+const DEFAULT_TIMEOUT_SEC = 600;
+const DEFAULT_APPROVAL_MODE = 'yolo';
+
+export { DEFAULT_TIMEOUT_SEC, DEFAULT_APPROVAL_MODE };
+
+
+/**
+ * Run Gemini CLI with stream-json format and collect events.
+ * Spawns with detached=true for proper group kill on timeout.
+ *
+ * @param {object} options
+ * @param {string} options.prompt - Task prompt
+ * @param {string} [options.cwd] - Working directory
+ * @param {string} [options.model] - Model ID
+ * @param {string} [options.approvalMode] - Approval mode
+ * @param {number} [options.timeout] - Timeout in seconds
+ * @param {string} [options.sessionId] - Session to resume
+ * @param {string} [options.taskId] - Task ID for tracking
+ * @returns {Promise<object>} Collected events and final response
+ */
+export function runGeminiStreaming({ prompt, cwd, model, approvalMode, timeout, sessionId, taskId, runner: runnerId, policy, includeDirs }) {
+  return new Promise((resolve, reject) => {
+    const runner = getRunner(runnerId);
+    const isRemote = runner.type === 'ssh';
+    const args = [];
+
+    if (sessionId) {
+      args.push('--resume', sessionId);
+    }
+    args.push('-p', prompt);
+    args.push(
+      '--output-format', 'stream-json',
+      '--approval-mode', approvalMode ?? DEFAULT_APPROVAL_MODE,
+    );
+    const effectiveModel = model || loadConfig().defaultModel;
+    if (effectiveModel) {
+      args.push('--model', effectiveModel);
+    }
+    if (policy) {
+      args.push('--policy', policy);
+    }
+    if (includeDirs?.length > 0) {
+      for (const dir of includeDirs) {
+        args.push('--include-directories', dir);
+      }
+    }
+
+    const timeoutMs = (timeout ?? DEFAULT_TIMEOUT_SEC) * 1000;
+
+    let spawnCmd, spawnArgs, spawnOpts;
+
+    if (isRemote) {
+      const ssh = buildSshSpawn(runner, args, cwd ?? process.cwd());
+      spawnCmd = ssh.command;
+      spawnArgs = ssh.args;
+      spawnOpts = { stdio: ['pipe', 'pipe', 'pipe'], detached: true };
+    } else {
+      spawnCmd = 'gemini';
+      spawnArgs = args;
+      const currentDepth = parseInt(process.env.AGENT_POOL_DEPTH ?? '0');
+      spawnOpts = {
+        cwd: cwd ?? process.cwd(),
+        env: {
+          ...process.env,
+          TERM: 'dumb',
+          CI: '1',
+          AGENT_POOL_DEPTH: String(currentDepth + 1),
+        },
+        stdio: ['pipe', 'pipe', 'pipe'],
+        detached: true,
+      };
+    }
+
+    const child = spawn(spawnCmd, spawnArgs, spawnOpts);
+
+    trackChild(child.pid, taskId ?? 'streaming', `gemini-${isRemote ? 'ssh' : 'local'}`);
+    if (taskId) setTaskPid(taskId, child.pid);
+
+    const events = [];
+    let stderrData = '';
+    let buffer = '';
+    let timeoutHandle;
+    let remotePid = null;
+    let resolved = false;
+
+    if (timeoutMs > 0) {
+      timeoutHandle = setTimeout(() => {
+        // Soft timeout: resolve with partial data, let process continue in background
+        clearTimeout(timeoutHandle);
+        timeoutHandle = null;
+        resolved = true;
+
+        const messages = events.filter((e) => e.type === 'message');
+        const toolUses = events.filter((e) => e.type === 'tool_use');
+        const responseText = messages
+          .filter((m) => m.role === 'assistant')
+          .map((m) => m.content ?? m.text ?? '')
+          .join('\n');
+
+        resolve({
+          sessionId: events.find((e) => e.type === 'init')?.session_id ?? null,
+          response: responseText || '⏳ Agent is still working (soft timeout reached). Partial results returned.',
+          stats: null,
+          toolCalls: toolUses.map((t) => ({
+            name: t.tool_name ?? t.name ?? 'unknown',
+            args: t.parameters ?? t.arguments,
+          })),
+          toolResults: [],
+          errors: [],
+          exitCode: null,
+          totalEvents: events.length,
+          softTimeout: true,
+          timeoutSeconds: timeout ?? DEFAULT_TIMEOUT_SEC,
+        });
+        // Process continues running — will be cleaned up on natural exit
+      }, timeoutMs);
+    }
+
+    child.stdout.on('data', (chunk) => {
+      buffer += chunk.toString();
+      const lines = buffer.split('\n');
+      buffer = lines.pop();
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+
+        // Parse remote PID from SSH wrapper
+        if (isRemote && !remotePid) {
+          const pid = parseRemotePid(trimmed);
+          if (pid) {
+            remotePid = pid;
+            continue; // Don't parse PID line as JSON
+          }
+        }
+
+        try {
+          const parsed = JSON.parse(trimmed);
+          events.push(parsed);
+          if (taskId) pushTaskEvent(taskId, parsed);
+        } catch {
+          // Skip non-JSON lines
+        }
+      }
+    });
+
+    child.stderr.on('data', (chunk) => {
+      stderrData += chunk.toString();
+    });
+
+    child.on('close', (code) => {
+      clearTimeout(timeoutHandle);
+      untrackChild(child.pid);
+
+      // If already resolved via soft timeout, update with final complete result
+      if (resolved) {
+        if (buffer.trim()) {
+          try { events.push(JSON.parse(buffer.trim())); } catch { /* ignore */ }
+        }
+        const messages = events.filter((e) => e.type === 'message');
+        const toolUses = events.filter((e) => e.type === 'tool_use');
+        const toolResults = events.filter((e) => e.type === 'tool_result');
+        const resultEvent = events.find((e) => e.type === 'result');
+        const errors = events.filter((e) => e.type === 'error');
+        const responseText = messages.filter((m) => m.role === 'assistant').map((m) => m.content ?? m.text ?? '').join('\n');
+        if (taskId) {
+          updateTaskResult(taskId, {
+            sessionId: events.find((e) => e.type === 'init')?.session_id ?? null,
+            response: resultEvent?.response ?? responseText,
+            stats: resultEvent?.stats ?? null,
+            toolCalls: toolUses.map((t) => ({ name: t.tool_name ?? t.name ?? 'unknown', args: t.parameters ?? t.arguments })),
+            toolResults: toolResults.map((t) => ({ name: t.tool_name ?? t.tool_id ?? t.name ?? 'unknown', output: t.output ? (typeof t.output === 'string' ? t.output.substring(0, 500) : JSON.stringify(t.output)?.substring(0, 500)) : t.status ?? '' })),
+            errors: errors.map((e) => e.message ?? e.error ?? JSON.stringify(e)),
+            exitCode: code,
+            totalEvents: events.length,
+          });
+        }
+        return;
+      }
+
+      // Process remaining buffer
+      if (buffer.trim()) {
+        try { events.push(JSON.parse(buffer.trim())); } catch { /* ignore */ }
+      }
+
+      const messages = events.filter((e) => e.type === 'message');
+      const toolUses = events.filter((e) => e.type === 'tool_use');
+      const toolResults = events.filter((e) => e.type === 'tool_result');
+      const resultEvent = events.find((e) => e.type === 'result');
+      const errors = events.filter((e) => e.type === 'error');
+
+      const responseText = messages
+        .filter((m) => m.role === 'assistant')
+        .map((m) => m.content ?? m.text ?? '')
+        .join('\n');
+
+      const initEvent = events.find((e) => e.type === 'init');
+
+      resolve({
+        sessionId: initEvent?.session_id ?? initEvent?.sessionId ?? null,
+        response: resultEvent?.response ?? responseText,
+        stats: resultEvent?.stats ?? null,
+        toolCalls: toolUses.map((t) => ({
+          name: t.tool_name ?? t.name ?? 'unknown',
+          args: t.parameters ?? t.arguments,
+        })),
+        toolResults: toolResults.map((t) => ({
+          name: t.tool_name ?? t.tool_id ?? t.name ?? 'unknown',
+          output: t.output
+            ? (typeof t.output === 'string' ? t.output.substring(0, 500) : JSON.stringify(t.output)?.substring(0, 500))
+            : t.status ?? '',
+        })),
+        errors: errors.map((e) => e.message ?? e.error ?? JSON.stringify(e)),
+        exitCode: code,
+        totalEvents: events.length,
+      });
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timeoutHandle);
+      untrackChild(child.pid);
+      if (resolved) return;
+      reject(new Error(`Failed to spawn gemini: ${err.message}`));
+    });
+
+    child.stdin.end();
+  });
+}
+
+/**
+ * List available Gemini CLI sessions for a project directory.
+ *
+ * @param {string} cwd - Working directory
+ * @returns {Promise<Array<{index: number, preview: string, timeAgo: string, sessionId: string}>>}
+ */
+export function listGeminiSessions(cwd) {
+  return new Promise((resolve) => {
+    execFile('gemini', ['--list-sessions'], {
+      cwd,
+      timeout: 10000,
+      env: { ...process.env, TERM: 'dumb', CI: '1' },
+    }, (error, stdout) => {
+      if (error) return resolve([]);
+      const sessions = [];
+      for (const line of stdout.split('\n')) {
+        const match = line.match(/^\s*(\d+)\.\s+(.+?)\s+\((.+?)\)\s+\[([a-f0-9-]+)\]/);
+        if (match) {
+          sessions.push({
+            index: parseInt(match[1]),
+            preview: match[2].trim(),
+            timeAgo: match[3],
+            sessionId: match[4],
+          });
+        }
+      }
+      resolve(sessions);
+    });
+  });
+}