@ai-devkit/agent-manager 0.18.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/terminal/TerminalFocusManager.ts

@@ -98,8 +98,8 @@ export class TerminalFocusManager {
 
     private async findITerm2Session(tty: string): Promise<TerminalLocation | null> {
         try {
-            // Check if iTerm2 is running first to avoid launching it
-            await execFileAsync('pgrep', ['-x', 'iTerm2']);
+            // Check if iTerm2 is running first to avoid launching it.
+            if (!await this.isProcessRunning('iTerm2')) return null;
         } catch {
             return null;
         }
@@ -137,7 +137,7 @@ export class TerminalFocusManager {
     private async findTerminalAppWindow(tty: string): Promise<TerminalLocation | null> {
         try {
             // Check if Terminal.app is running
-            await execFileAsync('pgrep', ['-x', 'Terminal']);
+            if (!await this.isProcessRunning('Terminal')) return null;
         } catch {
             return null;
         }
@@ -170,6 +170,14 @@ export class TerminalFocusManager {
         return null;
     }
 
+    private async isProcessRunning(name: string): Promise<boolean> {
+        const { stdout } = await execFileAsync('ps', ['-Axo', 'comm']);
+        return stdout
+            .split('\n')
+            .map((line) => line.trim())
+            .some((command) => command === name || command.endsWith(`/${name}`));
+    }
+
     private async focusTmuxPane(identifier: string): Promise<boolean> {
         try {
             await execFileAsync('tmux', ['switch-client', '-t', identifier]);

package/src/utils/agents.ts

@@ -1,7 +1,7 @@
 import path from 'path';
 import type { AgentType } from '../adapters/AgentAdapter.js';
 
-export type StartableAgentType = Extract<AgentType, 'claude' | 'codex' | 'gemini_cli' | 'opencode'>;
+export type StartableAgentType = Extract<AgentType, 'claude' | 'codex' | 'copilot' | 'gemini_cli' | 'opencode' | 'pi'>;
 
 export interface AgentConfig {
     /** Shell command to launch the agent (sent to tmux via `send-keys`). */
@@ -18,8 +18,10 @@ export interface AgentConfig {
 export const AGENTS: Record<StartableAgentType, AgentConfig> = {
     claude:     { command: 'claude',   matches: matchArgv0('claude') },
     codex:      { command: 'codex',    matches: matchArgv0('codex') },
-    opencode:   { command: 'opencode', matches: matchArgv0('opencode') },
+    copilot:    { command: 'copilot',  matches: matchArgv0Name('copilot-cli') },
     gemini_cli: { command: 'gemini',   matches: matchAnyToken('gemini') },
+    opencode:   { command: 'opencode', matches: matchArgv0('opencode') },
+    pi:         { command: 'pi',       matches: matchAnyBasename(['pi']) },
 };
 
 function matchArgv0(name: string): (psCommand: string) => boolean {
@@ -30,6 +32,14 @@ function matchArgv0(name: string): (psCommand: string) => boolean {
     };
 }
 
+function matchArgv0Name(name: string): (psCommand: string) => boolean {
+    const lower = name.toLowerCase();
+    return (psCommand) => {
+        const token = psCommand.trim().split(/\s+/)[0];
+        return token ? token.toLowerCase().includes(lower) : false;
+    };
+}
+
 function matchAnyToken(name: string): (psCommand: string) => boolean {
     const lower = name.toLowerCase();
     return (psCommand) => {
@@ -39,3 +49,13 @@ function matchAnyToken(name: string): (psCommand: string) => boolean {
         return false;
     };
 }
+
+function matchAnyBasename(names: string[]): (psCommand: string) => boolean {
+    const lowers = new Set(names.map((name) => name.toLowerCase()));
+    return (psCommand) => {
+        for (const token of psCommand.trim().split(/\s+/)) {
+            if (lowers.has(path.basename(token).toLowerCase())) return true;
+        }
+        return false;
+    };
+}

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
  */