@ai-devkit/agent-manager 0.32.0 → 0.33.0

package/src/utils/AgentRegistry.ts

@@ -1,288 +1,349 @@
-import os from 'os';
-import path from 'path';
-import type { AgentType } from '../adapters/AgentAdapter.js';
-import {
-    DatabaseConnection,
-    resolveAgentRegistryDbPath,
-} from '../database/index.js';
+import os from "os";
+import path from "path";
+import type { AgentType } from "../adapters/AgentAdapter.js";
+import { DatabaseConnection, resolveAgentRegistryDbPath } from "../database/index.js";
+import { parseTmuxRuntimeRef, type TmuxRuntimeRef } from "../runtime/tmux/TmuxRuntimeRef.js";
 
 export class RenameNotFoundError extends Error {
-    constructor(public agentName: string) {
-        super(`Agent "${agentName}" not found in registry.`);
-        this.name = 'RenameNotFoundError';
-    }
+  constructor(public agentName: string) {
+    super(`Agent "${agentName}" not found in registry.`);
+    this.name = "RenameNotFoundError";
+  }
 }
 
 export class RenameConflictError extends Error {
-    constructor(public agentName: string) {
-        super(`Agent "${agentName}" is already in use.`);
-        this.name = 'RenameConflictError';
-    }
+  constructor(public agentName: string) {
+    super(`Agent "${agentName}" is already in use.`);
+    this.name = "RenameConflictError";
+  }
 }
 
 export interface RegistryEntry {
-    name: string;
-    type: AgentType;
-    pid: number;
-    tmuxSession: string;
-    cwd: string;
-    startedAt: string;  // ISO 8601
-    sessionId: string;
-    sessionFilePath: string;
-    pinned: boolean;
-    updatedAt?: string;
+  name: string;
+  type: AgentType;
+  pid: number;
+  runtime: AgentRuntimeProvider;
+  runtimeRef: unknown | null;
+  cwd: string;
+  startedAt: string; // ISO 8601
+  sessionId: string;
+  sessionFilePath: string;
+  pinned: boolean;
+  updatedAt?: string;
 }
 
 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;
-    pinned: number;
+  name: string;
+  type: AgentType;
+  pid: number;
+  tmux_session: string;
+  runtime?: string;
+  runtime_ref?: string;
+  cwd: string;
+  started_at: string;
+  session_id: string;
+  session_file_path: string;
+  updated_at: string;
+  pinned: number;
 }
 
-const DEFAULT_REGISTRY_PATH = path.join(os.homedir(), '.ai-devkit', 'agents.json');
+export const AGENT_RUNTIME_PROVIDERS = ["tmux", "herdr"] as const;
+export type AgentRuntimeProvider = (typeof AGENT_RUNTIME_PROVIDERS)[number];
+
+const DEFAULT_REGISTRY_PATH = path.join(os.homedir(), ".ai-devkit", "agents.json");
 const DEFAULT_PRUNE_INTERVAL_MS = 30_000;
 
 let defaultInstance: AgentRegistry | null = null;
 
 export interface AgentRegistryOptions {
-    now?: () => Date;
-    pruneIntervalMs?: number;
-    onDatabaseOperation?: (sql: string) => void;
-    readonly?: boolean;
+  now?: () => Date;
+  pruneIntervalMs?: number;
+  onDatabaseOperation?: (sql: string) => void;
+  readonly?: boolean;
 }
 
 export class AgentRegistry {
-    private db: DatabaseConnection;
-    private readonly now: () => Date;
-    private readonly pruneIntervalMs: number;
-    private readonly readonly: boolean;
-    private lastPrunedAt: number | undefined;
-
-    constructor(filePath: string = DEFAULT_REGISTRY_PATH, options: AgentRegistryOptions = {}) {
-        this.now = options.now ?? (() => new Date());
-        this.pruneIntervalMs = options.pruneIntervalMs ?? DEFAULT_PRUNE_INTERVAL_MS;
-        this.readonly = options.readonly ?? false;
-        this.db = new DatabaseConnection({
-            dbPath: resolveAgentRegistryDbPath(filePath),
-            verbose: options.onDatabaseOperation,
-            readonly: this.readonly,
-        });
-    }
-
-    static default(): AgentRegistry {
-        if (!defaultInstance) {
-            defaultInstance = new AgentRegistry();
-        }
-        return defaultInstance;
-    }
-
-    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,
-            pinned: row.pinned !== 0,
-            updatedAt: row.updated_at,
-        };
-    }
-
-    private mergeEntry(incoming: RegistryEntry, existing: RegistryEntry | undefined): RegistryEntry {
-        if (!existing) return incoming;
-        const incomingIsManaged = Boolean(incoming.tmuxSession);
-        return {
-            ...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 db: DatabaseConnection;
+  private readonly now: () => Date;
+  private readonly pruneIntervalMs: number;
+  private readonly readonly: boolean;
+  private lastPrunedAt: number | undefined;
+
+  constructor(filePath: string = DEFAULT_REGISTRY_PATH, options: AgentRegistryOptions = {}) {
+    this.now = options.now ?? (() => new Date());
+    this.pruneIntervalMs = options.pruneIntervalMs ?? DEFAULT_PRUNE_INTERVAL_MS;
+    this.readonly = options.readonly ?? false;
+    this.db = new DatabaseConnection({
+      dbPath: resolveAgentRegistryDbPath(filePath),
+      verbose: options.onDatabaseOperation,
+      readonly: this.readonly,
+    });
+  }
+
+  static default(): AgentRegistry {
+    if (!defaultInstance) {
+      defaultInstance = new AgentRegistry();
     }
-
-    private findPidConflicts(type: AgentType, pid: number): RegistryEntry[] {
-        return this.db.query<RegistryRow>(
-            'SELECT * FROM agents WHERE pid = ? AND type <> ?',
-            [pid, type],
-        ).map((row) => this.rowToEntry(row));
+    return defaultInstance;
+  }
+
+  private rowToEntry(row: RegistryRow): RegistryEntry {
+    const runtime = this.parseRuntime(row.runtime);
+    return {
+      name: row.name,
+      type: row.type,
+      pid: row.pid,
+      runtime,
+      runtimeRef: this.parseRuntimeRef(runtime, row.runtime_ref, row.tmux_session),
+      cwd: row.cwd,
+      startedAt: row.started_at,
+      sessionId: row.session_id,
+      sessionFilePath: row.session_file_path,
+      pinned: row.pinned !== 0,
+      updatedAt: row.updated_at,
+    };
+  }
+
+  private parseRuntime(value: string | undefined): AgentRuntimeProvider {
+    return value === "herdr" ? "herdr" : "tmux";
+  }
+
+  private parseRuntimeRef(
+    runtime: AgentRuntimeProvider,
+    raw: string | undefined,
+    legacyTmuxSession: string,
+  ): unknown | null {
+    if (raw) {
+      try {
+        return JSON.parse(raw) as unknown;
+      } catch {
+        return null;
+      }
     }
 
-    private entriesEqual(left: RegistryEntry, right: RegistryEntry): boolean {
-        return left.name === right.name
-            && left.type === right.type
-            && left.pid === right.pid
-            && left.tmuxSession === right.tmuxSession
-            && left.cwd === right.cwd
-            && left.startedAt === right.startedAt
-            && left.sessionId === right.sessionId
-            && left.sessionFilePath === right.sessionFilePath;
+    if (runtime === "tmux" && legacyTmuxSession) {
+      return { session: legacyTmuxSession };
     }
 
-    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]);
-        }
+    return null;
+  }
+
+  private mergeEntry(incoming: RegistryEntry, existing: RegistryEntry | undefined): RegistryEntry {
+    if (!existing) return incoming;
+    const incomingIsManaged =
+      incoming.runtime === "herdr" || Boolean(parseTmuxRuntimeRef(incoming.runtimeRef));
+    return {
+      ...existing,
+      name: incomingIsManaged ? incoming.name : existing.name,
+      runtime: incoming.runtime ?? existing.runtime,
+      runtimeRef: incoming.runtimeRef ?? existing.runtimeRef,
+      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 findPidConflicts(type: AgentType, pid: number): RegistryEntry[] {
+    return this.db
+      .query<RegistryRow>("SELECT * FROM agents WHERE pid = ? AND type <> ?", [pid, type])
+      .map((row) => this.rowToEntry(row));
+  }
+
+  private entriesEqual(left: RegistryEntry, right: RegistryEntry): boolean {
+    return (
+      left.name === right.name &&
+      left.type === right.type &&
+      left.pid === right.pid &&
+      left.runtime === right.runtime &&
+      JSON.stringify(left.runtimeRef ?? null) === JSON.stringify(right.runtimeRef ?? null) &&
+      left.cwd === right.cwd &&
+      left.startedAt === right.startedAt &&
+      left.sessionId === right.sessionId &&
+      left.sessionFilePath === right.sessionFilePath
+    );
+  }
+
+  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(`
+  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
+                , runtime, runtime_ref
             )
             VALUES (
-                @type, @pid, @name, @tmuxSession, @cwd, @startedAt, @sessionId, @sessionFilePath, @updatedAt
+                @type, @pid, @name, @legacyTmuxSession, @cwd, @startedAt, @sessionId, @sessionFilePath, @updatedAt
+                , @runtime, @runtimeRefJson
             )
             ON CONFLICT(type, pid) DO UPDATE SET
                 name = excluded.name,
                 tmux_session = excluded.tmux_session,
+                runtime = excluded.runtime,
+                runtime_ref = excluded.runtime_ref,
                 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: this.now().toISOString() });
+        `)
+      .run({
+        ...entry,
+        legacyTmuxSession: parseTmuxRuntimeRef(entry.runtimeRef)?.session ?? "",
+        runtimeRefJson: JSON.stringify(entry.runtimeRef ?? null),
+        updatedAt: this.now().toISOString(),
+      });
+  }
+
+  private needsWrite(incoming: RegistryEntry): boolean {
+    const existing = this.findByIdentity(incoming.type, incoming.pid);
+    const merged = this.mergeEntry(incoming, existing);
+    return (
+      !existing ||
+      !this.entriesEqual(merged, existing) ||
+      this.findPidConflicts(incoming.type, incoming.pid).length > 0
+    );
+  }
+
+  private save(incoming: RegistryEntry): void {
+    const existing = this.findByIdentity(incoming.type, incoming.pid);
+    const merged = this.mergeEntry(incoming, existing);
+    const pidConflicts = this.findPidConflicts(incoming.type, incoming.pid);
+    if (existing && this.entriesEqual(merged, existing) && pidConflicts.length === 0) return;
+
+    for (const conflict of pidConflicts) {
+      this.db.execute("DELETE FROM agents WHERE type = ? AND pid = ?", [
+        conflict.type,
+        conflict.pid,
+      ]);
     }
-
-    private needsWrite(incoming: RegistryEntry): boolean {
-        const existing = this.findByIdentity(incoming.type, incoming.pid);
-        const merged = this.mergeEntry(incoming, existing);
-        return !existing
-            || !this.entriesEqual(merged, existing)
-            || this.findPidConflicts(incoming.type, incoming.pid).length > 0;
+    if (existing && this.entriesEqual(merged, existing)) return;
+
+    this.deleteNameConflict(merged.name, merged.type, merged.pid);
+    this.insertOrUpdate(merged);
+  }
+
+  isAlive(entry: RegistryEntry): boolean {
+    try {
+      process.kill(entry.pid, 0);
+      return true;
+    } catch (error) {
+      const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+      return code !== "ESRCH";
     }
-
-    private save(incoming: RegistryEntry): void {
-        const existing = this.findByIdentity(incoming.type, incoming.pid);
-        const merged = this.mergeEntry(incoming, existing);
-        const pidConflicts = this.findPidConflicts(incoming.type, incoming.pid);
-        if (existing && this.entriesEqual(merged, existing) && pidConflicts.length === 0) return;
-
-        for (const conflict of pidConflicts) {
-            this.db.execute('DELETE FROM agents WHERE type = ? AND pid = ?', [conflict.type, conflict.pid]);
+  }
+
+  private pruneAt(nowMs: number): void {
+    const entries = this.list();
+    const stale = entries.filter((e) => !this.isAlive(e));
+    if (stale.length > 0) {
+      this.db.transaction(() => {
+        for (const entry of stale) {
+          this.db.execute("DELETE FROM agents WHERE type = ? AND pid = ?", [entry.type, entry.pid]);
         }
-        if (existing && this.entriesEqual(merged, existing)) return;
-
-        this.deleteNameConflict(merged.name, merged.type, merged.pid);
-        this.insertOrUpdate(merged);
+      });
     }
-
-    isAlive(entry: RegistryEntry): boolean {
-        try {
-            process.kill(entry.pid, 0);
-            return true;
-        } catch (error) {
-            const code = error && typeof error === 'object' && 'code' in error
-                ? error.code
-                : undefined;
-            return code !== 'ESRCH';
-        }
+    this.lastPrunedAt = nowMs;
+  }
+
+  prune(): void {
+    this.pruneAt(this.now().getTime());
+  }
+
+  pruneIfDue(): void {
+    const nowMs = this.now().getTime();
+    const elapsed = this.lastPrunedAt === undefined ? undefined : nowMs - this.lastPrunedAt;
+    if (elapsed !== undefined && elapsed >= 0 && elapsed < this.pruneIntervalMs) return;
+    this.pruneAt(nowMs);
+  }
+
+  register(entry: RegistryEntry): void {
+    this.registerBatch([entry]);
+  }
+
+  registerBatch(entries: RegistryEntry[]): void {
+    if (entries.length === 0) return;
+    if (!entries.some((entry) => this.needsWrite(entry))) return;
+    this.db.transaction(() => {
+      for (const incoming of entries) {
+        this.save(incoming);
+      }
+    });
+  }
+
+  rename(currentName: string, newName: string): void {
+    const existing = this.findByName(currentName);
+    if (!existing) {
+      throw new RenameNotFoundError(currentName);
     }
-
-    private pruneAt(nowMs: number): void {
-        const entries = this.list();
-        const stale = entries.filter((e) => !this.isAlive(e));
-        if (stale.length > 0) {
-            this.db.transaction(() => {
-                for (const entry of stale) {
-                    this.db.execute('DELETE FROM agents WHERE type = ? AND pid = ?', [entry.type, entry.pid]);
-                }
-            });
-        }
-        this.lastPrunedAt = nowMs;
-    }
-
-    prune(): void {
-        this.pruneAt(this.now().getTime());
-    }
-
-    pruneIfDue(): void {
-        const nowMs = this.now().getTime();
-        const elapsed = this.lastPrunedAt === undefined ? undefined : nowMs - this.lastPrunedAt;
-        if (elapsed !== undefined && elapsed >= 0 && elapsed < this.pruneIntervalMs) return;
-        this.pruneAt(nowMs);
+    const conflict = this.findByName(newName);
+    if (conflict && this.isAlive(conflict)) {
+      throw new RenameConflictError(newName);
     }
 
-    register(entry: RegistryEntry): void {
-        this.registerBatch([entry]);
-    }
-
-    registerBatch(entries: RegistryEntry[]): void {
-        if (entries.length === 0) return;
-        if (!entries.some((entry) => this.needsWrite(entry))) return;
-        this.db.transaction(() => {
-            for (const incoming of entries) {
-                this.save(incoming);
-            }
-        });
-    }
-
-    rename(currentName: string, newName: string): void {
-        const existing = this.findByName(currentName);
-        if (!existing) {
-            throw new RenameNotFoundError(currentName);
-        }
-        const conflict = this.findByName(newName);
-        if (conflict && this.isAlive(conflict)) {
-            throw new RenameConflictError(newName);
-        }
-
-        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, this.now().toISOString(), existing.type, existing.pid],
-            );
-        });
-    }
-
-    togglePin(type: AgentType, pid: number): boolean | null {
-        if (this.readonly) {
-            throw new Error('Agent registry is readonly; cannot toggle pin.');
-        }
-        const result = this.db.execute(
-            'UPDATE agents SET pinned = NOT pinned, updated_at = ? WHERE type = ? AND pid = ?',
-            [this.now().toISOString(), type, pid],
-        );
-        if (result.changes === 0) return null;
-        return this.findByIdentity(type, pid)?.pinned ?? null;
-    }
-
-    lookup(name: string): RegistryEntry | null {
-        return this.findByName(name) ?? null;
-    }
-
-    list(): RegistryEntry[] {
-        const rows = this.db.query<RegistryRow>('SELECT * FROM agents ORDER BY started_at ASC, name ASC');
-        return rows.map((row) => this.rowToEntry(row));
+    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,
+        this.now().toISOString(),
+        existing.type,
+        existing.pid,
+      ]);
+    });
+  }
+
+  togglePin(type: AgentType, pid: number): boolean | null {
+    if (this.readonly) {
+      throw new Error("Agent registry is readonly; cannot toggle pin.");
     }
+    const result = this.db.execute(
+      "UPDATE agents SET pinned = NOT pinned, updated_at = ? WHERE type = ? AND pid = ?",
+      [this.now().toISOString(), type, pid],
+    );
+    if (result.changes === 0) return null;
+    return this.findByIdentity(type, pid)?.pinned ?? null;
+  }
+
+  lookup(name: string): RegistryEntry | null {
+    return this.findByName(name) ?? null;
+  }
+
+  list(): RegistryEntry[] {
+    const rows = this.db.query<RegistryRow>(
+      "SELECT * FROM agents ORDER BY started_at ASC, name ASC",
+    );
+    return rows.map((row) => this.rowToEntry(row));
+  }
 }
+
+export { parseTmuxRuntimeRef };
+export type { TmuxRuntimeRef };

package/src/utils/agent-requests.ts

@@ -1,28 +1,28 @@
-import * as fs from 'fs';
-import * as path from 'path';
+import * as fs from "fs";
+import * as path from "path";
 
 export interface AgentRequest {
-    sessionId: string;
-    toolName: string;
-    toolInput: Record<string, unknown>;
-    timestamp: string;
+  sessionId: string;
+  toolName: string;
+  toolInput: Record<string, unknown>;
+  timestamp: string;
 }
 
 export function getAgentRequestPath(homeDir: string, sessionId: string): string {
-    return path.join(homeDir, '.ai-devkit', 'agent-requests', `${sessionId}.json`);
+  return path.join(homeDir, ".ai-devkit", "agent-requests", `${sessionId}.json`);
 }
 
 export function readLatestAgentRequest(homeDir: string, sessionId: string): AgentRequest | null {
-    try {
-        const raw = fs.readFileSync(getAgentRequestPath(homeDir, sessionId), 'utf-8');
-        return JSON.parse(raw) as AgentRequest;
-    } catch {
-        return null;
-    }
+  try {
+    const raw = fs.readFileSync(getAgentRequestPath(homeDir, sessionId), "utf-8");
+    return JSON.parse(raw) as AgentRequest;
+  } catch {
+    return null;
+  }
 }
 
 export function writeAgentRequest(homeDir: string, entry: AgentRequest): void {
-    const filePath = getAgentRequestPath(homeDir, entry.sessionId);
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, JSON.stringify(entry, null, 2), 'utf-8');
+  const filePath = getAgentRequestPath(homeDir, entry.sessionId);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(entry, null, 2), "utf-8");
 }