@keyou007/agent-bot 0.1.20-alpha.1 → 0.1.20

package/src/cli/AgentPrerequisites.ts

@@ -1,4 +1,7 @@
 import { spawn } from "node:child_process";
+import { codexVersionIssue, MINIMUM_CODEX_VERSION } from "../codex/CodexVersion.js";
+import { compareSemanticVersions } from "../utils/semanticVersion.js";
+export { compareSemanticVersions } from "../utils/semanticVersion.js";
 
 export type SupportedAgentId = "codex" | "traex";
 export type SupportedAgentState = "missing" | "outdated" | "ready";
@@ -29,6 +32,8 @@ export interface SupportedAgentInspection {
   installedVersion?: string;
   latestVersion?: string;
   latestCheckFailed?: boolean;
+  minimumVersion?: string;
+  compatibilityIssue?: string;
   action?: {
     kind: AgentMaintenanceKind;
     command: string;
@@ -100,6 +105,15 @@ async function inspectCodex(
   const installedVersion = commandVersion(installed);
   if (!installedVersion) return missingInspection("codex", "Codex", platform, env);
 
+  const compatibilityIssue = codexVersionIssue(installedVersion);
+  if (compatibilityIssue) {
+    return {
+      id: "codex", name: "Codex", state: "outdated", installedVersion,
+      minimumVersion: MINIMUM_CODEX_VERSION, compatibilityIssue,
+      action: maintenanceAction("codex", "upgrade", platform, env),
+    };
+  }
+
   const latest = await run(capturedCommand(
     "npm",
     ["view", CODEX_PACKAGE, "version", "--json"],
@@ -294,46 +308,6 @@ function versionInText(value: string): string | undefined {
   return /\b(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)\b/u.exec(value)?.[1];
 }
 
-export function compareSemanticVersions(left: string, right: string): number {
-  const leftVersion = parseSemanticVersion(left);
-  const rightVersion = parseSemanticVersion(right);
-  if (!leftVersion || !rightVersion) return 0;
-  for (let index = 0; index < 3; index += 1) {
-    const difference = leftVersion.core[index]! - rightVersion.core[index]!;
-    if (difference !== 0) return difference;
-  }
-  if (!leftVersion.prerelease && !rightVersion.prerelease) return 0;
-  if (!leftVersion.prerelease) return 1;
-  if (!rightVersion.prerelease) return -1;
-  const length = Math.max(leftVersion.prerelease.length, rightVersion.prerelease.length);
-  for (let index = 0; index < length; index += 1) {
-    const leftPart = leftVersion.prerelease[index];
-    const rightPart = rightVersion.prerelease[index];
-    if (leftPart === undefined) return -1;
-    if (rightPart === undefined) return 1;
-    if (leftPart === rightPart) continue;
-    const leftNumber = /^\d+$/u.test(leftPart) ? Number(leftPart) : undefined;
-    const rightNumber = /^\d+$/u.test(rightPart) ? Number(rightPart) : undefined;
-    if (leftNumber !== undefined && rightNumber !== undefined) return leftNumber - rightNumber;
-    if (leftNumber !== undefined) return -1;
-    if (rightNumber !== undefined) return 1;
-    return leftPart.localeCompare(rightPart);
-  }
-  return 0;
-}
-
-function parseSemanticVersion(value: string): {
-  core: [number, number, number];
-  prerelease?: string[];
-} | undefined {
-  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/u.exec(value);
-  if (!match) return undefined;
-  return {
-    core: [Number(match[1]), Number(match[2]), Number(match[3])],
-    ...(match[4] ? { prerelease: match[4].split(".") } : {}),
-  };
-}
-
 export function runAgentCommand(command: AgentCommandSpec): Promise<AgentCommandResult> {
   return new Promise((resolve) => {
     const invocation = resolveInvocation(command);

package/src/cli/DefaultAgentSelection.ts

@@ -12,7 +12,7 @@ export function selectableDefaultAgents(
   const supported = new Map(inspections.map((inspection) => [inspection.id, inspection]));
   return configured.flatMap((agent) => {
     const inspection = supported.get(agent.name as SupportedAgentInspection["id"]);
-    if (!inspection?.installedVersion) return [];
+    if (!inspection?.installedVersion || inspection.compatibilityIssue) return [];
     return [{
       ...agent,
       installedVersion: inspection.installedVersion,

package/src/cli.ts

@@ -338,6 +338,9 @@ async function initCommand(
     );
     const configuredAgents = readConfiguredAgentSelection(paths.config.path).agents.map((agent) => agent.name);
     const configuredAgentNames = new Set(configuredAgents);
+    for (const agent of inspectedAgents) {
+      if (configuredAgentNames.has(agent.id) && agent.compatibilityIssue) throw new Error(agent.compatibilityIssue);
+    }
     const agents = inspectedAgents.map((agent) => ({
       ...agent,
       configured: configuredAgentNames.has(agent.id),
@@ -554,6 +557,8 @@ async function configureAgentsAndDefault(
 
   const choices = selectableDefaultAgents(configured.agents, inspections);
   if (choices.length === 0) {
+    const issue = inspections.find((inspection) => inspection.compatibilityIssue)?.compatibilityIssue;
+    if (issue) throw new Error(issue);
     throw new Error(cliText(
       "No installed supported Agent was detected. Install Codex or TraeX, then run agentbot init again.",
       "没有检测到已安装且受支持的 Agent。请安装 Codex 或 TraeX，然后重新运行 agentbot init。",
@@ -679,6 +684,10 @@ function printInteractiveAgentInspection(
   inspection: SupportedAgentInspection,
   ui: InitUi,
 ): void {
+  if (inspection.compatibilityIssue) {
+    ui.warn(inspection.compatibilityIssue);
+    return;
+  }
   if (inspection.state === "missing") {
     ui.info(cliText(
       `${inspection.name}: not installed`,
@@ -710,6 +719,10 @@ function printAgentInspection(
   inspection: SupportedAgentInspection,
   output: NodeJS.WriteStream,
 ): void {
+  if (inspection.compatibilityIssue) {
+    output.write(`  ${inspection.compatibilityIssue}\n`);
+    return;
+  }
   if (inspection.state === "missing") {
     output.write(cliText(
       `  ${inspection.name}: not installed\n`,

package/src/codex/CodexLocalActivityDetector.ts

@@ -9,6 +9,16 @@ const TASK_COMPLETE = Buffer.from('"type":"task_complete"');
 const TURN_ABORTED = Buffer.from('"type":"turn_aborted"');
 const PATTERN_OVERLAP = Math.max(TASK_STARTED.length, TASK_COMPLETE.length, TURN_ABORTED.length) - 1;
 
+interface RolloutState {
+  size: number;
+  mtimeMs: number;
+  ctimeMs: number;
+  ino: number;
+  dev: number;
+  tail: Buffer;
+  task: { active: boolean; turnId?: string };
+}
+
 interface ThreadPathRow {
   id: string;
   rollout_path: string;
@@ -35,6 +45,7 @@ export interface CodexLocalThreadSettings {
  * even while Codex Desktop is actively appending events to its rollout.
  */
 export class CodexLocalActivityDetector {
+  private readonly rollouts = new Map<string, RolloutState>();
   constructor(private readonly codexHome: string) {}
 
   async activeThreadIds(threadIds: string[]): Promise<Set<string>> {
@@ -64,7 +75,7 @@ export class CodexLocalActivityDetector {
 
     const active = new Map<string, string | undefined>();
     for (const row of rows) {
-      const task = await latestTask(row.rollout_path);
+      const task = await latestTask(row.rollout_path, this.rollouts);
       if (task.active) active.set(row.id, task.turnId);
     }
     return active;
@@ -104,16 +115,31 @@ export class CodexLocalActivityDetector {
   }
 }
 
-async function latestTask(rolloutPath: string): Promise<{ active: boolean; turnId?: string }> {
+async function latestTask(rolloutPath: string, cache: Map<string, RolloutState>): Promise<{ active: boolean; turnId?: string }> {
   let file;
   try {
     file = await open(rolloutPath, "r");
-    const size = (await file.stat()).size;
+    const { size, mtimeMs, ctimeMs, ino, dev } = await file.stat();
+    const previous = cache.get(rolloutPath);
+    const sameFile = previous?.ino === ino && previous.dev === dev;
+    if (sameFile && previous.size === size && previous.mtimeMs === mtimeMs && previous.ctimeMs === ctimeMs) {
+      return previous.task;
+    }
+    let stopAt = 0;
+    let task: RolloutState["task"] = { active: false };
+    if (sameFile && size > previous.size) {
+      const boundary = Buffer.alloc(previous.tail.length);
+      await file.read(boundary, 0, boundary.length, previous.size - boundary.length);
+      if (boundary.equals(previous.tail)) {
+        stopAt = Math.max(0, previous.size - PATTERN_OVERLAP);
+        task = previous.task;
+      }
+    }
     let position = size;
     let laterPrefix = Buffer.alloc(0);
 
-    while (position > 0) {
-      const length = Math.min(READ_CHUNK_SIZE, position);
+    while (position > stopAt) {
+      const length = Math.min(READ_CHUNK_SIZE, position - stopAt);
       position -= length;
       const chunk = Buffer.allocUnsafe(length);
       await file.read(chunk, 0, length, position);
@@ -123,14 +149,20 @@ async function latestTask(rolloutPath: string): Promise<{ active: boolean; turnI
       const abortedAt = searchable.lastIndexOf(TURN_ABORTED);
       const terminalAt = Math.max(completedAt, abortedAt);
       if (startedAt >= 0 || terminalAt >= 0) {
-        if (startedAt <= terminalAt) return { active: false };
-        const absoluteOffset = position + startedAt;
-        return { active: true, turnId: await readTurnId(file, absoluteOffset, size) };
+        task = startedAt <= terminalAt ? { active: false }
+          : { active: true, turnId: await readTurnId(file, position + startedAt, size) };
+        break;
       }
       laterPrefix = chunk.subarray(0, Math.min(PATTERN_OVERLAP, chunk.length));
     }
-    return { active: false };
+    const tail = Buffer.alloc(Math.min(1_024, size));
+    await file.read(tail, 0, tail.length, size - tail.length);
+    cache.delete(rolloutPath);
+    cache.set(rolloutPath, { size, mtimeMs, ctimeMs, ino, dev, tail, task });
+    if (cache.size > 512) cache.delete(cache.keys().next().value!);
+    return task;
   } catch {
+    cache.delete(rolloutPath);
     return { active: false };
   } finally {
     await file?.close();

package/src/codex/CodexProcessManager.ts

@@ -11,12 +11,15 @@ import {
 } from "../runtime/agentEnvironment.js";
 import type { AgentProcessInfo } from "../runtime/types.js";
 import { spawnStdioCommand } from "../utils/spawnCommand.js";
+import { assertSupportedCodexVersion } from "./CodexVersion.js";
 
 export class CodexProcessManager implements AppServerClientProvider {
   private static readonly RELEASE_TIMEOUT_MS = 5_000;
   private client?: AppServerConnection;
   private child?: ChildProcessWithoutNullStreams;
   private version?: string;
+  private agentFamily?: "codex" | "traex";
+  private initializing?: Promise<AppServerClient>;
   private readonly disconnectListeners = new Set<(error: Error) => void>();
 
   constructor(
@@ -28,7 +31,18 @@ export class CodexProcessManager implements AppServerClientProvider {
   ) {}
 
   async getClient(): Promise<AppServerClient> {
+    if (this.initializing) return this.initializing;
     if (this.client) return this.client;
+    const initialization = this.startClient();
+    this.initializing = initialization;
+    try {
+      return await initialization;
+    } finally {
+      if (this.initializing === initialization) this.initializing = undefined;
+    }
+  }
+
+  private async startClient(): Promise<AppServerClient> {
     this.version = undefined;
     const environmentContext = this.environmentContext();
     const child = spawnStdioCommand(
@@ -52,13 +66,25 @@ export class CodexProcessManager implements AppServerClientProvider {
       const error = new Error(`App Server exited (code=${code ?? "null"}, signal=${signal ?? "null"}).`);
       for (const listener of this.disconnectListeners) listener(error);
     });
-    const initializeResult = await client.request("initialize", {
-      clientInfo: { name: "agent-bot", title: "Agent Bot", version: "0.1.0" },
-      capabilities: { experimentalApi: true },
-    });
-    this.version = initializedAgentVersion(initializeResult);
-    client.notify("initialized", {});
-    return client;
+    try {
+      const initializeResult = await client.request("initialize", {
+        clientInfo: { name: "agent-bot", title: "Agent Bot", version: "0.1.0" },
+        capabilities: { experimentalApi: true },
+      });
+      this.version = initializedAgentVersion(initializeResult);
+      const userAgent = initializeResult && typeof initializeResult === "object"
+        ? (initializeResult as Record<string, unknown>).userAgent : undefined;
+      if (!this.getAgentFamily() && typeof userAgent === "string") {
+        if (/^codex(?:-cli)?[ /]/iu.test(userAgent)) this.agentFamily = "codex";
+        else if (/^trae(?:cli|x)?[ /]/iu.test(userAgent)) this.agentFamily = "traex";
+      }
+      if (this.getAgentFamily() === "codex") assertSupportedCodexVersion(this.version);
+      client.notify("initialized", {});
+      return client;
+    } catch (error) {
+      if (this.client === client) this.close();
+      throw error;
+    }
   }
 
   getProcessInfo(): AgentProcessInfo {
@@ -70,6 +96,17 @@ export class CodexProcessManager implements AppServerClientProvider {
     };
   }
 
+  getAgentFamily(): "codex" | "traex" | undefined {
+    if (this.agentFamily) return this.agentFamily;
+    const candidates = [this.command, this.args[0], this.environmentContext().agentName];
+    for (const value of candidates) {
+      const executable = value?.replaceAll("\\", "/").split("/").at(-1) ?? "";
+      if (/^codex(?:\.(?:exe|cmd|bat|m?js))?$/iu.test(executable)) return "codex";
+      if (/^(?:traex|traecli)(?:\.(?:exe|cmd|bat|m?js))?$/iu.test(executable)) return "traex";
+    }
+    return undefined;
+  }
+
   getCodexHome(): string {
     return this.env.CODEX_HOME ?? process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
   }