@keyou007/agent-bot 0.1.19-alpha.0 → 0.1.19

package/src/codex/CodexRuntime.ts

@@ -17,6 +17,7 @@ import type {
   RuntimeEvent,
   RuntimeExecutionSettings,
   RuntimePrompt,
+  RuntimeReleaseResult,
   RuntimeSession,
   RuntimeSessionMetadata,
 } from "../runtime/types.js";
@@ -41,6 +42,9 @@ const SESSION_REQUEST_TIMEOUT_MS = 60_000;
 const CONTROL_REQUEST_TIMEOUT_MS = 10_000;
 const SYNC_REQUEST_TIMEOUT_MS = 5_000;
 const THREAD_TURN_PAGE_SIZE = 100;
+const FORK_SOURCE_TURN_PAGE_SIZE = 20;
+const FORK_SOURCE_REQUEST_TIMEOUT_MS = 15_000;
+const USER_RESUMABLE_THREAD_SOURCE_KINDS = ["cli", "vscode", "exec", "appServer"] as const;
 // A timed-out fork keeps running in App Server and can create an orphan thread.
 // Wait for its response; connection closure still rejects the request.
 const FORK_REQUEST_TIMEOUT_MS = 0;
@@ -61,6 +65,7 @@ export interface AppServerClientProvider {
   getProcessInfo?(): AgentProcessInfo;
   getCodexHome?(): string;
   onDisconnect?(listener: (error: Error) => void): () => void;
+  release?(): Promise<void>;
   close(): void;
 }
 
@@ -91,6 +96,7 @@ export class CodexRuntime implements AgentRuntime {
   private readonly localActivityDetector?: CodexLocalActivityDetector;
   private readonly codexHome?: string;
   private threadListSortKey: ThreadListSortKey = "recency_at";
+  private releaseInFlight?: Promise<RuntimeReleaseResult>;
 
   constructor(
     private readonly provider: AppServerClientProvider,
@@ -290,6 +296,7 @@ export class CodexRuntime implements AgentRuntime {
         limit: input.limit ?? 20,
         sortKey,
         sortDirection: "desc",
+        sourceKinds: USER_RESUMABLE_THREAD_SOURCE_KINDS,
         archived: false,
         searchTerm: input.searchTerm,
       },
@@ -300,7 +307,37 @@ export class CodexRuntime implements AgentRuntime {
   async readRemoteSession(remoteSessionId: string): Promise<RemoteSessionSummary> {
     const client = await this.client();
     const response = await this.readThreadWithTurns(client, remoteSessionId);
-    const summary = remoteSessionSummary(response.thread);
+    return this.decorateRemoteSession(remoteSessionId, remoteSessionSummary(response.thread));
+  }
+
+  async readRemoteForkSource(remoteSessionId: string): Promise<RemoteSessionSummary> {
+    const client = await this.client();
+    const metadata = await client.request<ThreadReadResponse>(
+      "thread/read",
+      { threadId: remoteSessionId, includeTurns: false },
+      FORK_SOURCE_REQUEST_TIMEOUT_MS,
+    );
+    let turns: CodexTurnSnapshot[];
+    try {
+      turns = await this.listRecentThreadTurnsThroughCompleted(client, remoteSessionId);
+    } catch (error) {
+      if (!isUnsupportedThreadTurnsListError(error)) throw error;
+      this.logger.warn(
+        { error, remoteSessionId },
+        "App Server does not support lightweight Fork source reads; falling back to complete thread history.",
+      );
+      return this.readRemoteSession(remoteSessionId);
+    }
+    return this.decorateRemoteSession(remoteSessionId, remoteSessionSummary({
+      ...metadata.thread,
+      turns,
+    }));
+  }
+
+  private async decorateRemoteSession(
+    remoteSessionId: string,
+    summary: RemoteSessionSummary,
+  ): Promise<RemoteSessionSummary> {
     const activeThreads = await this.localActivityDetector?.activeThreads([remoteSessionId]);
     const activeSummary = activeThreads ? markLocallyDetectedActive(summary, activeThreads) : summary;
     const settings = await this.localActivityDetector?.threadSettings([remoteSessionId]);
@@ -310,6 +347,46 @@ export class CodexRuntime implements AgentRuntime {
     };
   }
 
+  private async listRecentThreadTurnsThroughCompleted(
+    client: AppServerClient,
+    remoteSessionId: string,
+  ): Promise<CodexTurnSnapshot[]> {
+    const turns: CodexTurnSnapshot[] = [];
+    const seenCursors = new Set<string>();
+    let cursor: string | undefined;
+    do {
+      const response = await client.request<ThreadTurnsListResponse>(
+        "thread/turns/list",
+        {
+          threadId: remoteSessionId,
+          ...(cursor ? { cursor } : {}),
+          limit: FORK_SOURCE_TURN_PAGE_SIZE,
+          sortDirection: "desc",
+          itemsView: "summary",
+        },
+        FORK_SOURCE_REQUEST_TIMEOUT_MS,
+      );
+      turns.push(...response.data);
+      const completedIndex = turns.findIndex((turn) => turn.status === "completed");
+      if (completedIndex >= 0) {
+        turns.splice(completedIndex + 1);
+        break;
+      }
+      const nextCursor = response.nextCursor ?? undefined;
+      if (!nextCursor) break;
+      if (seenCursors.has(nextCursor)) {
+        this.logger.warn(
+          { remoteSessionId, cursor: nextCursor },
+          "App Server repeated a Fork source Turn cursor; stopping pagination.",
+        );
+        break;
+      }
+      seenCursors.add(nextCursor);
+      cursor = nextCursor;
+    } while (cursor);
+    return turns.reverse();
+  }
+
   private async readThreadWithTurns(
     client: AppServerClient,
     remoteSessionId: string,
@@ -602,6 +679,29 @@ export class CodexRuntime implements AgentRuntime {
     return () => this.listeners.delete(listener);
   }
 
+  async release(options: { force?: boolean } = {}): Promise<RuntimeReleaseResult> {
+    if (this.releaseInFlight) return this.releaseInFlight;
+    const activeSessionIds = [...this.sessions.values()]
+      .filter((session) => Boolean(session.activeTurnId))
+      .map((session) => session.localSessionId);
+    if (activeSessionIds.length > 0 && options.force !== true) {
+      return { status: "busy", activeSessionIds };
+    }
+
+    const operation = (async (): Promise<RuntimeReleaseResult> => {
+      this.handleDisconnect(new Error("App Server released by user."), true);
+      if (this.provider.release) await this.provider.release();
+      else this.provider.close();
+      return { status: "released" };
+    })();
+    this.releaseInFlight = operation;
+    try {
+      return await operation;
+    } finally {
+      if (this.releaseInFlight === operation) this.releaseInFlight = undefined;
+    }
+  }
+
   close(): void {
     this.unsubscribe?.();
     this.unsubscribeDisconnect?.();
@@ -613,6 +713,7 @@ export class CodexRuntime implements AgentRuntime {
   }
 
   private async client(): Promise<AppServerClient> {
+    if (this.releaseInFlight) await this.releaseInFlight;
     const client = await this.provider.getClient();
     if (client !== this.attachedClient) this.attachClient(client);
     return client;
@@ -1012,7 +1113,7 @@ export class CodexRuntime implements AgentRuntime {
     for (const listener of this.listeners) listener(event);
   }
 
-  private handleDisconnect(error: Error): void {
+  private handleDisconnect(error: Error, intentionalRelease = false): void {
     this.unsubscribe?.();
     this.unsubscribe = undefined;
     this.attachedClient = undefined;
@@ -1027,7 +1128,9 @@ export class CodexRuntime implements AgentRuntime {
         type: "turn_failed",
         sessionId: session.localSessionId,
         turnId,
-        message: `App Server disconnected: ${error.message}`,
+        message: intentionalRelease
+          ? "Task interrupted because Agent Bot released the App Server."
+          : `App Server disconnected: ${error.message}`,
       });
     }
     for (const [requestId, pending] of this.approvals) {
@@ -1198,6 +1301,12 @@ function isPaginatedThreadReadError(error: unknown): boolean {
   return /paginated threads?[^\n]*do(?:es)? not support[^\n]*thread\/read[^\n]*includeTurns\s*=\s*true/i.test(details);
 }
 
+function isUnsupportedThreadTurnsListError(error: unknown): boolean {
+  if (!(error instanceof AppServerRequestError) || error.method !== "thread/turns/list") return false;
+  return error.code === -32601
+    || /method not found|unknown method|unsupported|not supported/i.test(appServerErrorDetails(error));
+}
+
 function isUnmaterializedThreadReadError(error: unknown): boolean {
   const details = appServerErrorDetails(error);
   return /thread[^\n]*(?:not materialized|not loaded)[^\n]*includeTurns[^\n]*(?:unavailable|before first user message)/i

package/src/commands/CommandRouter.ts

@@ -18,6 +18,7 @@ export const COMMAND_NAMES = [
   "permissions",
   "provider",
   "queue",
+  "release",
   "restart",
   "sessions",
   "status",
@@ -114,6 +115,9 @@ export class CommandRouter {
         if (args.length === 0) return { type: "restart" };
         if (args.length === 1 && args[0] === "--force") return { type: "restart", force: true };
         throw new Error("/restart 只接受一个可选的 --force 参数。");
+      case "release":
+        if (args.length > 0) throw new Error("/release 不接受参数。");
+        return { type: "release" };
       case "mute": {
         if (args.length === 0 || (args.length === 1 && args[0]!.toLowerCase() === "on")) {
           return { type: "mute", enabled: true };

package/src/commands/commandTypes.ts

@@ -19,6 +19,7 @@ export type Command =
   | { type: "goal"; action: "set" | "edit"; objective: string }
   | { type: "goal"; action: "pause" | "resume" | "clear" }
   | { type: "restart"; force?: boolean }
+  | { type: "release" }
   | { type: "mute"; enabled: boolean }
   | { type: "turns" }
   | { type: "model" }

package/src/feishu/CardRenderer.ts

@@ -275,6 +275,17 @@ export interface ThreadWriterConflictCardView {
   };
 }
 
+export interface AppServerReleaseCardView {
+  status: "waiting" | "releasing" | "released" | "cancelled" | "failed";
+  contextKey: string;
+  scheduleId: number;
+  agentName: string;
+  blockingTaskCount?: number;
+  releaseInSeconds?: number;
+  forced?: boolean;
+  error?: string;
+}
+
 export class CardRenderer {
   private readonly thinkingCardLayout: ThinkingCardLayout;
 
@@ -371,6 +382,91 @@ export class CardRenderer {
     );
   }
 
+  renderAppServerRelease(view: AppServerReleaseCardView): Record<string, unknown> {
+    const agent = inlineCode(view.agentName);
+    if (view.status === "released") {
+      return sectionCard("任务已释放", [markdown([
+        `**Agent**：${agent}`,
+        view.forced ? "执行中的任务已中断。" : undefined,
+        "> 请在 Codex Desktop 点击 **Retry**。",
+      ].filter((line): line is string => Boolean(line)).join("\n"))], "green");
+    }
+    if (view.status === "cancelled") {
+      return sectionCard("已取消释放", [markdown(`**Agent**：${agent}\n> Agent Bot 将继续保持当前任务连接。`)], "grey");
+    }
+    if (view.status === "failed") {
+      return sectionCard("释放失败", [markdown([
+        `**Agent**：${agent}`,
+        view.error ? truncateText(view.error, 500) : "无法释放 App Server。",
+      ].join("\n"))], "red");
+    }
+    if (view.status === "releasing") {
+      return sectionCard("正在释放", [markdown(`**Agent**：${agent}\n正在停止 Agent Bot 的 App Server。`)], "blue");
+    }
+
+    const blockingTaskCount = Math.max(0, view.blockingTaskCount ?? 0);
+    const releaseInSeconds = Math.max(1, view.releaseInSeconds ?? 1);
+    return sectionCard("等待释放", [
+      markdown([
+        `**Agent**：${agent}`,
+        blockingTaskCount > 0
+          ? `**等待任务**：${blockingTaskCount}`
+          : `**自动释放**：${releaseInSeconds} 秒后`,
+        blockingTaskCount > 0
+          ? "> 任务结束后自动释放；立即释放会中断执行。"
+          : "> 可立即释放或取消。",
+      ].join("\n")),
+      {
+        tag: "column_set",
+        flex_mode: "none",
+        horizontal_spacing: "8px",
+        vertical_align: "center",
+        columns: [
+          {
+            tag: "column",
+            width: "auto",
+            vertical_align: "center",
+            elements: [{
+              tag: "button",
+              text: { tag: "plain_text", content: "Release Now" },
+              type: "danger",
+              size: "small",
+              behaviors: [{
+                type: "callback",
+                value: {
+                  action: "app_server_release_now",
+                  contextKey: view.contextKey,
+                  scheduleId: view.scheduleId,
+                  agentName: view.agentName,
+                },
+              }],
+            }],
+          },
+          {
+            tag: "column",
+            width: "auto",
+            vertical_align: "center",
+            elements: [{
+              tag: "button",
+              text: { tag: "plain_text", content: "Cancel" },
+              type: "default",
+              size: "small",
+              behaviors: [{
+                type: "callback",
+                value: {
+                  action: "app_server_release_cancel",
+                  contextKey: view.contextKey,
+                  scheduleId: view.scheduleId,
+                  agentName: view.agentName,
+                },
+              }],
+            }],
+          },
+        ],
+      },
+    ], "orange");
+  }
+
   renderShellCommandCard(view: ShellCommandCardView): Record<string, unknown> {
     const rawOutput = normalizeTerminalOutput(view.output).trimEnd();
     const displayOutput = truncateMiddle(

package/src/feishu/MergedForwardMessage.ts

@@ -273,8 +273,12 @@ function renderPost(
     for (const rawElement of row) {
       if (!isRecord(rawElement)) continue;
       const tag = textValue(rawElement.tag);
-      if (tag === "text" || tag === "a") {
+      if (tag === "text") {
         rowText += textValue(rawElement.text);
+      } else if (tag === "a") {
+        const text = textValue(rawElement.text);
+        const href = textValue(rawElement.href);
+        rowText += href && href !== text ? `${text || href} (${href})` : text || href;
       } else if (tag === "at") {
         rowText += renderMention(rawElement, mentions);
       } else if (tag === "img") {

package/src/index.ts

@@ -432,6 +432,8 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
       return { ok: true, data: await controller.controlGetTaskStatus(request.localSessionId) };
     case "task_stop":
       return { ok: true, message: await controller.controlStopTask(request.localSessionId) };
+    case "task_release":
+      return { ok: true, data: await controller.controlReleaseTask(request.localSessionId) };
     case "task_archive":
       return { ok: true, data: await controller.controlArchiveTask(request.localSessionId) };
     case "task_dismiss":