@ai-devkit/agent-manager 0.26.1 → 0.26.3

package/src/adapters/CodexAdapter.ts

@@ -2,8 +2,8 @@
  * Codex Adapter
  *
  * Detects running Codex agents by:
- * 1. Finding running codex processes via shared listAgentProcesses()
- * 2. Enriching with CWD and start times via shared enrichProcesses()
+ * 1. Filtering Codex processes from a shared asynchronous process snapshot
+ * 2. Using snapshot CWD and start-time enrichment
  * 3. Matching exact PID-to-session metadata from ~/.codex/ai-devkit/sessions.json
  * 4. Discovering session files from ~/.codex/sessions/YYYY/MM/DD/ via shared batchGetSessionFileBirthtimes()
  * 5. Setting resolvedCwd from session_meta first line
@@ -20,9 +20,10 @@ import type {
     ConversationMessage,
     SessionSummary,
     ListSessionsOptions,
+    AgentDetectionContext,
 } from './AgentAdapter.js';
 import { AgentStatus } from './AgentAdapter.js';
-import { listAgentProcesses, enrichProcesses } from '../utils/process.js';
+import { captureProcessSnapshot, executableBasename, filterByProcessNames } from '../utils/process.js';
 import { batchGetSessionFileBirthtimes, isDirectory, safeReadFile, safeReaddir, safeStat } from '../utils/session.js';
 import type { SessionFile } from '../utils/session.js';
 import { matchProcessesToSessions, generateAgentName } from '../utils/matching.js';
@@ -88,6 +89,7 @@ interface MappingMatchResult {
 
 export class CodexAdapter implements AgentAdapter {
     readonly type = 'codex' as const;
+    readonly processNames = ['codex'] as const;
 
     private static readonly IDLE_THRESHOLD_MINUTES = 5;
     /** Include session files around process start day to recover long-lived processes. */
@@ -111,8 +113,10 @@ export class CodexAdapter implements AgentAdapter {
     /**
      * Detect running Codex agents
      */
-    async detectAgents(): Promise<AgentInfo[]> {
-        const processes = enrichProcesses(listAgentProcesses('codex'));
+    async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+        const snapshot = context?.processes ?? await captureProcessSnapshot(this.processNames);
+        const relevant = filterByProcessNames(snapshot, this.processNames);
+        const processes = relevant.filter((process) => this.canHandle(process));
         if (processes.length === 0) return [];
 
         const { cachedAgents, remaining } = this.tryRegistryCache(processes);
@@ -657,8 +661,7 @@ export class CodexAdapter implements AgentAdapter {
     }
 
     private isCodexExecutable(command: string): boolean {
-        const executable = command.trim().split(/\s+/)[0] || '';
-        const base = path.basename(executable).toLowerCase();
+        const base = executableBasename(command);
         return base === 'codex' || base === 'codex.exe';
     }
 

package/src/adapters/CopilotAdapter.ts

@@ -2,8 +2,8 @@
  * Copilot Adapter
  *
  * Detects running GitHub Copilot CLI agents by:
- * 1. Finding running copilot processes via shared listAgentProcesses()
- * 2. Enriching with CWD and start times via shared enrichProcesses()
+ * 1. Filtering Copilot processes from a shared asynchronous process snapshot
+ * 2. Using snapshot CWD and start-time enrichment
  * 3. Mapping active ~/.copilot/session-state/{sessionId}/inuse.{pid}.lock files to processes
  * 4. Reading events.jsonl as the primary session/conversation source
  * 5. Reading workspace.yaml as a flat fallback metadata source
@@ -17,9 +17,16 @@ import type {
     ListSessionsOptions,
     ProcessInfo,
     SessionSummary,
+    AgentDetectionContext,
 } from './AgentAdapter.js';
 import { AgentStatus } from './AgentAdapter.js';
-import { enrichProcesses, findWrapperProcess, findWrapperProcessPids, listAgentProcesses } from '../utils/process.js';
+import {
+    captureProcessSnapshot,
+    executableBasename,
+    filterByProcessNames,
+    findWrapperProcess,
+    findWrapperProcessPids,
+} from '../utils/process.js';
 import { generateAgentName } from '../utils/matching.js';
 import { isDirectory, safeReadFile, safeReaddir, safeStat } from '../utils/session.js';
 import { AgentRegistry, type RegistryEntry } from '../utils/AgentRegistry.js';
@@ -89,6 +96,7 @@ interface CopilotEventSummary {
 
 export class CopilotAdapter implements AgentAdapter {
     readonly type = 'copilot' as const;
+    readonly processNames = ['copilot'] as const;
 
     private static readonly IDLE_THRESHOLD_MINUTES = 5;
     private static readonly VERBOSE_SYSTEM_EVENTS = new Set([
@@ -120,8 +128,10 @@ export class CopilotAdapter implements AgentAdapter {
         return this.isCopilotExecutable(processInfo.command);
     }
 
-    async detectAgents(): Promise<AgentInfo[]> {
-        const processes = enrichProcesses(listAgentProcesses('copilot'));
+    async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+        const snapshot = context?.processes ?? await captureProcessSnapshot(this.processNames);
+        const relevant = filterByProcessNames(snapshot, this.processNames);
+        const processes = relevant.filter((process) => this.canHandle(process));
         if (processes.length === 0) return [];
 
         const processByPid = new Map(processes.map((proc) => [proc.pid, proc]));
@@ -457,8 +467,7 @@ export class CopilotAdapter implements AgentAdapter {
     }
 
     private isCopilotExecutable(command: string): boolean {
-        const executable = command.trim().split(/\s+/)[0] || '';
-        const base = path.basename(executable).toLowerCase();
+        const base = executableBasename(command);
         return base === 'copilot' || base === 'copilot.exe';
     }
 }

package/src/adapters/GeminiCliAdapter.ts

@@ -2,8 +2,8 @@
  * Gemini CLI Adapter
  *
  * Detects running Gemini CLI agents by:
- * 1. Finding running gemini processes via shared listAgentProcesses()
- * 2. Enriching with CWD and start times via shared enrichProcesses()
+ * 1. Filtering Gemini Node processes from a shared asynchronous process snapshot
+ * 2. Using snapshot CWD and start-time enrichment
  * 3. Discovering session files from ~/.gemini/tmp/<shortId>/chats/session-*.json
  * 4. Matching sessions to processes via shared matchProcessesToSessions()
  *    using sha256(cwd) === session.projectHash as the resolvedCwd source
@@ -20,9 +20,16 @@ import type {
     ConversationMessage,
     SessionSummary,
     ListSessionsOptions,
+    AgentDetectionContext,
 } from './AgentAdapter.js';
 import { AgentStatus } from './AgentAdapter.js';
-import { listAgentProcesses, enrichProcesses, findWrapperProcess, findWrapperProcessPids } from '../utils/process.js';
+import {
+    captureProcessSnapshot,
+    executableBasename,
+    filterByProcessNames,
+    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';
@@ -81,6 +88,7 @@ interface GeminiSession {
 
 export class GeminiCliAdapter implements AgentAdapter {
     readonly type = 'gemini_cli' as const;
+    readonly processNames = ['node'] as const;
 
     private static readonly IDLE_THRESHOLD_MINUTES = 5;
     private static readonly SESSION_FILE_PREFIX = 'session-';
@@ -109,12 +117,13 @@ export class GeminiCliAdapter implements AgentAdapter {
      * binary). The primary running process is therefore the Node runtime
      * itself, and `ps aux` lists it as `node /path/to/gemini ...` with
      * argv[0] = `node`. We scan the Node process pool via the shared
-     * helper and keep only those whose command line references the gemini
+     * snapshot and keep only those whose command line references the gemini
      * executable or script via isGeminiExecutable().
      */
-    async detectAgents(): Promise<AgentInfo[]> {
-        const nodeProcesses = enrichProcesses(listAgentProcesses('node'));
-        const processes = nodeProcesses.filter((proc) => this.isGeminiExecutable(proc.command));
+    async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+        const snapshot = context?.processes ?? await captureProcessSnapshot(this.processNames);
+        const relevant = filterByProcessNames(snapshot, this.processNames);
+        const processes = relevant.filter((process) => this.canHandle(process));
         if (processes.length === 0) return [];
 
         const wrapperPids = findWrapperProcessPids(processes);
@@ -541,7 +550,7 @@ export class GeminiCliAdapter implements AgentAdapter {
         // other adapters' argv[0]-only check because the Node-script
         // distribution puts the real gemini path in argv[1..], not argv[0].
         for (const token of command.trim().split(/\s+/)) {
-            const base = path.basename(token).toLowerCase();
+            const base = executableBasename(token);
             if (base === 'gemini' || base === 'gemini.exe' || base === 'gemini.js') {
                 return true;
             }

package/src/adapters/GrokCliAdapter.ts

@@ -6,9 +6,10 @@ import type {
     ConversationMessage,
     SessionSummary,
     ListSessionsOptions,
+    AgentDetectionContext,
 } from './AgentAdapter.js';
 import { AgentStatus } from './AgentAdapter.js';
-import { listAgentProcesses, enrichProcesses } from '../utils/process.js';
+import { captureProcessSnapshot, executableBasename, filterByProcessNames } from '../utils/process.js';
 import { isDirectory, safeReadFile, safeReaddir, safeStat } from '../utils/session.js';
 import { generateAgentName } from '../utils/matching.js';
 
@@ -16,7 +17,7 @@ import { generateAgentName } from '../utils/matching.js';
  * Grok Build CLI Adapter
  *
  * Detects running Grok Build CLI agents by:
- * 1. Finding running `grok` processes via shared listAgentProcesses() — Grok is
+ * 1. Filtering `grok` processes from a shared asynchronous snapshot — Grok is
  *    a native binary at ~/.grok/bin/grok, so argv[0] basename is `grok`.
  * 2. Resolving each live process to its working directory via
  *    ~/.grok/active_sessions.json, which Grok maintains as a list of
@@ -69,6 +70,7 @@ interface GrokSession {
 
 export class GrokCliAdapter implements AgentAdapter {
     readonly type = 'grok_cli' as const;
+    readonly processNames = ['grok'] as const;
 
     private base: string;
     private sessionsDir: string;
@@ -87,13 +89,14 @@ export class GrokCliAdapter implements AgentAdapter {
     }
 
     private isGrokExecutable(command: string): boolean {
-        const executable = command.trim().split(/\s+/)[0] || '';
-        const base = path.basename(executable).toLowerCase();
+        const base = executableBasename(command);
         return base === 'grok' || base === 'grok.exe';
     }
 
-    async detectAgents(): Promise<AgentInfo[]> {
-        const processes = enrichProcesses(listAgentProcesses('grok'));
+    async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+        const snapshot = context?.processes ?? await captureProcessSnapshot(this.processNames);
+        const relevant = filterByProcessNames(snapshot, this.processNames);
+        const processes = relevant.filter((process) => this.canHandle(process));
         if (processes.length === 0) {
             return [];
         }

package/src/adapters/OpenCodeAdapter.ts

@@ -2,8 +2,8 @@
  * OpenCode Adapter
  *
  * Detects running OpenCode agents by:
- * 1. Finding running opencode processes via shared listAgentProcesses()
- * 2. Enriching with CWD and start times via shared enrichProcesses()
+ * 1. Filtering OpenCode processes from a shared asynchronous process snapshot
+ * 2. Using snapshot CWD and start-time enrichment
  * 3. Querying OpenCode's SQLite DB (~/.local/share/opencode/opencode.db) to
  *    find the session matching each process's CWD and read status from message.time.completed
  *
@@ -21,9 +21,10 @@ import type {
     ConversationMessage,
     SessionSummary,
     ListSessionsOptions,
+    AgentDetectionContext,
 } from './AgentAdapter.js';
 import { AgentStatus } from './AgentAdapter.js';
-import { listAgentProcesses, enrichProcesses } from '../utils/process.js';
+import { captureProcessSnapshot, executableBasename, filterByProcessNames } from '../utils/process.js';
 import { generateAgentName } from '../utils/matching.js';
 
 const SESSION_REF_SEP = '::';
@@ -55,6 +56,7 @@ interface OpenCodeSessionStats {
 
 export class OpenCodeAdapter implements AgentAdapter {
     readonly type = 'opencode' as const;
+    readonly processNames = ['opencode'] as const;
 
     private static readonly IDLE_THRESHOLD_MINUTES = 5;
 
@@ -84,13 +86,14 @@ export class OpenCodeAdapter implements AgentAdapter {
     }
 
     canHandle(processInfo: ProcessInfo): boolean {
-        const exe = (processInfo.command.trim().split(/\s+/)[0] || '').toLowerCase();
-        const base = path.basename(exe);
+        const base = executableBasename(processInfo.command);
         return base === 'opencode' || base === 'opencode.exe';
     }
 
-    async detectAgents(): Promise<AgentInfo[]> {
-        const processes = enrichProcesses(listAgentProcesses('opencode'));
+    async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+        const snapshot = context?.processes ?? await captureProcessSnapshot(this.processNames);
+        const relevant = filterByProcessNames(snapshot, this.processNames);
+        const processes = relevant.filter((process) => this.canHandle(process));
         if (processes.length === 0) return [];
 
         const db = this.openDb();

package/src/adapters/PiAdapter.ts

@@ -17,9 +17,10 @@ import type {
     ConversationMessage,
     SessionSummary,
     ListSessionsOptions,
+    AgentDetectionContext,
 } from './AgentAdapter.js';
 import { AgentStatus } from './AgentAdapter.js';
-import { listAgentProcesses, enrichProcesses } from '../utils/process.js';
+import { captureProcessSnapshot, executableBasename, filterByProcessNames } 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';
@@ -66,6 +67,7 @@ interface TrackerAgentResult {
 
 export class PiAdapter implements AgentAdapter {
     readonly type = 'pi' as const;
+    readonly processNames = ['pi', 'node'] as const;
 
     private static readonly IDLE_THRESHOLD_MINUTES = 5;
 
@@ -86,8 +88,10 @@ export class PiAdapter implements AgentAdapter {
         return this.isPiExecutable(processInfo.command);
     }
 
-    async detectAgents(): Promise<AgentInfo[]> {
-        const processes = enrichProcesses(this.listPiProcesses());
+    async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+        const snapshot = context?.processes ?? await captureProcessSnapshot(this.processNames);
+        const relevant = filterByProcessNames(snapshot, this.processNames);
+        const processes = this.listPiProcesses(relevant);
         if (processes.length === 0) return [];
 
         const { cachedAgents, remaining } = this.tryRegistryCache(processes);
@@ -149,12 +153,9 @@ export class PiAdapter implements AgentAdapter {
         return agents;
     }
 
-    private listPiProcesses(): ProcessInfo[] {
+    private listPiProcesses(snapshot: readonly ProcessInfo[]): ProcessInfo[] {
         const byPid = new Map<number, ProcessInfo>();
-        for (const proc of listAgentProcesses('pi')) {
-            if (this.canHandle(proc)) byPid.set(proc.pid, proc);
-        }
-        for (const proc of listAgentProcesses('node')) {
+        for (const proc of snapshot) {
             if (this.canHandle(proc)) byPid.set(proc.pid, proc);
         }
         return Array.from(byPid.values());
@@ -547,7 +548,7 @@ export class PiAdapter implements AgentAdapter {
 
     private isPiExecutable(command: string): boolean {
         for (const token of command.trim().split(/\s+/)) {
-            const base = path.basename(token).toLowerCase();
+            const base = executableBasename(token);
             if (base === 'pi' || base === 'pi.exe' || base === 'pi.js') return true;
         }
         return false;

package/src/adapters/index.ts

@@ -6,4 +6,4 @@ export { GrokCliAdapter } from './GrokCliAdapter.js';
 export { OpenCodeAdapter } from './OpenCodeAdapter.js';
 export { PiAdapter } from './PiAdapter.js';
 export { AgentStatus } from './AgentAdapter.js';
-export type { AgentAdapter, AgentType, AgentInfo, ProcessInfo } from './AgentAdapter.js';
+export type { AgentAdapter, AgentType, AgentInfo, ProcessInfo, AgentDetectionContext } from './AgentAdapter.js';

package/src/database/connection.ts

@@ -0,0 +1,74 @@
+import Database from 'better-sqlite3';
+import { mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+import { initializeSchema } from './schema.js';
+
+export const DEFAULT_AGENT_REGISTRY_DB_PATH = join(homedir(), '.ai-devkit', 'agents.db');
+
+export interface DatabaseOptions {
+    dbPath?: string;
+    verbose?: boolean;
+    readonly?: boolean;
+}
+
+export function resolveAgentRegistryDbPath(filePath?: string): string {
+    if (!filePath) return DEFAULT_AGENT_REGISTRY_DB_PATH;
+    return filePath.endsWith('.json') ? filePath.replace(/\.json$/, '.db') : filePath;
+}
+
+export class DatabaseConnection {
+    private db: Database.Database;
+    private readonly dbPath: string;
+
+    constructor(options: DatabaseOptions = {}) {
+        this.dbPath = options.dbPath ?? DEFAULT_AGENT_REGISTRY_DB_PATH;
+        mkdirSync(dirname(this.dbPath), { recursive: true });
+
+        this.db = new Database(this.dbPath, {
+            readonly: options.readonly ?? false,
+            verbose: options.verbose ? console.log : undefined,
+        });
+
+        this.configure();
+        initializeSchema(this);
+    }
+
+    private configure(): void {
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        this.db.pragma('synchronous = NORMAL');
+        this.db.pragma('busy_timeout = 5000');
+        this.db.pragma('mmap_size = 268435456');
+    }
+
+    get instance(): Database.Database {
+        return this.db;
+    }
+
+    get path(): string {
+        return this.dbPath;
+    }
+
+    query<T>(sql: string, params: unknown[] = []): T[] {
+        return this.db.prepare(sql).all(...params) as T[];
+    }
+
+    queryOne<T>(sql: string, params: unknown[] = []): T | undefined {
+        return this.db.prepare(sql).get(...params) as T | undefined;
+    }
+
+    execute(sql: string, params: unknown[] = []): Database.RunResult {
+        return this.db.prepare(sql).run(...params);
+    }
+
+    transaction<T>(fn: () => T): T {
+        return this.db.transaction(fn)();
+    }
+
+    close(): void {
+        if (this.db.open) {
+            this.db.close();
+        }
+    }
+}

package/src/database/index.ts

@@ -0,0 +1,7 @@
+export {
+    DatabaseConnection,
+    DEFAULT_AGENT_REGISTRY_DB_PATH,
+    resolveAgentRegistryDbPath,
+} from './connection.js';
+export type { DatabaseOptions } from './connection.js';
+export { getSchemaVersion, initializeSchema } from './schema.js';

package/src/database/migrations/001_initial.sql

@@ -0,0 +1,12 @@
+CREATE TABLE IF NOT EXISTS agents (
+    type TEXT NOT NULL,
+    pid INTEGER NOT NULL,
+    name TEXT NOT NULL UNIQUE,
+    tmux_session TEXT NOT NULL DEFAULT '',
+    cwd TEXT NOT NULL DEFAULT '',
+    started_at TEXT NOT NULL,
+    session_id TEXT NOT NULL DEFAULT '',
+    session_file_path TEXT NOT NULL DEFAULT '',
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (type, pid)
+);

package/src/database/schema.ts

@@ -0,0 +1,62 @@
+import { readFileSync, readdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import type { DatabaseConnection } from './connection.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export function getSchemaVersion(db: DatabaseConnection): number {
+    const result = db.instance.pragma('user_version') as { user_version: number }[];
+    return result[0]?.user_version ?? 0;
+}
+
+function setSchemaVersion(db: DatabaseConnection, version: number): void {
+    db.instance.pragma(`user_version = ${version}`);
+}
+
+function getMigrationsDir(): string {
+    return join(__dirname, 'migrations');
+}
+
+interface Migration {
+    version: number;
+    path: string;
+    name: string;
+}
+
+function getMigrationFiles(): Migration[] {
+    const migrationsDir = getMigrationsDir();
+
+    let files: string[];
+    try {
+        files = readdirSync(migrationsDir).filter((f) => f.endsWith('.sql')).sort();
+    } catch {
+        return [];
+    }
+
+    return files.map((file) => {
+        const match = file.match(/^(\d+)_(.+)\.sql$/);
+        if (!match || !match[1] || !match[2]) {
+            throw new Error(`Invalid migration filename: ${file}. Expected format: 001_name.sql`);
+        }
+        return {
+            version: parseInt(match[1], 10),
+            name: match[2],
+            path: join(migrationsDir, file),
+        };
+    });
+}
+
+export function initializeSchema(db: DatabaseConnection): void {
+    const currentVersion = getSchemaVersion(db);
+    const pendingMigrations = getMigrationFiles().filter((m) => m.version > currentVersion);
+
+    for (const migration of pendingMigrations) {
+        const sql = readFileSync(migration.path, 'utf-8');
+
+        db.transaction(() => {
+            db.instance.exec(sql);
+            setSchemaVersion(db, migration.version);
+        });
+    }
+}

package/src/index.ts

@@ -16,6 +16,7 @@ export type {
     ConversationMessage,
     SessionSummary,
     ListSessionsOptions,
+    AgentDetectionContext,
 } from './adapters/AgentAdapter.js';
 
 export { TerminalFocusManager, TerminalType } from './terminal/TerminalFocusManager.js';
@@ -23,6 +24,7 @@ export type { TerminalLocation } from './terminal/TerminalFocusManager.js';
 export { TtyWriter } from './terminal/TtyWriter.js';
 
 export { getProcessTty } from './utils/process.js';
+export { captureProcessSnapshot, executableBasename, filterByProcessNames } from './utils/process.js';
 export type { AgentSortKey } from './utils/sortAgents.js';
 export type { ListAgentsOptions } from './AgentManager.js';