@ai-devkit/agent-manager 0.19.0 → 0.19.1

package/src/adapters/GeminiCliAdapter.ts

@@ -22,11 +22,11 @@ import type {
     ListSessionsOptions,
 } from './AgentAdapter.js';
 import { AgentStatus } from './AgentAdapter.js';
-import { listAgentProcesses, enrichProcesses } from '../utils/process.js';
+import { listAgentProcesses, enrichProcesses, findWrapperProcess, findWrapperProcessPids } from '../utils/process.js';
 import { isDirectory, safeReadFile, safeReaddir, safeStat } from '../utils/session.js';
 import type { SessionFile } from '../utils/session.js';
 import { matchProcessesToSessions, generateAgentName } from '../utils/matching.js';
-import { AgentRegistry } from '../utils/AgentRegistry.js';
+import { AgentRegistry, type RegistryEntry } from '../utils/AgentRegistry.js';
 
 /**
  * A single Gemini CLI message content part. Mirrors the `{text?: string}`
@@ -117,40 +117,70 @@ export class GeminiCliAdapter implements AgentAdapter {
         const processes = nodeProcesses.filter((proc) => this.isGeminiExecutable(proc.command));
         if (processes.length === 0) return [];
 
-        const { cachedAgents, remaining } = this.tryRegistryCache(processes);
+        const wrapperPids = findWrapperProcessPids(processes);
+        const { cachedAgents, remaining } = this.tryRegistryCache(processes, wrapperPids);
         if (remaining.length === 0) return this.deduplicateSessionAgents(cachedAgents);
 
-        const { sessions, contentCache } = this.discoverSessions(remaining);
+        const candidateProcesses = remaining.filter((proc) => !wrapperPids.has(proc.pid));
+        const registryEntriesByPid = new Map(this.registry.list().map((entry) => [entry.pid, entry]));
+
+        const { sessions, contentCache } = this.discoverSessions(candidateProcesses);
         if (sessions.length === 0) {
+            const processOnlyAgents = candidateProcesses.map((proc) => {
+                const agent = this.mapProcessOnlyAgent(proc);
+                this.applyWrapperRegistryName(agent, proc, processes, registryEntriesByPid);
+                return agent;
+            });
+
             return this.deduplicateSessionAgents([
                 ...cachedAgents,
-                ...remaining.map((p) => this.mapProcessOnlyAgent(p)),
+                ...processOnlyAgents,
             ]);
         }
 
-        const matches = matchProcessesToSessions(remaining, sessions);
+        const matches = matchProcessesToSessions(candidateProcesses, sessions);
         const matchedPids = new Set(matches.map((m) => m.process.pid));
+        const matchedProcesses: ProcessInfo[] = [];
         const agents: AgentInfo[] = [];
 
         for (const match of matches) {
             const cachedContent = contentCache.get(match.session.filePath);
             const sessionData = this.parseSession(cachedContent, match.session.filePath);
             if (sessionData) {
-                agents.push(this.mapSessionToAgent(sessionData, match.process, match.session.filePath));
+                const agent = this.mapSessionToAgent(sessionData, match.process, match.session.filePath);
+                this.applyWrapperRegistryName(agent, match.process, processes, registryEntriesByPid);
+                agents.push(agent);
+                matchedProcesses.push(match.process);
             } else {
                 matchedPids.delete(match.process.pid);
             }
         }
 
-        for (const proc of remaining) {
-            if (!matchedPids.has(proc.pid)) {
-                agents.push(this.mapProcessOnlyAgent(proc));
+        const matchedWrapperPids = findWrapperProcessPids(candidateProcesses, matchedProcesses);
+        for (const proc of candidateProcesses) {
+            if (!matchedPids.has(proc.pid) && !matchedWrapperPids.has(proc.pid)) {
+                const agent = this.mapProcessOnlyAgent(proc);
+                this.applyWrapperRegistryName(agent, proc, processes, registryEntriesByPid);
+                agents.push(agent);
             }
         }
 
         return this.deduplicateSessionAgents([...cachedAgents, ...agents]);
     }
 
+    private applyWrapperRegistryName(
+        agent: AgentInfo,
+        processInfo: ProcessInfo,
+        processes: ProcessInfo[],
+        registryEntriesByPid: Map<number, RegistryEntry>,
+    ): void {
+        const wrapper = findWrapperProcess(processes, processInfo);
+        const wrapperEntry = wrapper ? registryEntriesByPid.get(wrapper.pid) : undefined;
+        if (wrapperEntry?.type === this.type) {
+            agent.name = wrapperEntry.name;
+        }
+    }
+
     private deduplicateSessionAgents(agents: AgentInfo[]): AgentInfo[] {
         const bySession = new Map<string, AgentInfo>();
         const result: AgentInfo[] = [];
@@ -187,7 +217,7 @@ export class GeminiCliAdapter implements AgentAdapter {
         return null;
     }
 
-    private tryRegistryCache(processes: ProcessInfo[]): {
+    private tryRegistryCache(processes: ProcessInfo[], wrapperPids: Set<number>): {
         cachedAgents: AgentInfo[];
         remaining: ProcessInfo[];
     } {
@@ -198,6 +228,7 @@ export class GeminiCliAdapter implements AgentAdapter {
         for (const proc of processes) {
             const entry = byPid.get(proc.pid);
             if (
+                wrapperPids.has(proc.pid) ||
                 !entry ||
                 entry.type !== this.type ||
                 !entry.sessionFilePath ||

package/src/utils/process.ts

@@ -12,10 +12,10 @@ import type { ProcessInfo } from '../adapters/AgentAdapter.js';
 /**
  * List running processes matching an agent executable name.
  *
- * Uses `ps aux` then filters in JS for exact executable basename match.
+ * Uses `ps -axo` then filters in JS for exact executable basename match.
  * This avoids shell pipelines and string interpolation.
  *
- * Returned ProcessInfo has pid, command, tty populated.
+ * Returned ProcessInfo has pid, ppid, command, tty populated.
  * cwd and startTime are NOT populated — call enrichProcesses() to fill them.
  */
 export function listAgentProcesses(namePattern: string): ProcessInfo[] {
@@ -25,7 +25,7 @@ export function listAgentProcesses(namePattern: string): ProcessInfo[] {
     }
 
     try {
-        const output = execFileSync('ps', ['aux'], { encoding: 'utf-8' });
+        const output = execFileSync('ps', ['-axo', 'pid=,ppid=,tty=,command='], { encoding: 'utf-8' });
 
         const lowerPattern = namePattern.toLowerCase();
         const processes: ProcessInfo[] = [];
@@ -33,14 +33,15 @@ export function listAgentProcesses(namePattern: string): ProcessInfo[] {
         for (const line of output.trim().split('\n')) {
             if (!line.trim()) continue;
 
-            const parts = line.trim().split(/\s+/);
-            if (parts.length < 11) continue;
+            const match = line.match(/^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/);
+            if (!match) continue;
 
-            const pid = parseInt(parts[1], 10);
-            if (Number.isNaN(pid)) continue;
+            const pid = parseInt(match[1], 10);
+            const ppid = parseInt(match[2], 10);
+            if (Number.isNaN(pid) || Number.isNaN(ppid)) continue;
 
-            const tty = parts[6];
-            const command = parts.slice(10).join(' ');
+            const tty = match[3];
+            const command = match[4];
 
             // Check that the executable basename matches exactly
             const executable = command.trim().split(/\s+/)[0] || '';
@@ -53,6 +54,7 @@ export function listAgentProcesses(namePattern: string): ProcessInfo[] {
 
             processes.push({
                 pid,
+                ppid,
                 command,
                 cwd: '',
                 tty: ttyShort,
@@ -177,6 +179,59 @@ export function enrichProcesses(processes: ProcessInfo[]): ProcessInfo[] {
     return processes;
 }
 
+function isSameTerminalProcess(proc: ProcessInfo, matched: ProcessInfo): boolean {
+    const sameTty = proc.tty !== '' && proc.tty !== '?' && proc.tty === matched.tty;
+    const sameCwd = proc.cwd !== '' && proc.cwd === matched.cwd;
+
+    return sameTty && (sameCwd || proc.cwd === '' || matched.cwd === '');
+}
+
+function matchesProcessIdentity(proc: ProcessInfo, matched: ProcessInfo): boolean {
+    return proc.pid === matched.pid || isSameTerminalProcess(proc, matched);
+}
+
+export function findWrapperProcess(
+    processes: ProcessInfo[],
+    child: ProcessInfo,
+): ProcessInfo | undefined {
+    return processes.find((proc) => (
+        proc.pid !== child.pid &&
+        child.ppid === proc.pid &&
+        matchesProcessIdentity(proc, child)
+    ));
+}
+
+/**
+ * Find parent wrapper processes that should not be reported as separate agents.
+ *
+ * A process is considered a wrapper when it is the parent of another candidate
+ * agent process in the same terminal/worktree, or when it points at the same
+ * terminal/worktree as an already session-matched process.
+ */
+export function findWrapperProcessPids(
+    processes: ProcessInfo[],
+    matchedProcesses: ProcessInfo[] = [],
+): Set<number> {
+    const wrappers = new Set<number>();
+
+    for (const child of processes) {
+        const wrapper = findWrapperProcess(processes, child);
+        if (wrapper) {
+            wrappers.add(wrapper.pid);
+        }
+    }
+
+    for (const proc of processes) {
+        if (matchedProcesses.some((matched) => (
+            proc.pid !== matched.pid && isSameTerminalProcess(proc, matched)
+        ))) {
+            wrappers.add(proc.pid);
+        }
+    }
+
+    return wrappers;
+}
+
 /**
  * Get the TTY device for a specific process
  */