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

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.20-alpha.1",
+  "version": "0.1.21",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@keyou007/agent-bot",
-      "version": "0.1.20-alpha.1",
+      "version": "0.1.21",
       "license": "GPL-3.0-only",
       "dependencies": {
         "@agentclientprotocol/sdk": "1.2.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.20-alpha.1",
+  "version": "0.1.21",
   "type": "module",
   "description": "Use Codex, TraeX, and compatible coding agents from Lark/Feishu.",
   "license": "GPL-3.0-only",

package/skills/agent-bot/SKILL.md

@@ -96,6 +96,10 @@ agentbot task forkgroup [title]
 
 Choose `new` or `newgroup` for fresh context. Choose `fork` or `forkgroup` when the new task must retain conversation history through the latest completed Turn. Forking must not interrupt an active source turn.
 
+Feishu `/sessions [keyword]` lists and searches tasks across projects and all Providers, not just the App Server's current Provider. Switching Provider does not hide existing tasks; listing still uses paged metadata and the latest Turn summary only.
+
+Fork creation stores source-task and branch-Turn references without synchronizing the full local Turn list. The Feishu Turn card reuses local records and loads only the summary pages needed for the requested page, not the entire history. `task turns` loads the first page if necessary and returns available local records. This does not change the Agent's inherited context. Retry listing Turns after a temporary history-read failure; unsupported summary pagination never falls back to downloading full history.
+
 ## Change Settings
 
 ```powershell
@@ -108,6 +112,8 @@ agentbot task permissions [auto|confirm]
 
 Omit the value to inspect the current setting and available choices. `agent` changes the default Agent for future tasks in that conversation. The other settings affect the specified task from its next request and become the saved defaults for that Agent.
 
+Provider changes require an idle task and verify the actual Provider and model before saving. Custom Providers discover models through their OpenAI-compatible `/models` endpoint when available. Switching keeps the previous model when supported, otherwise uses the Provider default or its first model. A missing model-list endpoint falls back to the current or configured model and does not by itself block switching. Wait for active work to finish; do not stop it without the user's request. Switching unloads only the selected thread, not the shared App Server. On failure, previous settings are retained and recovery is attempted. If recovery fails, resolve the reported configuration or ownership issue and retry the Provider switch before sending another prompt. Never replace a forked task with an empty task to work around a switch failure.
+
 ## Goals And Turns
 
 ```powershell
@@ -119,7 +125,9 @@ agentbot task turns
 agentbot task reset <turn-id>
 ```
 
-Use `turns` to obtain a real Turn ID before `reset`. Reset changes conversation context only; it does not revert local files.
+In Feishu, `/turn` (also `/turns`) opens history. `/turn <Turn ID>` or `/turn <index>` shows saved runtime details for the current task without resetting, resuming, or interrupting it. Indices match the history card: one-based, newest first, including a running Turn at the top. Missing records use only necessary summary pages; Fork queries stay within the branch anchor. Summary-only external Turns do not contain unrecorded tool output. This does not change the CLI's `task turns [task]` task-reference argument.
+
+Use `turns` to obtain a real Turn ID before `reset`. Reset changes conversation context only; it does not revert local files. Agent Bot announces an interactive Reset when it starts and queues every new message after its Reaction until the replacement thread is ready.
 
 ## Files And Local Commands
 
@@ -168,6 +176,8 @@ agentbot --profile ~/.agent-bot-rescue server status
 
 Initialization prepares configuration, checks supported Agents, configures Feishu, and starts the server. On first initialization and `init --reset`, let the user choose whether all group messages are accepted or an explicit @ mention is required; only the first choice requests the additional all-group-message permission. Relay authorization links and wait for the user; never choose a response mode, skip authorization, or choose maintenance actions without permission.
 
+Codex requires version 0.153.4 or later. Init checks this locally, and runtime startup validates the actual App Server version. For an unsupported version, show the upgrade instruction (`codex update` or `npm install -g @openai/codex@latest`); do not work around it by reading full history through legacy APIs. Safely restart Agent Bot after an authorized upgrade. This version requirement does not apply to TraeX or ACP Agents.
+
 Use `init --reset` only for an explicitly requested full reset. Without `--profile` it resets the default Profile; pass `--profile <directory>` to reset another Profile. It preserves backups under `.reset-backups`.
 
 ## After Code Changes

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/CodexEventMapper.ts

@@ -8,6 +8,15 @@ export type MappedCodexNotification =
       turnId: string;
       lastTokens: number;
       cumulativeTokens: number;
+      contextTokens?: number;
+    }
+  | {
+      kind: "context_compaction";
+      threadId: string;
+      turnId: string;
+      phase: "started" | "completed";
+      compactionId?: string;
+      timestampMs?: number;
     }
   | { kind: "agent_delta"; threadId: string; turnId: string; itemId: string; text: string }
   | {
@@ -61,7 +70,18 @@ export function mapCodexNotification(method: string, params: unknown): MappedCod
     const lastTokens = effectiveTokenCount(params.tokenUsage.last);
     const cumulativeTokens = effectiveTokenCount(params.tokenUsage.total);
     if (lastTokens === undefined || cumulativeTokens === undefined) return undefined;
-    return { kind: "token_usage", threadId, turnId, lastTokens, cumulativeTokens };
+    return {
+      kind: "token_usage",
+      threadId,
+      turnId,
+      lastTokens,
+      cumulativeTokens,
+      contextTokens: numberValue(params.tokenUsage.last.totalTokens),
+    };
+  }
+
+  if (method === "thread/compacted") {
+    return { kind: "context_compaction", threadId, turnId, phase: "completed" };
   }
 
   if (method === "item/agentMessage/delta") {
@@ -98,6 +118,16 @@ export function mapCodexNotification(method: string, params: unknown): MappedCod
     return { kind: "plan", threadId, turnId, steps };
   }
   if ((method === "item/started" || method === "item/completed") && isRecord(params.item)) {
+    if (params.item.type === "contextCompaction") {
+      return {
+        kind: "context_compaction",
+        threadId,
+        turnId,
+        phase: method === "item/started" ? "started" : "completed",
+        compactionId: stringValue(params.item.id),
+        timestampMs: numberValue(method === "item/started" ? params.startedAtMs : params.completedAtMs),
+      };
+    }
     if (params.item.type === "agentMessage") {
       const itemId = stringValue(params.item.id);
       const phase = messagePhase(params.item.phase);

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,10 +96,25 @@ 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");
   }
 
+  getEnvironmentVariable(name: string): string | undefined {
+    return this.env[name] ?? process.env[name];
+  }
+
   close(): void {
     this.client?.close();
     if (this.child && !this.child.killed) this.child.kill();