@yemi33/minions 0.1.2383 → 0.1.2384

package/engine/process-utils.js

@@ -14,7 +14,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { execSync: _execSync } = require('child_process');
+const { execSync: _execSync, execFile: _execFile } = require('child_process');
 
 // Shared.js-local PID liveness check, moved here unchanged. Avoids a circular
 // require on engine/cli.js (which has its own isPidAlive) and engine/timeout.js
@@ -24,7 +24,12 @@ const { execSync: _execSync } = require('child_process');
 function isPidAlive(pid) {
   if (!Number.isFinite(pid) || pid <= 0) return false;
   try { process.kill(pid, 0); return true; }
-  catch { return false; }
+  catch (err) {
+    // Signal 0 returning EPERM means the process exists but this caller cannot
+    // inspect it. Treating that as dead lets lock recovery delete a live
+    // holder's lock and breaks cross-process mutual exclusion.
+    return err && err.code === 'EPERM';
+  }
 }
 
 // ─── Cross-Platform Process Kill Helpers ─────────────────────────────────────
@@ -206,6 +211,7 @@ function _parseWmicCsv(text) {
   const ppidIdx = idx('ParentProcessId');
   const pidIdx = idx('ProcessId');
   const cmdIdx = idx('CommandLine');
+  const creationIdx = idx('CreationDate');
   if (nameIdx < 0 || ppidIdx < 0 || pidIdx < 0) return [];
   const out = [];
   for (let i = 1; i < lines.length; i++) {
@@ -218,28 +224,31 @@ function _parseWmicCsv(text) {
     const ppid = parseInt(cols[ppidIdx], 10);
     const name = cols[nameIdx] || '';
     const cmd = cmdIdx >= 0 ? cols.slice(cmdIdx).join(',') : '';
-    out.push({ pid, ppid: Number.isInteger(ppid) ? ppid : 0, name, cmd });
+    const created = creationIdx >= 0
+      ? String(cols[creationIdx] || '').match(/^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})\.(\d{3})\d{3}([+-]\d{3})$/)
+      : null;
+    const startedAt = created
+      ? Date.UTC(
+        Number(created[1]), Number(created[2]) - 1, Number(created[3]),
+        Number(created[4]), Number(created[5]), Number(created[6]), Number(created[7])
+      ) - Number(created[8]) * 60000
+      : 0;
+    out.push({ pid, ppid: Number.isInteger(ppid) ? ppid : 0, name, cmd, startedAt });
   }
   return out;
 }
 
+const PROCESS_LIST_PS_SCRIPT = "Get-CimInstance Win32_Process | ForEach-Object { [PSCustomObject]@{ Name = $_.Name; ParentProcessId = $_.ParentProcessId; ProcessId = $_.ProcessId; CommandLine = $_.CommandLine; StartedAt = if ($_.CreationDate) { [int64](([datetimeoffset]$_.CreationDate).ToUnixTimeMilliseconds()) } else { 0 } } } | ConvertTo-Json -Compress -Depth 2";
+
 // PowerShell Get-CimInstance is the modern path (wmic is removed on Win11
 // 24H2+). We try it first and fall back to wmic for older Windows hosts.
 function _psListProcesses() {
-  const script = "Get-CimInstance Win32_Process | Select-Object Name,ParentProcessId,ProcessId,CommandLine | ConvertTo-Json -Compress -Depth 2";
   try {
     const out = _execSync(
-      `powershell -NoProfile -NonInteractive -Command "${script}"`,
+      `powershell -NoProfile -NonInteractive -Command "${PROCESS_LIST_PS_SCRIPT}"`,
       { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 4000, windowsHide: true, maxBuffer: 4 * 1024 * 1024 }
     );
-    const parsed = JSON.parse(out);
-    const arr = Array.isArray(parsed) ? parsed : [parsed];
-    return arr.map(p => ({
-      pid: Number(p.ProcessId),
-      ppid: Number(p.ParentProcessId) || 0,
-      name: p.Name || '',
-      cmd: p.CommandLine || '',
-    })).filter(p => Number.isInteger(p.pid) && p.pid > 0);
+    return _parsePowerShellProcesses(out);
   } catch { return null; }
 }
 
@@ -261,11 +270,7 @@ function _unixListProcesses() {
       'ps -A -o pid=,ppid=,comm=',
       { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000 }
     );
-    return out.split(/\r?\n/).map(line => {
-      const m = line.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
-      if (!m) return null;
-      return { pid: parseInt(m[1], 10), ppid: parseInt(m[2], 10), name: m[3], cmd: '' };
-    }).filter(Boolean);
+    return _parseUnixProcesses(out);
   } catch { return []; }
 }
 
@@ -273,6 +278,103 @@ function listAllProcesses() {
   return process.platform === 'win32' ? _winListProcesses() : _unixListProcesses();
 }
 
+function _parsePowerShellProcesses(out) {
+  const parsed = JSON.parse(out);
+  const arr = Array.isArray(parsed) ? parsed : [parsed];
+  return arr.map(p => ({
+    pid: Number(p.ProcessId),
+    ppid: Number(p.ParentProcessId) || 0,
+    name: p.Name || '',
+    cmd: p.CommandLine || '',
+    startedAt: Number(p.StartedAt) || 0,
+  })).filter(p => Number.isInteger(p.pid) && p.pid > 0);
+}
+
+function _parseUnixProcesses(out) {
+  return out.split(/\r?\n/).map(line => {
+    const m = line.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
+    if (!m) return null;
+    return { pid: parseInt(m[1], 10), ppid: parseInt(m[2], 10), name: m[3], cmd: '' };
+  }).filter(Boolean);
+}
+
+function _parseUnixProcessesWithStart(out) {
+  return out.split(/\r?\n/).map(line => {
+    const m = line.trim().match(/^(\d+)\s+(\d+)\s+(.{24})\s+(.*)$/);
+    if (!m) return null;
+    const startedAt = Date.parse(m[3].trim());
+    return {
+      pid: parseInt(m[1], 10),
+      ppid: parseInt(m[2], 10),
+      name: m[4],
+      cmd: '',
+      startedAt: Number.isNaN(startedAt) ? 0 : startedAt,
+    };
+  }).filter(Boolean);
+}
+
+async function _applyLinuxStartTicks(processes) {
+  if (process.platform !== 'linux') return processes;
+  await Promise.all(processes.map(async (entry) => {
+    try {
+      const stat = await fs.promises.readFile(`/proc/${entry.pid}/stat`, 'utf8');
+      const fields = stat.slice(stat.lastIndexOf(') ') + 2).trim().split(/\s+/);
+      const startTicks = Number(fields[19]);
+      entry.startedAt = Number.isFinite(startTicks) && startTicks > 0 ? startTicks : 0;
+    } catch {
+      entry.startedAt = 0;
+    }
+  }));
+  return processes;
+}
+
+function _execFileText(file, args, opts) {
+  return new Promise((resolve, reject) => {
+    _execFile(file, args, opts, (err, stdout) => {
+      if (err) reject(err);
+      else resolve(stdout);
+    });
+  });
+}
+
+async function listAllProcessesAsync() {
+  if (process.platform === 'win32') {
+    try {
+      const out = await _execFileText(
+        'powershell',
+        ['-NoProfile', '-NonInteractive', '-Command', PROCESS_LIST_PS_SCRIPT],
+        { encoding: 'utf8', windowsHide: true, timeout: 4000, maxBuffer: 4 * 1024 * 1024 }
+      );
+      const parsed = _parsePowerShellProcesses(out);
+      if (parsed.length > 0) return parsed;
+    } catch { /* fall through to wmic */ }
+    try {
+      const out = await _execFileText(
+        'wmic',
+        ['process', 'get', 'CreationDate,Name,ParentProcessId,ProcessId', '/format:csv'],
+        { encoding: 'utf8', windowsHide: true, timeout: 4000, maxBuffer: 4 * 1024 * 1024 }
+      );
+      return _parseWmicCsv(out);
+    } catch {
+      return [];
+    }
+  }
+  try {
+    const out = await _execFileText(
+      'ps',
+      ['-A', '-o', 'pid=,ppid=,lstart=,comm='],
+      {
+        encoding: 'utf8',
+        timeout: 5000,
+        env: { ...process.env, LC_ALL: 'C', LANG: 'C' },
+      }
+    );
+    return await _applyLinuxStartTicks(_parseUnixProcessesWithStart(out));
+  } catch {
+    return [];
+  }
+}
+
 // W-mq6f2fe0000557fa — orphan-worktree GC: identify OS processes whose cwd
 // is at or inside `dir`. Cross-platform with a fail-open contract: on any
 // error or timeout we return [] (the caller continues with its existing
@@ -315,6 +417,7 @@ function findProcessesWithCwdInside(dir, opts = {}) {
     if (process.platform === 'win32') {
       return _findWindowsProcessesWithCwdInside(resolved, timeoutMs, now);
     }
+
     if (process.platform === 'linux') {
       return _findLinuxProcessesWithCwdInside(resolved, timeoutMs, now);
     }
@@ -322,6 +425,37 @@ function findProcessesWithCwdInside(dir, opts = {}) {
   } catch { return []; }
 }
 
+async function findProcessesWithCwdInsideAsync(dir, opts = {}) {
+  const timeoutMs = Number(opts.timeoutMs) > 0 ? Number(opts.timeoutMs) : 5000;
+  const script = [
+    'const utils = require(process.argv[1]);',
+    '(async () => {',
+    'const timeoutMs = Number(process.argv[3]);',
+    "const rows = process.platform === 'win32'",
+    '? utils.findProcessCwdHolders(process.argv[2], { timeoutMs })',
+    ': utils.findProcessesWithCwdInside(process.argv[2], { timeoutMs });',
+    'const processes = await utils.listAllProcessesAsync();',
+    'const byPid = new Map(processes.map((entry) => [Number(entry.pid), entry]));',
+    'const enriched = rows.map((entry) => ({',
+    '...entry, startedAt: Number(byPid.get(Number(entry.pid))?.startedAt) || 0,',
+    '})).filter((entry) => entry.startedAt > 0);',
+    'process.stdout.write(JSON.stringify(enriched));',
+    '})().catch((err) => { console.error(err.message); process.exitCode = 1; });',
+  ].join('');
+  const out = await _execFileText(
+    process.execPath,
+    ['-e', script, __filename, String(dir || ''), String(timeoutMs)],
+    {
+      encoding: 'utf8',
+      timeout: timeoutMs + 2000,
+      windowsHide: true,
+      maxBuffer: 4 * 1024 * 1024,
+    }
+  );
+  const parsed = JSON.parse(out || '[]');
+  return Array.isArray(parsed) ? parsed : [];
+}
+
 function _findWindowsProcessesWithCwdInside(resolved, timeoutMs, now) {
   // Win32_Process exposes CommandLine but not the cwd. Match by basename of
   // the worktree dir (the dispatch id like W-mq1k8z6o003acd89) appearing in
@@ -695,7 +829,9 @@ module.exports = {
   _winListProcesses,
   _unixListProcesses,
   listAllProcesses,
+  listAllProcessesAsync,
   findProcessesWithCwdInside,
+  findProcessesWithCwdInsideAsync,
   _findWindowsProcessesWithCwdInside,
   _findLinuxProcessesWithCwdInside,
   _findMacProcessesWithCwdInside,

package/engine/runtimes/copilot.js

@@ -32,7 +32,7 @@ const https = require('https');
 const os = require('os');
 const path = require('path');
 const { execSync } = require('child_process');
-const { FAILURE_CLASS, safeWrite, ts, resolveEngineCacheDir } = require('../shared');
+const { ENGINE_DEFAULTS, FAILURE_CLASS, safeWrite, ts, resolveEngineCacheDir } = require('../shared');
 
 const ENGINE_DIR = __dirname.replace(/[\\/]runtimes$/, '');
 const _CACHE_DIR = resolveEngineCacheDir(ENGINE_DIR);
@@ -568,7 +568,8 @@ function resolveInvocationOptions({
   const resolved = { ...options };
   if (resolved.stream == null) resolved.stream = engineConfig.copilotStreamMode;
   if (resolved.disableBuiltinMcps == null) {
-    resolved.disableBuiltinMcps = engineConfig.copilotDisableBuiltinMcps;
+    resolved.disableBuiltinMcps = engineConfig.copilotDisableBuiltinMcps
+      ?? ENGINE_DEFAULTS.copilotDisableBuiltinMcps;
   }
   if (resolved.reasoningSummaries == null) {
     resolved.reasoningSummaries = engineConfig.copilotReasoningSummaries;
@@ -576,6 +577,11 @@ function resolveInvocationOptions({
   if (failureClass === FAILURE_CLASS.MODEL_UNAVAILABLE && engineConfig.copilotFallbackModel) {
     resolved.model = engineConfig.copilotFallbackModel;
   }
+  if (Array.isArray(resolved.disabledMcpServers)) {
+    resolved.disabledMcpServers = [...new Set(
+      resolved.disabledMcpServers.filter(Boolean).map(String)
+    )].sort();
+  }
   return resolved;
 }
 
@@ -588,8 +594,20 @@ function shouldSuppressPostMutationError({ mutationApplied, error } = {}) {
   return error.errorClass === 'unknown-model' || error.errorClass === 'model-unavailable';
 }
 
-function buildWorkerArgs() {
-  return ['--acp', '--allow-all', '--max-autopilot-continues', '1'];
+function buildWorkerArgs(options = {}) {
+  const maxTurns = Number(options.maxTurns);
+  const args = [
+    '--acp',
+    '--allow-all',
+    '--max-autopilot-continues',
+    String(Number.isFinite(maxTurns) && maxTurns > 0 ? Math.floor(maxTurns) : 1),
+  ];
+  if (options.disableBuiltinMcps === true) args.push('--disable-builtin-mcps');
+  if (options.reasoningSummaries === true) args.push('--enable-reasoning-summaries');
+  for (const name of options.disabledMcpServers || []) {
+    if (name) args.push('--disable-mcp-server', String(name));
+  }
+  return args;
 }
 
 function encodePooledOutput(event = {}) {