@ai-devkit/agent-manager 0.26.0 → 0.26.2

package/src/__tests__/utils/AgentRegistry.test.ts

@@ -33,29 +33,28 @@ describe('AgentRegistry', () => {
     });
 
     describe('register', () => {
-        it('creates the file and parent directory if missing', () => {
+        it('creates the SQLite database and parent directory if missing', () => {
             registry.register(makeEntry());
-            expect(fs.existsSync(regPath)).toBe(true);
-            const parsed = JSON.parse(fs.readFileSync(regPath, 'utf8'));
-            expect(parsed.entries).toHaveLength(1);
-            expect(parsed.entries[0].name).toBe('agent1');
+            expect(fs.existsSync(regPath.replace(/\.json$/, '.db'))).toBe(true);
+            expect(registry.list()[0].name).toBe('agent1');
         });
 
         it('appends a new entry when name is unique', () => {
             registry.register(makeEntry({ name: 'a' }));
-            registry.register(makeEntry({ name: 'b' }));
+            registry.register(makeEntry({ name: 'b', pid: process.ppid }));
             expect(registry.list()).toHaveLength(2);
         });
 
-        it('upserts in place when name already exists', () => {
-            registry.register(makeEntry({ name: 'a', pid: 100 }));
-            registry.register(makeEntry({ name: 'a', pid: 200 }));
+        it('upserts in place when type and pid already exist', () => {
+            registry.register(makeEntry({ name: 'a', pid: process.pid }));
+            registry.register(makeEntry({ name: 'fallback', pid: process.pid, tmuxSession: '' }));
             const all = registry.list();
             expect(all).toHaveLength(1);
-            expect(all[0].pid).toBe(200);
+            expect(all[0].pid).toBe(process.pid);
+            expect(all[0].name).toBe('a');
         });
 
-        it('writes atomically (no leftover .tmp on success)', () => {
+        it('does not write through the legacy fixed .tmp path', () => {
             registry.register(makeEntry());
             expect(fs.existsSync(`${regPath}.tmp`)).toBe(false);
         });
@@ -69,16 +68,18 @@ describe('AgentRegistry', () => {
 
         it('preserves existing tmuxSession when incoming is empty string', () => {
             registry.register(makeEntry({ name: 'a', tmuxSession: 'pinned' }));
-            registry.register(makeEntry({ name: 'a', tmuxSession: '', pid: 999 }));
+            registry.register(makeEntry({ name: 'fallback', tmuxSession: '', pid: process.pid }));
             const saved = registry.lookup('a');
             expect(saved?.tmuxSession).toBe('pinned');
-            expect(saved?.pid).toBe(999);
+            expect(saved?.pid).toBe(process.pid);
         });
 
-        it('replaces tmuxSession when incoming is non-empty', () => {
-            registry.register(makeEntry({ name: 'a', tmuxSession: 'old' }));
-            registry.register(makeEntry({ name: 'a', tmuxSession: 'new' }));
-            expect(registry.lookup('a')?.tmuxSession).toBe('new');
+        it('lets a managed start entry replace a generated fallback for the same pid', () => {
+            registry.register(makeEntry({ name: `ai-devkit-${process.pid}`, tmuxSession: '' }));
+            registry.register(makeEntry({ name: 'custom-name', tmuxSession: 'custom-name' }));
+            expect(registry.lookup('custom-name')?.tmuxSession).toBe('custom-name');
+            expect(registry.lookup(`ai-devkit-${process.pid}`)).toBeNull();
+            expect(registry.list()).toHaveLength(1);
         });
     });
 
@@ -88,28 +89,35 @@ describe('AgentRegistry', () => {
             expect(fs.existsSync(regPath)).toBe(false);
         });
 
-        it('upserts multiple entries with a single write', () => {
-            const writeSpy = vi.spyOn(fs, 'writeFileSync');
+        it('upserts multiple entries in a single batch', () => {
             registry.registerBatch([
                 makeEntry({ name: 'a' }),
-                makeEntry({ name: 'b' }),
-                makeEntry({ name: 'c' }),
+                makeEntry({ name: 'b', pid: process.pid + 1 }),
+                makeEntry({ name: 'c', pid: process.pid + 2 }),
             ]);
-            expect(writeSpy).toHaveBeenCalledTimes(1);
-            writeSpy.mockRestore();
             expect(registry.list()).toHaveLength(3);
         });
 
         it('applies the tmuxSession merge per entry', () => {
             registry.register(makeEntry({ name: 'a', tmuxSession: 'pinned' }));
             registry.registerBatch([
-                makeEntry({ name: 'a', tmuxSession: '', pid: 7 }),
-                makeEntry({ name: 'b', tmuxSession: '' }),
+                makeEntry({ name: 'fallback', tmuxSession: '', pid: process.pid }),
+                makeEntry({ name: 'b', tmuxSession: '', pid: process.pid + 1 }),
             ]);
             expect(registry.lookup('a')?.tmuxSession).toBe('pinned');
-            expect(registry.lookup('a')?.pid).toBe(7);
+            expect(registry.lookup('a')?.pid).toBe(process.pid);
             expect(registry.lookup('b')?.tmuxSession).toBe('');
         });
+
+        it('handles concurrent registry instances without duplicate pid rows', () => {
+            const other = new AgentRegistry(regPath);
+            registry.register(makeEntry({ name: `ai-devkit-${process.pid}`, tmuxSession: '' }));
+            other.register(makeEntry({ name: 'custom-name', tmuxSession: 'custom-name' }));
+            registry.register(makeEntry({ name: `ai-devkit-${process.pid}`, tmuxSession: '' }));
+
+            expect(registry.list()).toHaveLength(1);
+            expect(registry.lookup('custom-name')?.pid).toBe(process.pid);
+        });
     });
 
     describe('lookup', () => {
@@ -124,20 +132,20 @@ describe('AgentRegistry', () => {
     });
 
     describe('list', () => {
-        it('returns empty array when file does not exist', () => {
+        it('returns empty array when database does not contain entries', () => {
             expect(registry.list()).toEqual([]);
         });
 
-        it('returns empty array when file is malformed', () => {
+        it('ignores existing legacy agents.json entries', () => {
+            const legacyEntry = makeEntry({ name: 'legacy', tmuxSession: 'legacy' });
             fs.mkdirSync(path.dirname(regPath), { recursive: true });
-            fs.writeFileSync(regPath, 'not json', 'utf8');
-            expect(registry.list()).toEqual([]);
-        });
+            fs.writeFileSync(regPath, JSON.stringify({ entries: [legacyEntry] }), 'utf8');
 
-        it('coerces non-array entries to []', () => {
-            fs.mkdirSync(path.dirname(regPath), { recursive: true });
-            fs.writeFileSync(regPath, JSON.stringify({ entries: 'oops' }), 'utf8');
-            expect(registry.list()).toEqual([]);
+            const legacyRegistry = new AgentRegistry(regPath);
+
+            expect(legacyRegistry.lookup('legacy')).toBeNull();
+            expect(legacyRegistry.list()).toEqual([]);
+            expect(fs.existsSync(regPath.replace(/\.json$/, '.db'))).toBe(true);
         });
     });
 
@@ -163,10 +171,10 @@ describe('AgentRegistry', () => {
 
         it('is a no-op when all entries are alive', () => {
             registry.register(makeEntry({ pid: process.pid }));
-            const before = fs.readFileSync(regPath, 'utf8');
+            const before = registry.list();
             registry.prune();
-            const after = fs.readFileSync(regPath, 'utf8');
-            expect(after).toBe(before);
+            const after = registry.list();
+            expect(after).toEqual(before);
         });
 
         it('does nothing when file is missing', () => {
@@ -203,7 +211,7 @@ describe('AgentRegistry', () => {
 
         it('throws RenameConflictError when new name is already in use by a live entry', () => {
             registry.register(makeEntry({ name: 'agent-a', pid: process.pid }));
-            registry.register(makeEntry({ name: 'agent-b', pid: process.pid }));
+            registry.register(makeEntry({ name: 'agent-b', pid: process.ppid }));
             expect(() => registry.rename('agent-a', 'agent-b')).toThrow(RenameConflictError);
         });
 
@@ -214,7 +222,7 @@ describe('AgentRegistry', () => {
             expect(registry.lookup('agent-b')?.pid).toBe(process.pid);
         });
 
-        it('writes atomically (no leftover .tmp on success)', () => {
+        it('does not create the legacy fixed .tmp path on rename', () => {
             registry.register(makeEntry({ name: 'old-name', pid: process.pid }));
             registry.rename('old-name', 'new-name');
             expect(fs.existsSync(`${regPath}.tmp`)).toBe(false);

package/src/adapters/CodexAdapter.ts

@@ -37,9 +37,26 @@ interface CodexEventEntry {
         id?: string;
         cwd?: string;
         timestamp?: string;
+        role?: string;
+        content?: CodexContent[];
+        item?: CodexItem;
+        turn_id?: string;
+        internal_chat_message_metadata_passthrough?: {
+            turn_id?: string;
+        };
     };
 }
 
+interface CodexContent {
+    type?: string;
+    text?: string;
+}
+
+interface CodexItem {
+    type?: string;
+    content?: string | CodexContent[];
+}
+
 interface CodexSession {
     sessionId: string;
     projectPath: string;
@@ -502,7 +519,7 @@ export class CodexAdapter implements AgentAdapter {
         }
 
         const lastEntry = this.findLastEventEntry(entries);
-        const lastPayloadType = lastEntry?.payload?.type;
+        const lastPayloadType = lastEntry ? this.normalizedPayloadType(lastEntry) : undefined;
 
         const lastActive =
             this.parseTimestamp(lastEntry?.timestamp) ||
@@ -596,15 +613,44 @@ export class CodexAdapter implements AgentAdapter {
 
     private extractSummary(entries: CodexEventEntry[]): string {
         for (let i = entries.length - 1; i >= 0; i--) {
-            const message = entries[i]?.payload?.message;
-            if (typeof message === 'string' && message.trim().length > 0) {
-                return this.truncate(message.trim(), 120);
-            }
+            const message = this.extractEntryText(entries[i]);
+            if (message) return this.truncate(message, 120);
         }
 
         return 'Codex session active';
     }
 
+    private normalizedPayloadType(entry: CodexEventEntry): string | undefined {
+        const payloadType = entry.payload?.type;
+
+        if (entry.type === 'response_item' && payloadType === 'message') {
+            if (entry.payload?.role === 'assistant') return 'agent_message';
+            if (entry.payload?.role === 'user') return 'user_message';
+            return payloadType;
+        }
+
+        if (entry.type === 'event_msg' && payloadType === 'item_completed') {
+            const itemType = entry.payload?.item?.type;
+            if (itemType === 'AgentMessage') return 'agent_message';
+            if (itemType === 'UserMessage') return 'user_message';
+            return itemType ?? payloadType;
+        }
+
+        return payloadType;
+    }
+
+    private extractEntryText(entry: CodexEventEntry | undefined): string {
+        if (!entry) return '';
+
+        const legacyMessage = entry.payload?.message;
+        if (typeof legacyMessage === 'string' && legacyMessage.trim().length > 0) {
+            return legacyMessage.trim();
+        }
+
+        const conversationMessage = this.toConversationMessage(entry, false);
+        return conversationMessage?.content.trim() ?? '';
+    }
+
     private truncate(value: string, maxLength: number): string {
         if (value.length <= maxLength) return value;
         return `${value.slice(0, maxLength - 3)}...`;
@@ -619,7 +665,8 @@ export class CodexAdapter implements AgentAdapter {
     /**
      * Read the full conversation from a Codex session JSONL file.
      *
-     * Codex entries use payload.type to indicate message role and payload.message for content.
+     * Codex entries use either legacy payload.message fields or current
+     * response_item/event_msg content arrays.
      */
     getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
         const verbose = options?.verbose ?? false;
@@ -628,45 +675,118 @@ export class CodexAdapter implements AgentAdapter {
         if (content === undefined) return [];
 
         const lines = content.trim().split('\n');
+        const entries: CodexEventEntry[] = [];
         const messages: ConversationMessage[] = [];
 
         for (const line of lines) {
-            let entry: CodexEventEntry;
             try {
-                entry = JSON.parse(line);
+                entries.push(JSON.parse(line));
             } catch {
                 continue;
             }
+        }
 
-            if (entry.type === 'session_meta') continue;
+        const responseItemMirrorKeys = new Set<string>();
+        for (const entry of entries) {
+            if (entry.type !== 'response_item') continue;
 
-            const payloadType = entry.payload?.type;
-            if (!payloadType) continue;
+            const message = this.toConversationMessage(entry, verbose);
+            const mirrorKey = message ? this.mirroredMessageKey(entry, message) : null;
+            if (mirrorKey) responseItemMirrorKeys.add(mirrorKey);
+        }
 
-            let role: ConversationMessage['role'];
-            if (payloadType === 'user_message') {
-                role = 'user';
-            } else if (payloadType === 'agent_message' || payloadType === 'task_complete') {
-                role = 'assistant';
-            } else if (verbose) {
-                role = 'system';
-            } else {
+        for (const entry of entries) {
+            const message = this.toConversationMessage(entry, verbose);
+            if (!message) continue;
+
+            const mirrorKey = this.mirroredMessageKey(entry, message);
+            if (
+                entry.type === 'event_msg' &&
+                mirrorKey &&
+                responseItemMirrorKeys.has(mirrorKey)
+            ) {
                 continue;
             }
 
-            const text = entry.payload?.message?.trim();
-            if (!text) continue;
-
-            messages.push({
-                role,
-                content: text,
-                timestamp: entry.timestamp,
-            });
+            messages.push(message);
         }
 
         return messages;
     }
 
+    private toConversationMessage(entry: CodexEventEntry, verbose: boolean): ConversationMessage | null {
+        if (entry.type === 'session_meta') return null;
+
+        const payloadType = entry.payload?.type;
+        if (entry.type === 'response_item' && payloadType === 'message') {
+            const role = this.mapCodexRole(entry.payload?.role, verbose);
+            const text = this.extractContentText(entry.payload?.content);
+            if (!role || !text) return null;
+
+            return { role, content: text, timestamp: entry.timestamp };
+        }
+
+        if (entry.type === 'event_msg' && payloadType === 'item_completed') {
+            const item = entry.payload?.item;
+            const role = this.mapCodexItemRole(item?.type, verbose);
+            const text = this.extractContentText(item?.content);
+            if (!role || !text) return null;
+
+            return { role, content: text, timestamp: entry.timestamp };
+        }
+
+        if (!payloadType) return null;
+
+        let role: ConversationMessage['role'];
+        if (payloadType === 'user_message') {
+            role = 'user';
+        } else if (payloadType === 'agent_message' || payloadType === 'task_complete') {
+            role = 'assistant';
+        } else if (verbose) {
+            role = 'system';
+        } else {
+            return null;
+        }
+
+        const text = entry.payload?.message?.trim();
+        if (!text) return null;
+
+        return { role, content: text, timestamp: entry.timestamp };
+    }
+
+    private mapCodexRole(role: string | undefined, verbose: boolean): ConversationMessage['role'] | null {
+        if (role === 'user') return 'user';
+        if (role === 'assistant') return 'assistant';
+        return verbose ? 'system' : null;
+    }
+
+    private mapCodexItemRole(itemType: string | undefined, verbose: boolean): ConversationMessage['role'] | null {
+        if (itemType === 'AgentMessage') return 'assistant';
+        if (itemType === 'UserMessage') return 'user';
+        return verbose ? 'system' : null;
+    }
+
+    private mirroredMessageKey(entry: CodexEventEntry, message: ConversationMessage): string | null {
+        const turnId =
+            entry.payload?.turn_id ||
+            entry.payload?.internal_chat_message_metadata_passthrough?.turn_id;
+
+        if (!turnId) return null;
+        return `${turnId}\0${message.role}\0${message.content}`;
+    }
+
+    private extractContentText(content: string | CodexContent[] | undefined): string {
+        if (typeof content === 'string') return content.trim();
+        if (!Array.isArray(content)) return '';
+
+        return content
+            .map((part) => part.text)
+            .filter((text): text is string => typeof text === 'string' && text.trim().length > 0)
+            .map((text) => text.trim())
+            .join('\n')
+            .trim();
+    }
+
     async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
         if (!isDirectory(this.codexSessionsDir)) return [];
 

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);
+        });
+    }
+}