@ai-devkit/agent-manager 0.37.0 → 0.39.0

package/src/{utils/agents.ts → harnesses/runtimeProfiles.ts}

@@ -1,44 +1,47 @@
-import path from "path";
-import type { AGENT_TYPES } from "../adapters/AgentAdapter.js";
-import { executablePath } from "./process.js";
+import path from "node:path";
+import { AGENT_TYPES, type AgentType } from "../adapters/AgentAdapter.js";
+import { executablePath } from "../utils/process.js";
 
-/** Every built-in harness can be started, so each needs an {@link AGENTS} entry. */
 export type StartableAgentType = (typeof AGENT_TYPES)[number];
 
-export interface AgentConfig {
-  /** Shell command to launch the agent (sent to tmux via `send-keys`). */
+export interface HarnessRuntimeProfile {
   command: string;
-  /** Returns true if the given `ps` command line belongs to this agent. */
+  runtimeKind: string;
+  discoveryAliases: readonly string[];
   matches: (psCommand: string) => boolean;
 }
 
-/**
- * Per-agent configuration: launch command plus a matcher that recognizes the
- * agent's process in `ps` output. Each matcher knows that agent's distribution
- * quirks (e.g. gemini ships as a Node script so its real binary is in argv[1..]).
- */
-export const AGENTS: Record<StartableAgentType, AgentConfig> = {
-  claude: { command: "claude", matches: matchArgv0("claude") },
-  codex: { command: "codex", matches: matchArgv0("codex") },
-  copilot: { command: "copilot", matches: matchArgv0Name("copilot-cli") },
-  gemini_cli: { command: "gemini", matches: matchAnyToken("gemini") },
-  grok_cli: { command: "grok", matches: matchArgv0("grok") },
-  antigravity_cli: { command: "agy", matches: matchArgv0("agy") },
-  opencode: { command: "opencode", matches: matchArgv0("opencode") },
-  pi: { command: "pi", matches: matchAnyBasename(["pi"]) },
-  kiro: { command: "kiro-cli", matches: matchAnyBasename(["kiro-cli", "kiro"]) },
+export const HARNESS_RUNTIME_PROFILES: Record<StartableAgentType, HarnessRuntimeProfile> = {
+  claude: profile("claude", matchArgv0("claude")),
+  codex: profile("codex", matchArgv0("codex")),
+  copilot: profile("copilot", matchArgv0Name("copilot-cli")),
+  gemini_cli: profile("gemini", matchAnyBasename(["gemini"]), ["gemini_cli"]),
+  grok_cli: profile("grok", matchArgv0("grok"), ["grok_cli"]),
+  antigravity_cli: profile("agy", matchArgv0("agy"), ["antigravity", "antigravity_cli"]),
+  opencode: profile("opencode", matchArgv0("opencode")),
+  pi: profile("pi", matchAnyBasename(["pi"])),
+  kiro: profile("kiro", matchAnyBasename(["kiro-cli", "kiro"]), ["kiro_cli", "kiro-cli"]),
+  devin: profile("devin", matchArgv0("devin")),
 };
 
-/**
- * Matchers read a `ps` command line, where argv is joined with spaces. argv[0]
- * is resolved with {@link executablePath} so executables installed under
- * directories containing spaces are recognised, while arguments are never
- * folded into the executable path unless that combined path is a real file.
- *
- * The filesystem is consulted only when a token after the first could be part
- * of a matching argv[0]; commands whose first token already decides the match,
- * or that contain no candidate token at all, are handled with string checks.
- */
+export function runtimeAgentMatchesHarness(runtimeAgent: string, type: AgentType): boolean {
+  if (type === "other") return runtimeAgent.toLowerCase() === "other";
+  return HARNESS_RUNTIME_PROFILES[type].discoveryAliases.includes(runtimeAgent.toLowerCase());
+}
+
+function profile(
+  runtimeKind: string,
+  matches: (psCommand: string) => boolean,
+  extraAliases: readonly string[] = [],
+): HarnessRuntimeProfile {
+  return {
+    command: runtimeKind === "kiro" ? "kiro-cli" : runtimeKind,
+    runtimeKind,
+    discoveryAliases: [runtimeKind, ...extraAliases],
+    matches,
+  };
+}
+
 const ABSOLUTE_PATH = /^(?:\/|[a-zA-Z]:[\\/])/;
 const PATH_SEPARATOR = /[\\/]/;
 
@@ -50,14 +53,12 @@ function tokensOf(psCommand: string): string[] {
   return psCommand.trim().split(/\s+/).filter(Boolean);
 }
 
-/** Split a command line into its resolved argv[0] and the remaining argument tokens. */
 function splitArgv0(psCommand: string): { argv0: string; args: string[] } {
   const command = psCommand.trim();
   const argv0 = executablePath(command);
   return { argv0, args: tokensOf(command.slice(argv0.length)) };
 }
 
-/** Whether argv[0] may span several tokens, i.e. a later path-like token satisfies `test`. */
 function mayContinueArgv0(tokens: string[], test: (token: string) => boolean): boolean {
   return (
     ABSOLUTE_PATH.test(tokens[0]) &&
@@ -87,10 +88,6 @@ function matchArgv0Name(name: string): (psCommand: string) => boolean {
   };
 }
 
-function matchAnyToken(name: string): (psCommand: string) => boolean {
-  return matchAnyBasename([name]);
-}
-
 function matchAnyBasename(names: string[]): (psCommand: string) => boolean {
   const lowers = new Set(names.map((name) => name.toLowerCase()));
   const test = (token: string) => lowers.has(basenameOf(token));

package/src/index.ts

@@ -1,73 +1,41 @@
-export { AgentManager, AgentNotRunningError } from "./AgentManager.js";
+export { AgentManager } from "./AgentManager.js";
 export {
+  getAnthropicCapacityReport,
   getClaudeCapacityReport,
   getCodexCapacityReport,
   getOpenAiCapacityReport,
   getZaiCapacityReport,
 } from "./capacity/index.js";
-export type {
-  ClaudeCapacityOptions,
-  CapacityProbeOptions,
-  CapacityReport,
-  CapacityWindow,
-  OpenAiCapacityOptions,
-  ZaiCapacityOptions,
-} from "./capacity/index.js";
+export type { CapacityReport, CapacityWindow } from "./capacity/index.js";
+
 export {
-  getAgentReadinessReport,
   getAgentReadinessReports,
   worstReadinessStatus,
-} from "./readiness/AgentReadiness.js";
+} from "./harnesses/readiness/AgentReadiness.js";
 export type {
   AgentReadinessOptions,
   AgentReadinessReport,
-  AuthReadinessCheck,
-  BuiltInSkillsReadinessCheck,
-  DirectoryReadinessCheck,
-  ExecutableReadinessCheck,
-  IntegrationReadinessCheck,
   ReadinessAgentType,
-  ReadinessAuthState,
-  ReadinessCheck,
   ReadinessStatus,
-} from "./readiness/AgentReadiness.js";
+} from "./harnesses/readiness/AgentReadiness.js";
 
-export { ClaudeCodeAdapter } from "./harnesses/claude/ClaudeCodeAdapter.js";
-export { CodexAdapter } from "./harnesses/codex/CodexAdapter.js";
-export { CopilotAdapter } from "./harnesses/copilot/CopilotAdapter.js";
-export { GeminiCliAdapter } from "./harnesses/gemini/GeminiCliAdapter.js";
-export { GrokCliAdapter } from "./harnesses/grok/GrokCliAdapter.js";
-export { AntigravityCliAdapter } from "./harnesses/antigravity/AntigravityCliAdapter.js";
-export { KiroAdapter } from "./harnesses/kiro/KiroAdapter.js";
-export { OpenCodeAdapter } from "./harnesses/opencode/OpenCodeAdapter.js";
-export { PiAdapter } from "./harnesses/pi/PiAdapter.js";
 export { createBuiltinAdapters } from "./harnesses/index.js";
+export { HARNESS_RUNTIME_PROFILES, type StartableAgentType } from "./harnesses/runtimeProfiles.js";
 export { AGENT_TYPES, AgentStatus } from "./adapters/AgentAdapter.js";
 export type {
   AgentAdapter,
   AgentType,
   AgentInfo,
-  ProcessInfo,
   ConversationMessage,
-  ConversationOptions,
   SessionSummary,
   ListSessionsOptions,
-  AgentDetectionContext,
 } from "./adapters/AgentAdapter.js";
 
-export { TerminalFocusManager, TerminalType } from "./terminal/TerminalFocusManager.js";
-export type { TerminalLocation } from "./terminal/TerminalFocusManager.js";
+export { TerminalFocusManager } from "./terminal/TerminalFocusManager.js";
+export { TerminalType } from "./terminal/types.js";
+export type { TerminalLocation } from "./terminal/types.js";
 export { TtyWriter } from "./terminal/TtyWriter.js";
 
-export type { AgentManagerOptions, ListAgentsOptions } from "./AgentManager.js";
-export {
-  extractHerdrAgentPanes,
-  fetchHerdrAgentPanes,
-  findMatchingHerdrPane,
-  herdrPaneToRuntimeRef,
-} from "./runtime/herdr/HerdrAgentDiscovery.js";
-export type { HerdrAgentPane } from "./runtime/herdr/HerdrAgentDiscovery.js";
-
 export {
   AgentRegistry,
   RenameNotFoundError,
@@ -75,14 +43,8 @@ export {
   AGENT_RUNTIME_PROVIDERS,
   parseTmuxRuntimeRef,
 } from "./utils/AgentRegistry.js";
-export type {
-  AgentRegistryOptions,
-  RegistryEntry,
-  AgentRuntimeProvider,
-  TmuxRuntimeRef,
-} from "./utils/AgentRegistry.js";
-export { TmuxManager } from "./terminal/TmuxManager.js";
-export type { AgentRuntimeAvailability, InteractiveAgentRuntime } from "./runtime/types.js";
+export type { AgentRuntimeProvider } from "./utils/AgentRegistry.js";
+export type { InteractiveAgentRuntime } from "./runtime/types.js";
 export {
   startAgent,
   stopAgent,
@@ -93,90 +55,15 @@ export {
   AgentPidPollTimeoutError,
   AgentRuntimeUnavailableError,
   AgentTerminalNotFoundError,
-  DEFAULT_PID_POLL_INTERVAL_MS,
   DEFAULT_PID_POLL_TIMEOUT_MS,
 } from "./runtime/ManagedAgentRuntime.js";
-export type {
-  FocusAgentDeps,
-  StartAgentDeps,
-  StartAgentOptions,
-  StopAgentDeps,
-  StopAgentResult,
-  FocusAgentResult,
-  SendAgentPromptDeps,
-} from "./runtime/ManagedAgentRuntime.js";
-export { AGENTS } from "./utils/agents.js";
-export type { AgentConfig, StartableAgentType } from "./utils/agents.js";
 
 export type { AgentRequest } from "./utils/agent-requests.js";
-export {
-  getAgentRequestPath,
-  readLatestAgentRequest,
-  writeAgentRequest,
-} from "./utils/agent-requests.js";
+export { readLatestAgentRequest, writeAgentRequest } from "./utils/agent-requests.js";
 
-export {
-  AGENT_MODES,
-  DurableAgentError,
-  DurableAgentBusyError,
-  DurableAgentNotFoundError,
-  DurableAgentRepositoryError,
-  DurableAgentNameConflictError,
-  ClaudePrintError,
-  CodexPrintError,
-  PiPrintError,
-} from "./durable/DurableAgent.js";
-export type {
-  DurableAgent,
-  DurableAgentBase,
-  ClaudeDurableAgent,
-  CodexDurableAgent,
-  PiDurableAgent,
-  DurableProvider,
-  CodexPrintErrorCode,
-  DurableAgentState,
-  DurableSessionHealth,
-  DurableRunStatus,
-  DurableActiveRun,
-  DurableLastResult,
-  PiPrintErrorCode,
-  ProcessIdentity,
-} from "./durable/DurableAgent.js";
+export { AGENT_MODES } from "./durable/DurableAgent.js";
+export type { DurableProvider } from "./durable/DurableAgent.js";
 export { DurableAgentRepository } from "./durable/DurableAgentRepository.js";
-export type {
-  CreateDurableAgentInput,
-  DurableAgentRepositoryOptions,
-  ProcessInspector,
-  DurableRunCompletion,
-} from "./durable/DurableAgentRepository.js";
 export { ClaudePrintAgentService } from "./harnesses/claude/durable/ClaudePrintAgentService.js";
-export type {
-  ClaudePrintAgentServiceOptions,
-  ClaudePrintSendResult,
-} from "./harnesses/claude/durable/ClaudePrintAgentService.js";
-export { CodexCliProbe } from "./harnesses/codex/durable/CodexCliProbe.js";
-export type { CodexCliProbeOptions } from "./harnesses/codex/durable/CodexCliProbe.js";
-export { CodexPrintRunner } from "./harnesses/codex/durable/CodexPrintRunner.js";
-export type {
-  CodexPrintRunnerOptions,
-  CodexPrintRunRequest,
-  CodexPrintRunResult,
-} from "./harnesses/codex/durable/CodexPrintRunner.js";
 export { CodexPrintAgentService } from "./harnesses/codex/durable/CodexPrintAgentService.js";
-export type {
-  CodexPrintAgentServiceOptions,
-  CodexPrintSendResult,
-} from "./harnesses/codex/durable/CodexPrintAgentService.js";
-export { PiCliProbe } from "./harnesses/pi/durable/PiCliProbe.js";
-export type { PiCliProbeOptions } from "./harnesses/pi/durable/PiCliProbe.js";
-export { PiPrintRunner } from "./harnesses/pi/durable/PiPrintRunner.js";
-export type {
-  PiPrintRunnerOptions,
-  PiPrintRunRequest,
-  PiPrintRunResult,
-} from "./harnesses/pi/durable/PiPrintRunner.js";
 export { PiPrintAgentService } from "./harnesses/pi/durable/PiPrintAgentService.js";
-export type {
-  PiPrintAgentServiceOptions,
-  PiPrintSendResult,
-} from "./harnesses/pi/durable/PiPrintAgentService.js";

package/src/runtime/ManagedAgentRuntime.ts

@@ -1,12 +1,12 @@
 import type { AgentInfo } from "../adapters/AgentAdapter.js";
-import type { TerminalLocation } from "../terminal/TerminalFocusManager.js";
-import { TmuxManager } from "../terminal/TmuxManager.js";
+import type { TerminalLocation } from "../terminal/types.js";
+import { TmuxManager } from "./tmux/TmuxManager.js";
 import {
   AgentRegistry,
   type AgentRuntimeProvider,
   type RegistryEntry,
 } from "../utils/AgentRegistry.js";
-import { AGENTS, type StartableAgentType } from "../utils/agents.js";
+import { HARNESS_RUNTIME_PROFILES, type StartableAgentType } from "../harnesses/runtimeProfiles.js";
 import { createInteractiveRuntime } from "./RuntimeFactory.js";
 import { DEFAULT_PID_POLL_INTERVAL_MS, DEFAULT_PID_POLL_TIMEOUT_MS } from "./tmux/PidPolling.js";
 import { TmuxAgentRuntime } from "./tmux/TmuxAgentRuntime.js";
@@ -91,7 +91,7 @@ export async function startAgent(
   deps: StartAgentDeps = {},
 ): Promise<RegistryEntry> {
   const registry = deps.registry ?? AgentRegistry.default();
-  const agent = AGENTS[opts.type];
+  const profile = HARNESS_RUNTIME_PROFILES[opts.type];
   const intervalMs = opts.pollIntervalMs ?? DEFAULT_PID_POLL_INTERVAL_MS;
   const timeoutMs = opts.pollTimeoutMs ?? DEFAULT_PID_POLL_TIMEOUT_MS;
   const provider = opts.runtimeProvider ?? deps.runtime?.provider ?? "tmux";
@@ -119,13 +119,13 @@ export async function startAgent(
   const result = await runtime.startAgent({
     name: opts.name,
     cwd: opts.cwd,
-    kind: agentRuntimeKind(opts.type, provider),
+    kind: profile.runtimeKind,
     args: [],
     timeoutMs,
     ...(provider === "tmux"
       ? {
-          command: agent.command,
-          matches: agent.matches,
+          command: profile.command,
+          matches: profile.matches,
           pollIntervalMs: intervalMs,
         }
       : {}),
@@ -251,18 +251,3 @@ function isHerdrRegistryEntry(
     "runtimeRef" in entry
   );
 }
-
-function agentRuntimeKind(type: StartableAgentType, provider: AgentRuntimeProvider): string {
-  if (provider === "tmux") return type;
-  return {
-    claude: "claude",
-    codex: "codex",
-    copilot: "copilot",
-    gemini_cli: "gemini",
-    grok_cli: "grok",
-    antigravity_cli: "agy",
-    opencode: "opencode",
-    pi: "pi",
-    kiro: "kiro",
-  }[type];
-}

package/src/runtime/herdr/HerdrAgentDiscovery.ts

@@ -1,4 +1,5 @@
-import type { AgentInfo, AgentType } from "../../adapters/AgentAdapter.js";
+import type { AgentInfo } from "../../adapters/AgentAdapter.js";
+import { runtimeAgentMatchesHarness } from "../../harnesses/runtimeProfiles.js";
 import { HerdrCliClient, type HerdrCommandRunner } from "./HerdrCliClient.js";
 import type { HerdrRuntimeRef } from "./HerdrRuntimeRef.js";
 
@@ -70,7 +71,7 @@ export function findMatchingHerdrPane(
   if (shellPidMatches.length > 1) return null;
 
   const cwdMatches = panes.filter(
-    (pane) => pane.cwd === agent.projectPath && herdrAgentMatchesType(pane.agent, agent.type),
+    (pane) => pane.cwd === agent.projectPath && runtimeAgentMatchesHarness(pane.agent, agent.type),
   );
   return cwdMatches.length === 1 ? cwdMatches[0]! : null;
 }
@@ -85,23 +86,6 @@ export function herdrPaneToRuntimeRef(pane: HerdrAgentPane, agentName: string):
   };
 }
 
-function herdrAgentMatchesType(herdrAgent: string, agentType: AgentType): boolean {
-  const normalized = herdrAgent.toLowerCase();
-  const candidates: Record<AgentType, readonly string[]> = {
-    claude: ["claude"],
-    codex: ["codex"],
-    copilot: ["copilot"],
-    gemini_cli: ["gemini", "gemini_cli"],
-    grok_cli: ["grok", "grok_cli"],
-    antigravity_cli: ["agy", "antigravity", "antigravity_cli"],
-    kiro: ["kiro", "kiro_cli", "kiro-cli"],
-    opencode: ["opencode"],
-    pi: ["pi"],
-    other: ["other"],
-  };
-  return candidates[agentType]?.includes(normalized) ?? false;
-}
-
 async function enrichHerdrAgentPanes(
   client: HerdrCliClient,
   panes: HerdrAgentPane[],

package/src/runtime/tmux/PidPolling.ts

@@ -1,4 +1,4 @@
-import type { TmuxManager } from "../../terminal/TmuxManager.js";
+import type { TmuxManager } from "./TmuxManager.js";
 
 export const DEFAULT_PID_POLL_INTERVAL_MS = 500;
 export const DEFAULT_PID_POLL_TIMEOUT_MS = 15_000;

package/src/runtime/tmux/TmuxAgentRuntime.ts

@@ -1,4 +1,4 @@
-import { TmuxManager } from "../../terminal/TmuxManager.js";
+import { TmuxManager } from "./TmuxManager.js";
 import { TtyWriter } from "../../terminal/TtyWriter.js";
 import { AgentPidPollTimeoutError, AgentTerminalNotFoundError } from "../errors.js";
 import { pollForPid } from "./PidPolling.js";

package/src/{terminal → runtime/tmux}/TmuxManager.ts

@@ -1,5 +1,5 @@
-import { execFile } from "child_process";
-import { promisify } from "util";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 
 const execFileAsync = promisify(execFile);
 
@@ -38,22 +38,6 @@ export class TmuxManager {
     }
   }
 
-  /**
-   * Find the actual agent process PID inside a tmux pane.
-   *
-   * Strategy: BFS the process tree, return the deepest process whose
-   * `ps` command line is accepted by `matches`. The caller supplies the
-   * matcher so this method has no agent-type knowledge.
-   *
-   * This handles two real-world process shapes:
-   * - Wrapper case: shell → claude-wrapper (matches) → claude (matches, deeper)
-   *   → returns the deeper one
-   * - Subprocess case: shell → claude (matches) → MCP server child (doesn't match)
-   *   → returns claude, not the subprocess
-   *
-   * Returns null when no process matches yet (agent still starting); the
-   * caller's poll loop retries.
-   */
   async findAgentPid(
     session: string,
     matches: (psCommand: string) => boolean,
@@ -71,12 +55,8 @@ export class TmuxManager {
       visited.add(pid);
 
       const command = await this.getProcessCommand(pid);
-      if (command && matches(command)) {
-        deepestMatch = pid;
-      }
-
-      const children = await this.pgrepChildren(pid);
-      queue.push(...children);
+      if (command && matches(command)) deepestMatch = pid;
+      queue.push(...(await this.pgrepChildren(pid)));
     }
 
     return deepestMatch;
@@ -91,8 +71,8 @@ export class TmuxManager {
         "-F",
         "#{pane_pid}",
       ]);
-      const panePid = parseInt(stdout.trim().split("\n")[0], 10);
-      return isNaN(panePid) ? null : panePid;
+      const panePid = Number.parseInt(stdout.trim().split("\n")[0], 10);
+      return Number.isNaN(panePid) ? null : panePid;
     } catch {
       return null;
     }
@@ -104,8 +84,8 @@ export class TmuxManager {
       return stdout
         .trim()
         .split("\n")
-        .map((s) => parseInt(s, 10))
-        .filter((n) => !isNaN(n));
+        .map((value) => Number.parseInt(value, 10))
+        .filter((value) => !Number.isNaN(value));
     } catch {
       return [];
     }
@@ -114,8 +94,7 @@ export class TmuxManager {
   private async getProcessCommand(pid: number): Promise<string | null> {
     try {
       const { stdout } = await execFileAsync("ps", ["-p", String(pid), "-o", "command="]);
-      const trimmed = stdout.trim();
-      return trimmed || null;
+      return stdout.trim() || null;
     } catch {
       return null;
     }

package/src/runtime/types.ts

@@ -1,5 +1,5 @@
 import type { AgentInfo } from "../adapters/AgentAdapter.js";
-import type { TerminalLocation } from "../terminal/TerminalFocusManager.js";
+import type { TerminalLocation } from "../terminal/types.js";
 import type { AgentRuntimeProvider } from "../utils/AgentRegistry.js";
 
 export type AgentRuntimeAvailability =