agent-pool-mcp 1.5.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-pool-mcp",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "type": "module",
   "description": "MCP Server for multi-agent task delegation and orchestration via Gemini CLI",
   "main": "index.js",

package/src/scheduler/daemon.js

@@ -11,10 +11,14 @@
  * @module agent-pool/scheduler/daemon
  */
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, readdirSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { join, dirname } from 'node:path';
 import { matchesCron } from './cron.js';
+import { getGroup } from '../tools/groups.js';
+import { getRunner } from '../runner/config.js';
+import { buildSshSpawn } from '../runner/ssh.js';
+import { killGroup } from '../runner/process-manager.js';
 
 const POLL_INTERVAL_MS = 30_000; // Check schedules every 30 seconds
 const PID_FILE = '.agents/scheduler.pid';
@@ -161,60 +165,119 @@ function executeSchedule(schedule) {
 
 // ─── Pipeline tick ──────────────────────────────────────────
 
-import { readdirSync } from 'node:fs';
-
 const PIPELINES_DIR = '.agents/pipelines';
 const RUNS_DIR = '.agents/runs';
 
 /**
- * Spawn a Gemini CLI agent for a pipeline step.
+ * Spawn Gemini CLI agent(s) for a pipeline step.
  * @param {object} stepDef - Step definition from pipeline
  * @param {object} run - Current run state
  * @param {string} runId
  * @param {string} [bounceReason] - If bouncing back, the reason
- * @returns {number} child PID
+ * @returns {number[]} Array of child PIDs
  */
 function spawnStep(stepDef, run, runId, bounceReason) {
-  let prompt = stepDef.prompt;
-  if (bounceReason) {
-    prompt = `${stepDef.prompt}\n\n⚠️ BOUNCE BACK: предыдущая попытка была отклонена следующим шагом.\nПричина: ${bounceReason}\nДополни и улучши результат.`;
+  const count = stepDef.count || 1;
+  const pids = [];
+
+  // Resolve group
+  let groupConfig = {};
+  if (stepDef.group) {
+    groupConfig = getGroup(run.cwd || cwd, stepDef.group) || {};
   }
 
-  // Inject pipeline context
-  prompt = `[Pipeline: ${run.pipelineName}, Step: ${stepDef.name}, Run: ${runId}]\n\nTask:\n${prompt}\n\nWhen finished, call signal_step_complete with step_name "${stepDef.name}" and run_id "${runId}".`;
+  const skill = stepDef.skill || groupConfig.skill;
+  const policy = groupConfig.policy; // currently policy only from group
+  const runnerId = groupConfig.runner;
+  const runner = runnerId ? getRunner(runnerId) : { type: 'local' };
+  const isRemote = runner && runner.type === 'ssh';
 
-  const args = [
-    '-p', prompt,
-    '--output-format', 'stream-json',
-    '--approval-mode', stepDef.approvalMode || 'yolo',
-  ];
+  for (let i = 0; i < count; i++) {
+    let prompt = stepDef.prompt;
+    if (bounceReason) {
+      prompt = `${stepDef.prompt}\n\n⚠️ BOUNCE BACK: предыдущая попытка была отклонена следующим шагом.\nПричина: ${bounceReason}\nДополни и улучши результат.`;
+    }
 
-  const child = spawn('gemini', args, {
-    cwd: run.cwd || cwd,
-    env: { ...process.env, TERM: 'dumb', CI: '1' },
-    stdio: ['pipe', 'pipe', 'pipe'],
-    detached: true,
-  });
+    if (count > 1) {
+      prompt = `[Agent ${i + 1}/${count}]\n\n${prompt}`;
+    }
 
-  child.on('close', (code) => {
-    // Update step exit code in run state
-    try {
-      const currentRun = JSON.parse(readFileSync(join(cwd, RUNS_DIR, `${runId}.json`), 'utf-8'));
-      if (currentRun.steps[stepDef.name]) {
-        currentRun.steps[stepDef.name].exitCode = code;
+    // Inject pipeline context
+    prompt = `[Pipeline: ${run.pipelineName}, Step: ${stepDef.name}, Run: ${runId}]\n\nTask:\n${prompt}\n\nWhen finished, call signal_step_complete with step_name "${stepDef.name}" and run_id "${runId}".`;
+
+    const args = [
+      '-p', prompt,
+      '--output-format', 'stream-json',
+      '--approval-mode', stepDef.approvalMode || 'yolo',
+    ];
+
+    if (skill) {
+      // Skills can be active via prompt injection, as we do for scheduled tasks
+      args[1] = `Activate skill "${skill}" first.\n\n${args[1]}`;
+    }
+    if (policy) {
+      args.push('--policy', policy);
+    }
+    if (groupConfig.include_dirs?.length > 0) {
+      for (const dir of groupConfig.include_dirs) {
+        args.push('--include-directories', dir);
       }
-      writeFileSync(join(cwd, RUNS_DIR, `${runId}.json`), JSON.stringify(currentRun, null, 2));
-    } catch { /* ignore */ }
-    console.error(`[pipeline] Step "${stepDef.name}" exited (code: ${code}, run: ${runId})`);
-  });
+    }
 
-  child.stdin.end();
-  child.unref();
+    let spawnCmd, spawnArgs, spawnOpts;
+    if (isRemote) {
+      const ssh = buildSshSpawn(runner, args, run.cwd || 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: run.cwd || cwd,
+        env: {
+          ...process.env,
+          TERM: 'dumb',
+          CI: '1',
+          AGENT_POOL_DEPTH: String(currentDepth + 1)
+        },
+        stdio: ['pipe', 'pipe', 'pipe'],
+        detached: true,
+      };
+      if (count > 1) spawnOpts.env.AGENT_INDEX = String(i);
+    }
+
+    const child = spawn(spawnCmd, spawnArgs, spawnOpts);
+
+    child.on('close', (code) => {
+      // Update step exit code in run state
+      try {
+        const currentRun = JSON.parse(readFileSync(join(cwd, RUNS_DIR, `${runId}.json`), 'utf-8'));
+        if (currentRun.steps[stepDef.name]) {
+          // If any child fails, set exit code to non-zero
+          if (code !== 0) {
+             currentRun.steps[stepDef.name].exitCode = code;
+          } else if (currentRun.steps[stepDef.name].exitCode === null) {
+             currentRun.steps[stepDef.name].exitCode = 0;
+          }
+        }
+        writeFileSync(join(cwd, RUNS_DIR, `${runId}.json`), JSON.stringify(currentRun, null, 2));
+      } catch { /* ignore */ }
+      console.error(`[pipeline] Step "${stepDef.name}" [pid ${child.pid}] exited (code: ${code}, run: ${runId})`);
+    });
+
+    child.stdin.end();
+    child.unref();
 
-  console.error(`[pipeline] Started step "${stepDef.name}" → pid ${child.pid} (run: ${runId})`);
-  return child.pid;
+    console.error(`[pipeline] Started step "${stepDef.name}" → pid ${child.pid} (run: ${runId})`);
+    pids.push(child.pid);
+  }
+
+  return pids;
 }
 
+
 /**
  * Check if a process is alive.
  * @param {number} pid
@@ -261,33 +324,67 @@ function tickPipelines() {
       if (step.status === 'bounce_pending') {
         step.status = 'running';
         step.startedAt = new Date().toISOString();
-        step.pid = spawnStep(stepDef, run, runId, step.lastBounceReason);
+        const pids = spawnStep(stepDef, run, runId, step.lastBounceReason);
+        step.pids = pids;
+        if (pids.length > 0) step.pid = pids[0];
         modified = true;
         continue;
       }
 
       // ── Handle running steps: check if process died ──
-      if (step.status === 'running' && step.pid) {
-        if (!isAlive(step.pid)) {
-          // Process is dead — did agent signal?
-          if (!step.signaled) {
-            // Auto-fallback: check exit code
-            if (step.exitCode === 0 || step.exitCode === null) {
-              // Treat as success (agent forgot to signal)
-              step.status = 'success';
-              step.completedAt = new Date().toISOString();
-              console.error(`[pipeline] Step "${stepDef.name}" auto-completed (pid dead, exit: ${step.exitCode})`);
-            } else {
-              // Failed
-              step.status = 'failed';
-              step.completedAt = new Date().toISOString();
-              console.error(`[pipeline] Step "${stepDef.name}" failed (exit: ${step.exitCode})`);
-              if (pipeline.onError === 'stop') {
-                run.status = 'failed';
-                run.completedAt = new Date().toISOString();
-              }
+      if (step.status === 'running') {
+        const pids = step.pids?.length > 0 ? step.pids : (step.pid ? [step.pid] : []);
+        if (pids.length === 0) continue;
+
+        let livingPids = 0;
+        for (const pid of pids) if (isAlive(pid)) livingPids++;
+
+        const isParallel = pids.length > 1;
+
+        if (isParallel) {
+          // Parallel semantics: rely entirely on exit codes
+          if (step.exitCode !== null && step.exitCode !== 0) {
+            // Fail fast: kill siblings
+            for (const pid of pids) if (isAlive(pid)) killGroup(pid);
+            step.status = 'failed';
+            step.completedAt = new Date().toISOString();
+            console.error(`[pipeline] Step "${stepDef.name}" parallel failed (exit: ${step.exitCode})`);
+            if (pipeline.onError === 'stop') {
+              run.status = 'failed';
+              run.completedAt = new Date().toISOString();
             }
             modified = true;
+          } else if (livingPids === 0) {
+            // All dead and no errors
+            step.status = 'success';
+            step.completedAt = new Date().toISOString();
+            console.error(`[pipeline] Step "${stepDef.name}" parallel completed successfully`);
+            modified = true;
+          }
+        } else {
+          // Sequential semantics (count 1)
+          const pid = pids[0];
+          if (!isAlive(pid)) {
+            // Process is dead — did agent signal?
+            if (!step.signaled) {
+              // Auto-fallback: check exit code
+              if (step.exitCode === 0 || step.exitCode === null) {
+                // Treat as success (agent forgot to signal)
+                step.status = 'success';
+                step.completedAt = new Date().toISOString();
+                console.error(`[pipeline] Step "${stepDef.name}" auto-completed (pid dead, exit: ${step.exitCode})`);
+              } else {
+                // Failed
+                step.status = 'failed';
+                step.completedAt = new Date().toISOString();
+                console.error(`[pipeline] Step "${stepDef.name}" failed (exit: ${step.exitCode})`);
+                if (pipeline.onError === 'stop') {
+                  run.status = 'failed';
+                  run.completedAt = new Date().toISOString();
+                }
+              }
+              modified = true;
+            }
           }
         }
         continue;
@@ -324,7 +421,9 @@ function tickPipelines() {
         if (shouldStart && run.status === 'running') {
           step.status = 'running';
           step.startedAt = new Date().toISOString();
-          step.pid = spawnStep(stepDef, run, runId);
+          const pids = spawnStep(stepDef, run, runId);
+          step.pids = pids;
+          if (pids.length > 0) step.pid = pids[0];
           modified = true;
         }
       }
@@ -335,7 +434,9 @@ function tickPipelines() {
         if (depStepName && run.steps[depStepName]?.status === 'success') {
           step.status = 'running';
           step.startedAt = new Date().toISOString();
-          step.pid = spawnStep(stepDef, run, runId);
+          const pids = spawnStep(stepDef, run, runId);
+          step.pids = pids;
+          if (pids.length > 0) step.pid = pids[0];
           modified = true;
         }
       }

package/src/scheduler/pipeline.js

@@ -11,6 +11,7 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, unlink
 import { join, dirname } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { ensureDaemon } from './scheduler.js';
+import { killGroup } from '../runner/process-manager.js';
 
 const PIPELINES_DIR = '.agents/pipelines';
 const RUNS_DIR = '.agents/runs';
@@ -69,6 +70,8 @@ export function createPipeline(cwd, { name, steps, onError }) {
       name: s.name,
       prompt: s.prompt,
       skill: s.skill || null,
+      group: s.group || null,
+      count: s.count ? parseInt(s.count, 10) : 1,
       approvalMode: s.approval_mode || 'yolo',
       timeout: s.timeout || 600,
       maxBounces: s.maxBounces ?? s.max_bounces ?? 2,
@@ -134,7 +137,8 @@ export function runPipeline(cwd, pipelineId) {
   for (const step of pipeline.steps) {
     steps[step.name] = {
       status: 'pending',
-      pid: null,
+      pid: null,     // Legacy / single pid
+      pids: [],      // Array for parallel execution
       exitCode: null,
       signaled: false,
       bounces: 0,
@@ -219,8 +223,13 @@ export function cancelRun(cwd, runId) {
 
   // Kill any running step
   for (const [name, step] of Object.entries(run.steps)) {
-    if (step.status === 'running' && step.pid) {
-      try { process.kill(step.pid, 'SIGTERM'); } catch { /* already dead */ }
+    if (step.status === 'running') {
+      const pidsToKill = [...(step.pids || [])];
+      if (step.pid && !pidsToKill.includes(step.pid)) pidsToKill.push(step.pid);
+
+      for (const pid of pidsToKill) {
+        killGroup(pid);
+      }
       step.status = 'cancelled';
     }
     if (step.status === 'pending') {
@@ -332,7 +341,16 @@ export function bounceBack(cwd, targetStepName, reason, runId) {
       targetStep.status = 'bounce_pending';
       targetStep.bounces += 1;
       targetStep.lastBounceReason = reason;
+
+      // Fail-fast: kill any remaining running agents for this step
+      const pidsToKill = [...(targetStep.pids || [])];
+      if (targetStep.pid && !pidsToKill.includes(targetStep.pid)) pidsToKill.push(targetStep.pid);
+      for (const pid of pidsToKill) {
+        killGroup(pid);
+      }
+
       targetStep.pid = null;
+      targetStep.pids = [];
       targetStep.exitCode = null;
       targetStep.signaled = false;
 

package/src/server.js

@@ -112,7 +112,7 @@ export function createServer() {
   }
 
   const server = new Server(
-    { name: 'agent-pool', version: '1.5.0' },
+    { name: 'agent-pool', version: '1.6.0' },
     { capabilities: { tools: {}, resources: {} } },
   );