@ai-devkit/agent-manager 0.15.0 → 0.17.0

package/dist/adapters/GeminiCliAdapter.js

@@ -8,14 +8,14 @@
  * 4. Matching sessions to processes via shared matchProcessesToSessions()
  *    using sha256(cwd) === session.projectHash as the resolvedCwd source
  * 5. Extracting summary from the most recent user message in the session JSON
- */
-import * as crypto from 'crypto';
+ */ import * as crypto from 'crypto';
 import * as fs from 'fs';
 import * as path from 'path';
 import { AgentStatus } from './AgentAdapter.js';
 import { listAgentProcesses, enrichProcesses } from '../utils/process.js';
 import { isDirectory, safeReadFile, safeReaddir, safeStat } from '../utils/session.js';
 import { matchProcessesToSessions, generateAgentName } from '../utils/matching.js';
+import { AgentRegistry } from '../utils/AgentRegistry.js';
 export class GeminiCliAdapter {
     type = 'gemini_cli';
     static IDLE_THRESHOLD_MINUTES = 5;
@@ -23,9 +23,11 @@ export class GeminiCliAdapter {
     static CHATS_DIR_NAME = 'chats';
     static TMP_DIR_NAME = 'tmp';
     geminiTmpDir;
-    constructor() {
+    registry;
+    constructor(registry = AgentRegistry.default()){
         const homeDir = process.env.HOME || process.env.USERPROFILE || '';
         this.geminiTmpDir = path.join(homeDir, '.gemini', GeminiCliAdapter.TMP_DIR_NAME);
+        this.registry = registry;
     }
     canHandle(processInfo) {
         return this.isGeminiExecutable(processInfo.command);
@@ -41,35 +43,96 @@ export class GeminiCliAdapter {
      * argv[0] = `node`. We scan the Node process pool via the shared
      * helper and keep only those whose command line references the gemini
      * executable or script via isGeminiExecutable().
-     */
-    async detectAgents() {
+     */ async detectAgents() {
         const nodeProcesses = enrichProcesses(listAgentProcesses('node'));
-        const processes = nodeProcesses.filter((proc) => this.isGeminiExecutable(proc.command));
-        if (processes.length === 0)
-            return [];
-        const { sessions, contentCache } = this.discoverSessions(processes);
+        const processes = nodeProcesses.filter((proc)=>this.isGeminiExecutable(proc.command));
+        if (processes.length === 0) return [];
+        const { cachedAgents, remaining } = this.tryRegistryCache(processes);
+        if (remaining.length === 0) return this.deduplicateSessionAgents(cachedAgents);
+        const { sessions, contentCache } = this.discoverSessions(remaining);
         if (sessions.length === 0) {
-            return processes.map((p) => this.mapProcessOnlyAgent(p));
+            return this.deduplicateSessionAgents([
+                ...cachedAgents,
+                ...remaining.map((p)=>this.mapProcessOnlyAgent(p))
+            ]);
         }
-        const matches = matchProcessesToSessions(processes, sessions);
-        const matchedPids = new Set(matches.map((m) => m.process.pid));
+        const matches = matchProcessesToSessions(remaining, sessions);
+        const matchedPids = new Set(matches.map((m)=>m.process.pid));
         const agents = [];
-        for (const match of matches) {
+        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));
-            }
-            else {
+            } else {
                 matchedPids.delete(match.process.pid);
             }
         }
-        for (const proc of processes) {
+        for (const proc of remaining){
             if (!matchedPids.has(proc.pid)) {
                 agents.push(this.mapProcessOnlyAgent(proc));
             }
         }
-        return agents;
+        return this.deduplicateSessionAgents([
+            ...cachedAgents,
+            ...agents
+        ]);
+    }
+    deduplicateSessionAgents(agents) {
+        const bySession = new Map();
+        const result = [];
+        for (const agent of agents){
+            const sessionKey = this.sessionDeduplicationKey(agent);
+            if (!sessionKey) {
+                result.push(agent);
+                continue;
+            }
+            const existing = bySession.get(sessionKey);
+            if (!existing) {
+                bySession.set(sessionKey, agent);
+                result.push(agent);
+                continue;
+            }
+            if (agent.pid > existing.pid) {
+                bySession.set(sessionKey, agent);
+                const index = result.indexOf(existing);
+                if (index >= 0) result[index] = agent;
+            }
+        }
+        return result;
+    }
+    sessionDeduplicationKey(agent) {
+        if (agent.sessionFilePath) return `file:${agent.sessionFilePath}`;
+        if (agent.sessionId && !agent.sessionId.startsWith('pid-')) {
+            return `session:${agent.sessionId}`;
+        }
+        return null;
+    }
+    tryRegistryCache(processes) {
+        const cachedAgents = [];
+        const remaining = [];
+        const byPid = new Map(this.registry.list().map((e)=>[
+                e.pid,
+                e
+            ]));
+        for (const proc of processes){
+            const entry = byPid.get(proc.pid);
+            if (!entry || entry.type !== this.type || !entry.sessionFilePath || !fs.existsSync(entry.sessionFilePath)) {
+                remaining.push(proc);
+                continue;
+            }
+            const content = safeReadFile(entry.sessionFilePath);
+            const sessionData = this.parseSession(content, entry.sessionFilePath);
+            if (!sessionData) {
+                remaining.push(proc);
+                continue;
+            }
+            cachedAgents.push(this.mapSessionToAgent(sessionData, proc, entry.sessionFilePath));
+        }
+        return {
+            cachedAgents,
+            remaining
+        };
     }
     /**
      * Discover session files for the given processes.
@@ -78,40 +141,36 @@ export class GeminiCliAdapter {
      * where <shortId> is opaque (managed by a project registry). We scan every
      * shortId directory and filter by matching session.projectHash against
      * sha256(process.cwd) to bind each session to a candidate process CWD.
-     */
-    discoverSessions(processes) {
-        const empty = { sessions: [], contentCache: new Map() };
-        if (!fs.existsSync(this.geminiTmpDir))
-            return empty;
+     */ discoverSessions(processes) {
+        const empty = {
+            sessions: [],
+            contentCache: new Map()
+        };
+        if (!fs.existsSync(this.geminiTmpDir)) return empty;
         const cwdHashMap = this.buildCwdHashMap(processes);
-        if (cwdHashMap.size === 0)
-            return empty;
+        if (cwdHashMap.size === 0) return empty;
         const contentCache = new Map();
         const sessions = [];
         let shortIdEntries;
         try {
             shortIdEntries = fs.readdirSync(this.geminiTmpDir);
-        }
-        catch {
+        } catch  {
             return empty;
         }
-        for (const shortId of shortIdEntries) {
+        for (const shortId of shortIdEntries){
             const chatsDir = path.join(this.geminiTmpDir, shortId, GeminiCliAdapter.CHATS_DIR_NAME);
             try {
-                if (!fs.statSync(chatsDir).isDirectory())
-                    continue;
-            }
-            catch {
+                if (!fs.statSync(chatsDir).isDirectory()) continue;
+            } catch  {
                 continue;
             }
             let chatFiles;
             try {
                 chatFiles = fs.readdirSync(chatsDir);
-            }
-            catch {
+            } catch  {
                 continue;
             }
-            for (const fileName of chatFiles) {
+            for (const fileName of chatFiles){
                 if (!fileName.startsWith(GeminiCliAdapter.SESSION_FILE_PREFIX) || !fileName.endsWith('.json')) {
                     continue;
                 }
@@ -119,27 +178,22 @@ export class GeminiCliAdapter {
                 let content;
                 try {
                     content = fs.readFileSync(filePath, 'utf-8');
-                }
-                catch {
+                } catch  {
                     continue;
                 }
                 let parsed;
                 try {
                     parsed = JSON.parse(content);
-                }
-                catch {
+                } catch  {
                     continue;
                 }
-                if (!parsed.projectHash)
-                    continue;
+                if (!parsed.projectHash) continue;
                 const resolvedCwd = cwdHashMap.get(parsed.projectHash);
-                if (!resolvedCwd)
-                    continue;
+                if (!resolvedCwd) continue;
                 let birthtimeMs = 0;
                 try {
                     birthtimeMs = fs.statSync(filePath).birthtimeMs;
-                }
-                catch {
+                } catch  {
                     continue;
                 }
                 const sessionId = parsed.sessionId || fileName.replace(/\.json$/, '');
@@ -149,24 +203,26 @@ export class GeminiCliAdapter {
                     filePath,
                     projectDir: chatsDir,
                     birthtimeMs,
-                    resolvedCwd,
+                    resolvedCwd
                 });
             }
         }
-        return { sessions, contentCache };
+        return {
+            sessions,
+            contentCache
+        };
     }
     buildCwdHashMap(processes) {
         const map = new Map();
-        for (const proc of processes) {
-            if (!proc.cwd)
-                continue;
+        for (const proc of processes){
+            if (!proc.cwd) continue;
             // Gemini CLI resolves its project root by walking up from the
             // startup directory looking for a `.git` boundary marker. A
             // session's projectHash therefore tracks that ancestor rather
             // than the process' actual CWD. Enumerate every ancestor as a
             // candidate so subdirectory invocations still line up with the
             // session the Gemini process wrote.
-            for (const candidate of this.candidateProjectRoots(proc.cwd)) {
+            for (const candidate of this.candidateProjectRoots(proc.cwd)){
                 if (!map.has(this.hashProjectRoot(candidate))) {
                     map.set(this.hashProjectRoot(candidate), proc.cwd);
                 }
@@ -178,7 +234,7 @@ export class GeminiCliAdapter {
         const roots = [];
         let current = path.resolve(cwd);
         let parent = path.dirname(current);
-        while (parent !== current) {
+        while(parent !== current){
             roots.push(current);
             current = parent;
             parent = path.dirname(current);
@@ -192,53 +248,42 @@ export class GeminiCliAdapter {
     /**
      * Parse session file content into GeminiSession.
      * Uses cached content if available, otherwise reads from disk.
-     */
-    parseSession(cachedContent, filePath) {
+     */ parseSession(cachedContent, filePath) {
         let content;
         if (cachedContent !== undefined) {
             content = cachedContent;
-        }
-        else {
+        } else {
             try {
                 content = fs.readFileSync(filePath, 'utf-8');
-            }
-            catch {
+            } catch  {
                 return null;
             }
         }
         let parsed;
         try {
             parsed = JSON.parse(content);
-        }
-        catch {
+        } catch  {
             return null;
         }
-        if (!parsed.sessionId)
-            return null;
+        if (!parsed.sessionId) return null;
         const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
         const lastEntry = messages.length > 0 ? messages[messages.length - 1] : undefined;
         let mtime = null;
         try {
             mtime = fs.statSync(filePath).mtime;
-        }
-        catch {
+        } catch  {
             mtime = null;
         }
-        const lastActive = this.parseTimestamp(parsed.lastUpdated) ||
-            this.parseTimestamp(lastEntry?.timestamp) ||
-            mtime ||
-            new Date();
+        const lastActive = this.parseTimestamp(parsed.lastUpdated) || this.parseTimestamp(lastEntry?.timestamp) || mtime || new Date();
         const sessionStart = this.parseTimestamp(parsed.startTime) || lastActive;
-        const projectPath = Array.isArray(parsed.directories) && parsed.directories.length > 0
-            ? parsed.directories[0]
-            : '';
+        const projectPath = Array.isArray(parsed.directories) && parsed.directories.length > 0 ? parsed.directories[0] : '';
         return {
             sessionId: parsed.sessionId,
             projectPath,
             summary: this.extractSummary(messages),
             sessionStart,
             lastActive,
-            lastMessageType: lastEntry?.type,
+            lastMessageType: lastEntry?.type
         };
     }
     mapSessionToAgent(session, processInfo, filePath) {
@@ -252,7 +297,7 @@ export class GeminiCliAdapter {
             projectPath,
             sessionId: session.sessionId,
             lastActive: session.lastActive,
-            sessionFilePath: filePath,
+            sessionFilePath: filePath
         };
     }
     mapProcessOnlyAgent(processInfo) {
@@ -264,12 +309,11 @@ export class GeminiCliAdapter {
             pid: processInfo.pid,
             projectPath: processInfo.cwd || '',
             sessionId: `pid-${processInfo.pid}`,
-            lastActive: new Date(),
+            lastActive: new Date()
         };
     }
     parseTimestamp(value) {
-        if (!value)
-            return null;
+        if (!value) return null;
         const timestamp = new Date(value);
         return Number.isNaN(timestamp.getTime()) ? null : timestamp;
     }
@@ -285,13 +329,11 @@ export class GeminiCliAdapter {
         return AgentStatus.RUNNING;
     }
     extractSummary(messages) {
-        for (let i = messages.length - 1; i >= 0; i--) {
+        for(let i = messages.length - 1; i >= 0; i--){
             const entry = messages[i];
-            if (entry?.type !== 'user')
-                continue;
+            if (entry?.type !== 'user') continue;
             const text = this.messageText(entry).trim();
-            if (text)
-                return this.truncate(text, 120);
+            if (text) return this.truncate(text, 120);
         }
         return 'Gemini CLI session active';
     }
@@ -299,11 +341,9 @@ export class GeminiCliAdapter {
      * Normalize an entry's content/displayContent into a plain string.
      * Prefers displayContent when both are present (matches Gemini CLI's
      * own rendering priority for the /chat UI).
-     */
-    messageText(entry) {
+     */ messageText(entry) {
         const displayText = this.resolveContent(entry.displayContent);
-        if (displayText)
-            return displayText;
+        if (displayText) return displayText;
         return this.resolveContent(entry.content);
     }
     /**
@@ -312,16 +352,12 @@ export class GeminiCliAdapter {
      * list (user turns carrying `[{text: "..."}]`). Non-text part
      * variants (data, file) are dropped since this helper is only used
      * for summary/conversation rendering.
-     */
-    resolveContent(content) {
-        if (!content)
-            return '';
-        if (typeof content === 'string')
-            return content;
-        if (!Array.isArray(content))
-            return '';
+     */ resolveContent(content) {
+        if (!content) return '';
+        if (typeof content === 'string') return content;
+        if (!Array.isArray(content)) return '';
         const parts = [];
-        for (const part of content) {
+        for (const part of content){
             if (part && typeof part.text === 'string' && part.text) {
                 parts.push(part.text);
             }
@@ -329,8 +365,7 @@ export class GeminiCliAdapter {
         return parts.join('');
     }
     truncate(value, maxLength) {
-        if (value.length <= maxLength)
-            return value;
+        if (value.length <= maxLength) return value;
         return `${value.slice(0, maxLength - 3)}...`;
     }
     isGeminiExecutable(command) {
@@ -338,7 +373,7 @@ export class GeminiCliAdapter {
         // known gemini entrypoint. This is intentionally broader than the
         // 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+/)) {
+        for (const token of command.trim().split(/\s+/)){
             const base = path.basename(token).toLowerCase();
             if (base === 'gemini' || base === 'gemini.exe' || base === 'gemini.js') {
                 return true;
@@ -351,69 +386,55 @@ export class GeminiCliAdapter {
      *
      * Gemini sessions store messages in an array with `type` field — typically
      * 'user' or 'gemini' for visible turns, with tool and system entries mixed in.
-     */
-    getConversation(sessionFilePath, options) {
+     */ getConversation(sessionFilePath, options) {
         const verbose = options?.verbose ?? false;
         const content = safeReadFile(sessionFilePath);
-        if (content === undefined)
-            return [];
+        if (content === undefined) return [];
         let parsed;
         try {
             parsed = JSON.parse(content);
-        }
-        catch {
+        } catch  {
             return [];
         }
         const messages = [];
-        if (!Array.isArray(parsed.messages))
-            return messages;
-        for (const entry of parsed.messages) {
+        if (!Array.isArray(parsed.messages)) return messages;
+        for (const entry of parsed.messages){
             const entryType = entry?.type;
-            if (!entryType)
-                continue;
+            if (!entryType) continue;
             let role;
             if (entryType === 'user') {
                 role = 'user';
-            }
-            else if (entryType === 'gemini' || entryType === 'assistant') {
+            } else if (entryType === 'gemini' || entryType === 'assistant') {
                 role = 'assistant';
-            }
-            else if (verbose) {
+            } else if (verbose) {
                 role = 'system';
-            }
-            else {
+            } else {
                 continue;
             }
             const text = this.messageText(entry).trim();
-            if (!text)
-                continue;
+            if (!text) continue;
             messages.push({
                 role,
                 content: text,
-                timestamp: entry.timestamp,
+                timestamp: entry.timestamp
             });
         }
         return messages;
     }
     async listSessions(opts) {
-        if (!isDirectory(this.geminiTmpDir))
-            return [];
+        if (!isDirectory(this.geminiTmpDir)) return [];
         const summaries = [];
-        for (const shortId of safeReaddir(this.geminiTmpDir)) {
+        for (const shortId of safeReaddir(this.geminiTmpDir)){
             const chatsDir = path.join(this.geminiTmpDir, shortId, GeminiCliAdapter.CHATS_DIR_NAME);
-            if (!isDirectory(chatsDir))
-                continue;
-            for (const fileName of safeReaddir(chatsDir)) {
-                if (!fileName.startsWith(GeminiCliAdapter.SESSION_FILE_PREFIX) ||
-                    !fileName.endsWith('.json')) {
+            if (!isDirectory(chatsDir)) continue;
+            for (const fileName of safeReaddir(chatsDir)){
+                if (!fileName.startsWith(GeminiCliAdapter.SESSION_FILE_PREFIX) || !fileName.endsWith('.json')) {
                     continue;
                 }
                 const filePath = path.join(chatsDir, fileName);
                 const summary = this.fileToSessionSummary(filePath);
-                if (!summary)
-                    continue;
-                if (opts?.cwd !== undefined && summary.cwd !== opts.cwd)
-                    continue;
+                if (!summary) continue;
+                if (opts?.cwd !== undefined && summary.cwd !== opts.cwd) continue;
                 summaries.push(summary);
             }
         }
@@ -423,31 +444,22 @@ export class GeminiCliAdapter {
      * Read a Gemini session JSON file and produce a {@link SessionSummary}.
      * Returns null when the file is unreadable, the JSON doesn't parse,
      * or the body lacks a sessionId.
-     */
-    fileToSessionSummary(filePath) {
+     */ fileToSessionSummary(filePath) {
         const content = safeReadFile(filePath);
-        if (content === undefined)
-            return null;
+        if (content === undefined) return null;
         let parsed;
         try {
             parsed = JSON.parse(content);
-        }
-        catch {
+        } catch  {
             return null;
         }
-        if (!parsed.sessionId)
-            return null;
+        if (!parsed.sessionId) return null;
         const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
         const firstUserMessage = this.extractFirstUserMessage(messages);
-        const cwd = Array.isArray(parsed.directories) && parsed.directories.length > 0
-            ? parsed.directories[0]
-            : '';
+        const cwd = Array.isArray(parsed.directories) && parsed.directories.length > 0 ? parsed.directories[0] : '';
         const stat = safeStat(filePath);
         const lastEntryTimestamp = this.parseTimestamp(messages.length > 0 ? messages[messages.length - 1]?.timestamp : undefined);
-        const lastActive = this.parseTimestamp(parsed.lastUpdated) ||
-            lastEntryTimestamp ||
-            stat?.mtime ||
-            new Date();
+        const lastActive = this.parseTimestamp(parsed.lastUpdated) || lastEntryTimestamp || stat?.mtime || new Date();
         const startedAt = this.parseTimestamp(parsed.startTime) || stat?.birthtime || stat?.mtime || lastActive;
         return {
             type: 'gemini_cli',
@@ -456,18 +468,17 @@ export class GeminiCliAdapter {
             firstUserMessage,
             lastActive,
             startedAt,
-            sessionFilePath: filePath,
+            sessionFilePath: filePath
         };
     }
     extractFirstUserMessage(messages) {
-        for (const entry of messages) {
-            if (entry?.type !== 'user')
-                continue;
+        for (const entry of messages){
+            if (entry?.type !== 'user') continue;
             const text = this.messageText(entry).trim();
-            if (text)
-                return text;
+            if (text) return text;
         }
         return '';
     }
 }
+
 //# sourceMappingURL=GeminiCliAdapter.js.map