@ai-devkit/agent-manager 0.26.1 → 0.26.3

package/src/utils/AgentRegistry.ts

@@ -1,7 +1,10 @@
-import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import type { AgentType } from '../adapters/AgentAdapter.js';
+import {
+    DatabaseConnection,
+    resolveAgentRegistryDbPath,
+} from '../database/index.js';
 
 export class RenameNotFoundError extends Error {
     constructor(public agentName: string) {
@@ -28,8 +31,16 @@ export interface RegistryEntry {
     sessionFilePath: string;
 }
 
-interface RegistryFile {
-    entries: RegistryEntry[];
+interface RegistryRow {
+    name: string;
+    type: AgentType;
+    pid: number;
+    tmux_session: string;
+    cwd: string;
+    started_at: string;
+    session_id: string;
+    session_file_path: string;
+    updated_at: string;
 }
 
 const DEFAULT_REGISTRY_PATH = path.join(os.homedir(), '.ai-devkit', 'agents.json');
@@ -37,10 +48,10 @@ const DEFAULT_REGISTRY_PATH = path.join(os.homedir(), '.ai-devkit', 'agents.json
 let defaultInstance: AgentRegistry | null = null;
 
 export class AgentRegistry {
-    private filePath: string;
+    private db: DatabaseConnection;
 
     constructor(filePath: string = DEFAULT_REGISTRY_PATH) {
-        this.filePath = filePath;
+        this.db = new DatabaseConnection({ dbPath: resolveAgentRegistryDbPath(filePath) });
     }
 
     static default(): AgentRegistry {
@@ -50,32 +61,79 @@ export class AgentRegistry {
         return defaultInstance;
     }
 
-    private readFile(): RegistryFile {
-        try {
-            const raw = fs.readFileSync(this.filePath, 'utf8');
-            const parsed = JSON.parse(raw) as RegistryFile;
-            return { entries: Array.isArray(parsed.entries) ? parsed.entries : [] };
-        } catch {
-            return { entries: [] };
-        }
-    }
-
-    private writeFile(data: RegistryFile): void {
-        const dir = path.dirname(this.filePath);
-        fs.mkdirSync(dir, { recursive: true });
-        const tmp = `${this.filePath}.tmp`;
-        fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf8');
-        fs.renameSync(tmp, this.filePath);
+    private rowToEntry(row: RegistryRow): RegistryEntry {
+        return {
+            name: row.name,
+            type: row.type,
+            pid: row.pid,
+            tmuxSession: row.tmux_session,
+            cwd: row.cwd,
+            startedAt: row.started_at,
+            sessionId: row.session_id,
+            sessionFilePath: row.session_file_path,
+        };
     }
 
     private mergeEntry(incoming: RegistryEntry, existing: RegistryEntry | undefined): RegistryEntry {
         if (!existing) return incoming;
+        const incomingIsManaged = Boolean(incoming.tmuxSession);
         return {
-            ...incoming,
+            ...existing,
+            name: incomingIsManaged ? incoming.name : existing.name,
             tmuxSession: incoming.tmuxSession || existing.tmuxSession,
+            cwd: incoming.cwd || existing.cwd,
+            startedAt: existing.startedAt || incoming.startedAt,
+            sessionId: incoming.sessionId || existing.sessionId,
+            sessionFilePath: incoming.sessionFilePath || existing.sessionFilePath,
         };
     }
 
+    private findByIdentity(type: AgentType, pid: number): RegistryEntry | undefined {
+        const row = this.db.queryOne<RegistryRow>(
+            'SELECT * FROM agents WHERE type = ? AND pid = ?',
+            [type, pid],
+        );
+        return row ? this.rowToEntry(row) : undefined;
+    }
+
+    private findByName(name: string): RegistryEntry | undefined {
+        const row = this.db.queryOne<RegistryRow>('SELECT * FROM agents WHERE name = ?', [name]);
+        return row ? this.rowToEntry(row) : undefined;
+    }
+
+    private deleteNameConflict(name: string, type: AgentType, pid: number): void {
+        const conflict = this.findByName(name);
+        if (!conflict) return;
+        if (conflict.type === type && conflict.pid === pid) return;
+        if (!this.isAlive(conflict)) {
+            this.db.execute('DELETE FROM agents WHERE type = ? AND pid = ?', [conflict.type, conflict.pid]);
+        }
+    }
+
+    private insertOrUpdate(entry: RegistryEntry): void {
+        this.db.instance.prepare(`
+            INSERT INTO agents (
+                type, pid, name, tmux_session, cwd, started_at, session_id, session_file_path, updated_at
+            )
+            VALUES (
+                @type, @pid, @name, @tmuxSession, @cwd, @startedAt, @sessionId, @sessionFilePath, @updatedAt
+            )
+            ON CONFLICT(type, pid) DO UPDATE SET
+                name = excluded.name,
+                tmux_session = excluded.tmux_session,
+                cwd = excluded.cwd,
+                started_at = agents.started_at,
+                session_id = excluded.session_id,
+                session_file_path = excluded.session_file_path,
+                updated_at = excluded.updated_at
+        `).run({ ...entry, updatedAt: new Date().toISOString() });
+    }
+
+    private save(entry: RegistryEntry): void {
+        this.deleteNameConflict(entry.name, entry.type, entry.pid);
+        this.insertOrUpdate(entry);
+    }
+
     isAlive(entry: RegistryEntry): boolean {
         try {
             process.kill(entry.pid, 0);
@@ -86,11 +144,13 @@ export class AgentRegistry {
     }
 
     prune(): void {
-        const data = this.readFile();
-        const live = data.entries.filter((e) => this.isAlive(e));
-        if (live.length !== data.entries.length) {
-            this.writeFile({ entries: live });
-        }
+        const entries = this.list();
+        const stale = entries.filter((e) => !this.isAlive(e));
+        this.db.transaction(() => {
+            for (const entry of stale) {
+                this.db.execute('DELETE FROM agents WHERE type = ? AND pid = ?', [entry.type, entry.pid]);
+            }
+        });
     }
 
     register(entry: RegistryEntry): void {
@@ -99,41 +159,41 @@ export class AgentRegistry {
 
     registerBatch(entries: RegistryEntry[]): void {
         if (entries.length === 0) return;
-        const data = this.readFile();
-        for (const incoming of entries) {
-            const idx = data.entries.findIndex((e) => e.name === incoming.name);
-            if (idx >= 0) {
-                data.entries[idx] = this.mergeEntry(incoming, data.entries[idx]);
-            } else {
-                data.entries.push(incoming);
+        this.db.transaction(() => {
+            for (const incoming of entries) {
+                const existing = this.findByIdentity(incoming.type, incoming.pid);
+                this.save(this.mergeEntry(incoming, existing));
             }
-        }
-        this.writeFile(data);
+        });
     }
 
     rename(currentName: string, newName: string): void {
-        const data = this.readFile();
-        const idx = data.entries.findIndex((e) => e.name === currentName);
-        if (idx < 0) {
+        const existing = this.findByName(currentName);
+        if (!existing) {
             throw new RenameNotFoundError(currentName);
         }
-        const liveEntries = data.entries.filter((e) => this.isAlive(e));
-        const conflict = liveEntries.find((e) => e.name === newName);
-        if (conflict) {
+        const conflict = this.findByName(newName);
+        if (conflict && this.isAlive(conflict)) {
             throw new RenameConflictError(newName);
         }
-        const pruned = liveEntries.map((e) =>
-            e.name === currentName ? { ...e, name: newName } : e,
-        );
-        this.writeFile({ entries: pruned });
+
+        this.db.transaction(() => {
+            if (conflict) {
+                this.db.execute('DELETE FROM agents WHERE type = ? AND pid = ?', [conflict.type, conflict.pid]);
+            }
+            this.db.execute(
+                'UPDATE agents SET name = ?, updated_at = ? WHERE type = ? AND pid = ?',
+                [newName, new Date().toISOString(), existing.type, existing.pid],
+            );
+        });
     }
 
     lookup(name: string): RegistryEntry | null {
-        const data = this.readFile();
-        return data.entries.find((e) => e.name === name) ?? null;
+        return this.findByName(name) ?? null;
     }
 
     list(): RegistryEntry[] {
-        return this.readFile().entries;
+        const rows = this.db.query<RegistryRow>('SELECT * FROM agents ORDER BY started_at ASC, name ASC');
+        return rows.map((row) => this.rowToEntry(row));
     }
 }

package/src/utils/index.ts

@@ -1,4 +1,4 @@
-export { listAgentProcesses, batchGetProcessCwds, batchGetProcessStartTimes, enrichProcesses } from './process.js';
+export { listAgentProcesses, batchGetProcessCwds, batchGetProcessStartTimes, enrichProcesses, captureProcessSnapshot } from './process.js';
 export { getProcessTty } from './process.js';
 export { batchGetSessionFileBirthtimes } from './session.js';
 export type { SessionFile } from './session.js';

package/src/utils/process.ts

@@ -2,13 +2,42 @@
  * Process Detection Utilities
  *
  * Shared shell command wrappers for detecting and inspecting running processes.
- * All execFileSync calls for process data live here — adapters must not call execFileSync directly.
+ * Built-in refresh discovery uses captureProcessSnapshot(); synchronous helpers
+ * remain exported for compatibility with existing consumers.
  */
 
 import * as path from 'path';
-import { execFileSync } from 'child_process';
+import { execFile, execFileSync } from 'child_process';
 import type { ProcessInfo } from '../adapters/AgentAdapter.js';
 
+const PROCESS_EXEC_MAX_BUFFER = 10 * 1024 * 1024;
+const VALID_EXECUTABLE_NAME = /^[a-zA-Z0-9_-]+$/;
+
+export function executableBasename(command: string): string {
+    const executable = command.trim().split(/\s+/)[0] || '';
+    return path.basename(executable.replace(/\\/g, '/')).toLowerCase();
+}
+
+function normalizeExecutableName(name: string): string {
+    const lower = name.toLowerCase();
+    return lower.endsWith('.exe') ? lower.slice(0, -4) : lower;
+}
+
+function normalizedProcessNames(namePatterns: readonly string[]): Set<string> {
+    return new Set(namePatterns.filter(Boolean).map(normalizeExecutableName));
+}
+
+export function filterByProcessNames(
+    processes: readonly ProcessInfo[],
+    namePatterns: readonly string[],
+): ProcessInfo[] {
+    const names = normalizedProcessNames(namePatterns);
+    if (names.size === 0) return [];
+    return processes.filter((process) => (
+        names.has(normalizeExecutableName(executableBasename(process.command)))
+    ));
+}
+
 /**
  * List running processes matching an agent executable name.
  *
@@ -20,14 +49,14 @@ import type { ProcessInfo } from '../adapters/AgentAdapter.js';
  */
 export function listAgentProcesses(namePattern: string): ProcessInfo[] {
     // Validate pattern contains only safe characters (alphanumeric, dash, underscore)
-    if (!namePattern || !/^[a-zA-Z0-9_-]+$/.test(namePattern)) {
+    if (!namePattern || !VALID_EXECUTABLE_NAME.test(namePattern)) {
         return [];
     }
 
     try {
         const output = execFileSync('ps', ['-axo', 'pid=,ppid=,tty=,command='], { encoding: 'utf-8' });
 
-        const lowerPattern = namePattern.toLowerCase();
+        const names = normalizedProcessNames([namePattern]);
         const processes: ProcessInfo[] = [];
 
         for (const line of output.trim().split('\n')) {
@@ -43,12 +72,7 @@ export function listAgentProcesses(namePattern: string): ProcessInfo[] {
             const tty = match[3];
             const command = match[4];
 
-            // Check that the executable basename matches exactly
-            const executable = command.trim().split(/\s+/)[0] || '';
-            const base = path.basename(executable).toLowerCase();
-            if (base !== lowerPattern && base !== `${lowerPattern}.exe`) {
-                continue;
-            }
+            if (!names.has(normalizeExecutableName(executableBasename(command)))) continue;
 
             const ttyShort = tty.startsWith('/dev/') ? tty.slice(5) : tty;
 
@@ -67,6 +91,132 @@ export function listAgentProcesses(namePattern: string): ProcessInfo[] {
     }
 }
 
+function execFileText(
+    file: string,
+    args: readonly string[],
+): Promise<string> {
+    return new Promise((resolve, reject) => {
+        execFile(file, args, { encoding: 'utf-8', maxBuffer: PROCESS_EXEC_MAX_BUFFER }, (error, stdout) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(stdout);
+        });
+    });
+}
+
+function parseProcessList(output: string, namePatterns: ReadonlySet<string>): ProcessInfo[] {
+    const processes: ProcessInfo[] = [];
+
+    for (const line of output.trim().split('\n')) {
+        if (!line.trim()) continue;
+
+        const match = line.match(/^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/);
+        if (!match) continue;
+
+        const pid = parseInt(match[1], 10);
+        const ppid = parseInt(match[2], 10);
+        if (Number.isNaN(pid) || Number.isNaN(ppid)) continue;
+
+        const tty = match[3];
+        const command = match[4];
+        const base = executableBasename(command);
+        const normalizedBase = normalizeExecutableName(base);
+        if (!namePatterns.has(normalizedBase)) continue;
+
+        processes.push({
+            pid,
+            ppid,
+            command,
+            cwd: '',
+            tty: tty.startsWith('/dev/') ? tty.slice(5) : tty,
+        });
+    }
+
+    return processes;
+}
+
+async function batchGetProcessCwdsAsync(pids: number[]): Promise<Map<number, string>> {
+    const result = new Map<number, string>();
+    if (pids.length === 0) return result;
+
+    try {
+        const output = await execFileText('lsof', ['-a', '-d', 'cwd', '-Fn', '-p', pids.join(',')]);
+        let currentPid: number | null = null;
+        for (const line of output.trim().split('\n')) {
+            if (line.startsWith('p')) {
+                currentPid = parseInt(line.slice(1), 10);
+            } else if (line.startsWith('n') && currentPid !== null) {
+                result.set(currentPid, line.slice(1));
+                currentPid = null;
+            }
+        }
+        return result;
+    } catch {
+        const entries = await Promise.all(pids.map(async (pid) => {
+            try {
+                const output = await execFileText('pwdx', [String(pid)]);
+                const match = output.match(/^\d+:\s*(.+)$/);
+                return match ? [pid, match[1].trim()] as const : null;
+            } catch {
+                return null;
+            }
+        }));
+        for (const entry of entries) {
+            if (entry) result.set(entry[0], entry[1]);
+        }
+        return result;
+    }
+}
+
+async function batchGetProcessStartTimesAsync(pids: number[]): Promise<Map<number, Date>> {
+    const result = new Map<number, Date>();
+    if (pids.length === 0) return result;
+
+    try {
+        const output = await execFileText('ps', ['-o', 'pid=,lstart=', '-p', pids.join(',')]);
+        for (const rawLine of output.split('\n')) {
+            const match = rawLine.trim().match(/^(\d+)\s+(.+)$/);
+            if (!match) continue;
+            const pid = parseInt(match[1], 10);
+            const date = new Date(match[2].trim());
+            if (Number.isFinite(pid) && !Number.isNaN(date.getTime())) result.set(pid, date);
+        }
+    } catch {
+        // Return partial/empty data, matching the synchronous helper.
+    }
+    return result;
+}
+
+/**
+ * Capture and enrich relevant processes without blocking the event loop.
+ * One base process listing is shared by every requested executable name.
+ */
+export async function captureProcessSnapshot(namePatterns: readonly string[]): Promise<ProcessInfo[]> {
+    const names = normalizedProcessNames(
+        namePatterns.filter((name) => Boolean(name) && VALID_EXECUTABLE_NAME.test(name)),
+    );
+    if (names.size === 0) return [];
+
+    try {
+        const output = await execFileText('ps', ['-axo', 'pid=,ppid=,tty=,command=']);
+        const processes = parseProcessList(output, names);
+        const pids = processes.map((process) => process.pid);
+        const [cwdMap, startTimeMap] = await Promise.all([
+            batchGetProcessCwdsAsync(pids),
+            batchGetProcessStartTimesAsync(pids),
+        ]);
+        return processes.map((process) => ({
+            ...process,
+            cwd: cwdMap.get(process.pid) || '',
+            startTime: startTimeMap.get(process.pid),
+        }));
+    } catch {
+        return [];
+    }
+}
+
 /**
  * Batch-get current working directories for multiple PIDs.
  *