@keyou007/agent-bot 0.1.22 → 0.1.24-alpha.0

package/src/codex/CodexRuntime.ts

@@ -5,6 +5,7 @@ import type {
   AgentProcessInfo,
   ApprovalDecision,
   CreateRuntimeSessionInput,
+  ConversationTurn,
   ForkRuntimeSessionInput,
   ModelOption,
   ModelProviderOption,
@@ -383,6 +384,46 @@ export class CodexRuntime implements AgentRuntime {
     };
   }
 
+  async *readConversation(remoteSessionId: string, throughTurnId?: string): AsyncIterable<ConversationTurn> {
+    const client = await this.client();
+    const seenCursors = new Set<string>();
+    let cursor: string | undefined;
+    const boundary = throughTurnId
+      ?? (await this.listRecentThreadTurnsThroughCompleted(client, remoteSessionId))
+        .find((turn) => turn.status === "completed")?.id;
+    if (!boundary) return;
+    do {
+      const page = await this.readTurnPage(client, remoteSessionId, {
+        cursor, limit: 50, itemsView: "summary", sortDirection: "asc",
+      }, CONTROL_REQUEST_TIMEOUT_MS);
+      for (const turn of page.data) {
+        if (turn.status === "inProgress" || (turn.id === boundary && turn.status !== "completed")) {
+          throw new Error("上下文历史发生变化，请重试。");
+        }
+        if (turn.status !== "completed") continue;
+        const messages: ConversationTurn["messages"] = [];
+        for (const item of turn.items ?? []) {
+          if (item.type === "userMessage") {
+            const text = (item.content ?? []).filter((block) => block.type === "text")
+              .map((block) => block.text ?? "").join("\n");
+            if (text.trim()) messages.push({ role: "user", text });
+          } else if (item.type === "agentMessage" && item.phase !== "commentary" && item.text?.trim()) {
+            messages.push({ role: "assistant", text: item.text });
+          }
+        }
+        yield { turnId: turn.id, messages };
+        if (turn.id === boundary) return;
+      }
+      const nextCursor = page.nextCursor ?? undefined;
+      if (nextCursor && (nextCursor === cursor || seenCursors.has(nextCursor))) {
+        throw new Error("App Server repeated a conversation history cursor.");
+      }
+      if (nextCursor) seenCursors.add(nextCursor);
+      cursor = nextCursor;
+    } while (cursor);
+    throw new Error("找不到上下文截止轮次，未创建克隆任务。");
+  }
+
   async readRemoteForkSource(remoteSessionId: string): Promise<RemoteSessionSummary> {
     const client = await this.client();
     const metadata = await client.request<ThreadReadResponse>(
@@ -454,14 +495,14 @@ export class CodexRuntime implements AgentRuntime {
   private async readTurnPage(
     client: AppServerClient,
     remoteSessionId: string,
-    input: { cursor?: string; limit: number; itemsView: "summary" | "full" },
+    input: { cursor?: string; limit: number; itemsView: "summary" | "full"; sortDirection?: "asc" | "desc" },
     timeoutMs = SYNC_REQUEST_TIMEOUT_MS,
   ): Promise<ThreadTurnsListResponse> {
     try {
       return await client.request<ThreadTurnsListResponse>("thread/turns/list", {
         threadId: remoteSessionId,
         ...(input.cursor ? { cursor: input.cursor } : {}),
-        limit: input.limit, sortDirection: "desc", itemsView: input.itemsView,
+        limit: input.limit, sortDirection: input.sortDirection ?? "desc", itemsView: input.itemsView,
       }, timeoutMs);
     } catch (error) {
       if (error instanceof AppServerRequestError && error.method === "thread/turns/list"
@@ -674,17 +715,38 @@ export class CodexRuntime implements AgentRuntime {
         await this.detachThreadForSettings(client, session);
         detached = true;
       }
-      const response = empty
-        ? await client.request<ThreadResponse>("thread/start", {
-            ...params, threadSource: "user", allowProviderModelFallback: false,
-          }, SESSION_REQUEST_TIMEOUT_MS)
-        : await client.request<ThreadResponse>("thread/resume", {
-            ...params, threadId: session.remoteSessionId, excludeTurns: true,
-          }, SESSION_REQUEST_TIMEOUT_MS);
-      if (empty) replacementId = response.thread.id;
+      let response: ThreadResponse;
+      if (empty) {
+        response = await client.request<ThreadResponse>("thread/start", {
+          ...params, threadSource: "user", allowProviderModelFallback: false,
+        }, SESSION_REQUEST_TIMEOUT_MS);
+        replacementId = response.thread.id;
+      } else {
+        response = await client.request<ThreadResponse>("thread/resume", {
+          ...params, threadId: session.remoteSessionId, excludeTurns: true,
+        }, SESSION_REQUEST_TIMEOUT_MS);
+        if (!providerSettingsMatch(response, settings)) {
+          this.logger.warn(
+            {
+              sessionId,
+              threadId: session.remoteSessionId,
+              requestedProvider: settings.modelProvider,
+              actualProvider: response.modelProvider,
+              requestedModel: settings.model,
+              actualModel: response.model,
+            },
+            "App Server did not apply Provider settings while resuming; forking the latest completed Turn.",
+          );
+          await this.detachThreadForSettings(client, session);
+          response = await this.forkThreadForSettings(client, session, settings);
+          replacementId = response.thread.id;
+        }
+      }
       assertProviderSettingsApplied(response, settings);
-      if (!empty && response.thread.id !== session.remoteSessionId) throw new Error("App Server 返回了不同的任务 ID，未保存设置。");
-      if (empty && session.title) await client.request("thread/name/set", {
+      if (!empty && !replacementId && response.thread.id !== session.remoteSessionId) {
+        throw new Error("App Server 返回了不同的任务 ID，未保存设置。");
+      }
+      if (session.title && (empty || replacementId)) await client.request("thread/name/set", {
         threadId: response.thread.id, name: session.title,
       }, SESSION_REQUEST_TIMEOUT_MS);
       const candidate = { ...session, ...settings, remoteSessionId: response.thread.id,
@@ -734,6 +796,29 @@ export class CodexRuntime implements AgentRuntime {
     }
   }
 
+  private async forkThreadForSettings(
+    client: AppServerClient,
+    session: CodexSession,
+    settings: RuntimeExecutionSettings,
+  ): Promise<ThreadResponse> {
+    const turns = await this.listRecentThreadTurnsThroughCompleted(client, session.remoteSessionId);
+    const lastTurnId = turns.find((turn) => turn.status === "completed")?.id;
+    if (!lastTurnId) {
+      throw new Error("无法为 Provider 切换找到已完成的 Turn。请先完成一轮任务后重试。");
+    }
+    return client.request<ThreadResponse>("thread/fork", {
+      threadId: session.remoteSessionId,
+      lastTurnId,
+      cwd: session.cwd,
+      model: settings.model,
+      modelProvider: settings.modelProvider,
+      threadSource: "user",
+      excludeTurns: true,
+      ...threadLifecycleParams(session.cwd),
+      ...permissionParams(settings.permissionMode),
+    }, FORK_REQUEST_TIMEOUT_MS);
+  }
+
   private async discardUnusedThread(client: AppServerClient, threadId: string): Promise<void> {
     try {
       await client.request("thread/unsubscribe", { threadId }, CONTROL_REQUEST_TIMEOUT_MS);
@@ -1688,6 +1773,13 @@ function remoteThreadStatus(value: string | undefined): RemoteSessionSummary["st
   return "not_loaded";
 }
 
+function providerSettingsMatch(
+  response: Pick<ThreadResponse, "modelProvider" | "model">,
+  settings: RuntimeExecutionSettings,
+): boolean {
+  return response.modelProvider === settings.modelProvider && response.model === settings.model;
+}
+
 function codexSourceLabel(source: unknown): string {
   if (typeof source === "string") return source;
   if (isRecord(source)) {

package/src/commands/CommandRouter.ts

@@ -3,6 +3,8 @@ import type { Command } from "./commandTypes.js";
 export const COMMAND_NAMES = [
   "agent",
   "archive",
+  "clone",
+  "clonegroup",
   "dir",
   "dismiss",
   "file",
@@ -34,6 +36,7 @@ type CommandName = (typeof COMMAND_NAMES)[number];
 const COMMAND_INITIALISMS: Partial<Record<CommandName, string>> = {
   dir: "di",
   forkgroup: "fg",
+  clonegroup: "cg",
   newgroup: "ng",
   nosteer: "ns",
 };
@@ -67,6 +70,9 @@ export class CommandRouter {
         return parseNewCommand(args);
       case "newgroup":
         return parseNewGroupCommand(args);
+      case "clone":
+      case "clonegroup":
+        return parseCloneCommand(command, args);
       case "forkgroup":
         return parseForkGroupCommand(args);
       case "fork":
@@ -242,6 +248,24 @@ function parseNewTaskOptions(
   };
 }
 
+function parseCloneCommand(type: "clone" | "clonegroup", args: string[]): Command {
+  const title: string[] = [];
+  let agentName: string | undefined;
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index]!;
+    if (argument === "--agent") {
+      if (agentName !== undefined) throw new Error(`/${type} 只能指定一次 --agent。`);
+      const name = args[++index];
+      if (!name?.trim() || name.startsWith("--")) throw new Error("请在 --agent 后指定 Agent 名称。");
+      agentName = name.trim();
+    } else {
+      if (argument.startsWith("--")) throw new Error(`/${type} 不支持参数：${argument}。`);
+      title.push(argument);
+    }
+  }
+  return { type, title: title.join(" ").trim() || undefined, agentName };
+}
+
 function parseForkCommand(args: string[]): Extract<Command, { type: "fork" }> {
   rejectOptions("/fork", args);
   if (args.length > 1) throw new Error("/fork 只接受一个可选的任务序号或任务 ID。");

package/src/commands/commandTypes.ts

@@ -4,6 +4,7 @@ export type Command =
   | { type: "newgroup"; title?: string; cwd?: string; projectless?: boolean }
   | { type: "dir"; directory?: string }
   | { type: "file"; filePath: string }
+  | { type: "clone" | "clonegroup"; title?: string; agentName?: string }
   | { type: "forkgroup"; title?: string }
   | { type: "fork"; sessionId?: string }
   | { type: "title"; title: string }

package/src/config/loadConfig.ts

@@ -26,6 +26,10 @@ const DEFAULT_CONFIG = `feishu:
 console:
   enabled: true
 
+updates:
+  # Daily stable update check, private 60-second cancellation window, then safe update.
+  enabled: true
+
 fileViewer:
   enabled: true
   # Use 0.0.0.0 to accept LAN connections and automatically prefer

package/src/config/schema.ts

@@ -57,6 +57,7 @@ export const agentConfigSchema = z.object({
 });
 
 export const appConfigSchema = z.object({
+  updates: z.object({ enabled: z.boolean().default(true) }).default({ enabled: true }),
   console: z
     .object({
       enabled: z.boolean().default(true),
@@ -107,4 +108,6 @@ export type AgentConfig = Omit<ParsedAgentConfig, "defaults"> & {
   defaults?: AgentExecutionDefaults;
 };
 export type GroupNameFormatConfig = z.infer<typeof groupNameFormatSchema>;
-export type AppConfig = z.infer<typeof appConfigSchema>;
+export type AppConfig = Omit<z.infer<typeof appConfigSchema>, "updates"> & {
+  updates?: { enabled: boolean };
+};

package/src/feishu/CardRenderer.ts

@@ -12,6 +12,7 @@ import type {
 } from "../runtime/types.js";
 import type { TurnActivity, TurnViewState, TurnViewStatus } from "../presentation/turnViewTypes.js";
 import { truncateMiddle, truncateText } from "../utils/markdown.js";
+import type { UpdateNotice } from "../updates/types.js";
 import { localCardImage } from "./LocalCardImage.js";
 
 export interface StartupStatusView {
@@ -953,6 +954,33 @@ export class CardRenderer {
     };
   }
 
+  renderUpdateNotice(view: UpdateNotice, now = Date.now()): Record<string, unknown> {
+    const cancellable = view.status === "announcing" || view.status === "countdown";
+    const status = cancellable
+      ? `**自动更新倒计时：${Math.max(0, Math.ceil(((view.deadline ?? now + 60_000) - now) / 1_000))} 秒**`
+      : view.status === "cancelled" ? "已取消本版本自动更新，不再提醒。"
+        : view.status === "preparing" ? "正在下载并校验更新；任务结束后自动安装并重启。"
+          : view.status === "scheduled" ? "更新已就绪，等待任务和结果投递完成后自动重启。"
+            : view.status === "completed" ? "更新已完成。"
+              : "自动更新未完成，当前版本继续运行。";
+    const elements = [
+      markdown(`**Agent Bot** ${inlineCode(view.currentVersion)} → ${inlineCode(view.version)}`),
+      markdown(`**本版更新**\n${truncateText(view.notes, 4_000)}`),
+      { tag: "hr" },
+      markdown(status),
+    ];
+    if (view.error) elements.push(markdown(inlineCode(truncateText(view.error, 600))));
+    if (cancellable) {
+      elements.push(markdown("> 1 分钟内未取消将自动更新；不会中断正在执行的任务。"));
+      elements.push(taskActionRow([{
+        text: "取消本次更新",
+        value: { action: "agentbot_update_cancel", version: view.version, token: view.token },
+      }]));
+    }
+    return sectionCard("Agent Bot 更新提醒", elements,
+      view.status === "completed" ? "green" : view.status === "cancelled" ? "grey" : "blue");
+  }
+
   renderSafeRestartStatus(view: SafeRestartStatusView): Record<string, unknown> {
     const countdown = view.phase === "countdown"
       ? `${Math.max(0, Math.ceil((view.remainingMs ?? 0) / 1_000))}s`
@@ -2370,7 +2398,7 @@ function truncateToolResult(result: string): string {
   return `${result.slice(0, headLength)}${marker}${result.slice(-tailLength)}`;
 }
 
-function displayFilePath(filePath: string, projectCwd?: string): string {
+export function displayFilePath(filePath: string, projectCwd?: string): string {
   if (!projectCwd) return filePath;
   const pathApi = usesWindowsPaths(projectCwd, filePath) ? path.win32 : path;
   const normalizedCwd = pathApi.resolve(projectCwd);
@@ -2393,8 +2421,12 @@ function usesWindowsPaths(...values: string[]): boolean {
   return values.some((value) => /^[A-Za-z]:[\\/]/.test(value) || /^\\\\/.test(value));
 }
 
+export function toolStatusIcon(status: ToolState["status"]): string {
+  return status === "failed" ? "❌" : status === "running" ? "⏳" : "✅";
+}
+
 function toolPanelTitle(tool: ToolState): string {
-  const icon = tool.status === "failed" ? "❌" : tool.status === "running" ? "⏳" : "✅";
+  const icon = toolStatusIcon(tool.status);
   const command = stripAnsi(tool.command ?? tool.title).trim();
   const meaningfulCommand = tool.kind === "web_search"
     ? tool.title

package/src/feishu/FeishuMessageClient.ts

@@ -259,8 +259,11 @@ export class FeishuMessageClient implements FeishuOutbound {
   private async readMessageItems(messageId: string, operation: string): Promise<MergedForwardMessageItem[]> {
     try {
       const token = await this.getTenantAccessToken();
+      const url = new URL(`https://open.feishu.cn/open-apis/im/v1/messages/${encodeURIComponent(messageId)}`);
+      // The default compatibility format can replace Card 2.0 content with an upgrade notice.
+      url.searchParams.set("card_msg_content_type", "user_card_content");
       const response = await fetch(
-        `https://open.feishu.cn/open-apis/im/v1/messages/${encodeURIComponent(messageId)}`,
+        url,
         { headers: { Authorization: `Bearer ${token}` } },
       );
       const payload = (await response.json()) as GetMessageResponse;
@@ -303,8 +306,9 @@ export class FeishuMessageClient implements FeishuOutbound {
   async sendInteractiveCard(
     contextKey: string,
     card: Record<string, unknown>,
+    idempotencyKey?: string,
   ): Promise<string | undefined> {
-    return this.sendMessage(contextKey, "interactive", await this.prepareInteractiveCard(card));
+    return this.sendMessage(contextKey, "interactive", await this.prepareInteractiveCard(card), idempotencyKey);
   }
 
   async replyText(

package/src/feishu/MergedForwardMessage.ts

@@ -187,7 +187,7 @@ function renderMessageContent(
     case "sticker":
       return "[表情包]";
     case "interactive":
-      return renderInteractiveCard(content) || "[消息卡片]";
+      return renderInteractiveCard(content, imageLabel) || "[消息卡片]";
     case "share_chat":
       return "[群名片]";
     case "share_user":
@@ -235,27 +235,49 @@ function messageTypeLabel(messageType: string): string {
   }
 }
 
-function renderInteractiveCard(content: Record<string, unknown>): string {
+function renderInteractiveCard(
+  content: Record<string, unknown>,
+  imageLabel: (imageKey: string) => string,
+): string {
   const values: string[] = [];
-  collectCardText(content, undefined, values);
+  collectCardText(content, undefined, values, imageLabel);
   return [...new Set(values.map((value) => normalizeFeishuPostText(value)).filter(Boolean))].join("\n");
 }
 
-function collectCardText(value: unknown, key: string | undefined, output: string[]): void {
+function collectCardText(
+  value: unknown,
+  key: string | undefined,
+  output: string[],
+  imageLabel: (imageKey: string) => string,
+): void {
   if (typeof value === "string") {
-    if (key === "content" || key === "text" || key === "title" || key === "subtitle") output.push(value);
+    if (
+      (key === "content" || key === "text" || key === "title" || key === "subtitle")
+      && !isUnsupportedCardClientPlaceholder(value)
+    ) {
+      output.push(value);
+    }
     return;
   }
   if (Array.isArray(value)) {
-    for (const item of value) collectCardText(item, key, output);
+    for (const item of value) collectCardText(item, key, output, imageLabel);
     return;
   }
   if (!isRecord(value)) return;
+  const imageKey = textValue(value.image_key ?? value.img_key);
+  if (imageKey) {
+    output.push(imageLabel(imageKey));
+  }
   for (const [childKey, childValue] of Object.entries(value)) {
-    collectCardText(childValue, childKey, output);
+    collectCardText(childValue, childKey, output, imageLabel);
   }
 }
 
+function isUnsupportedCardClientPlaceholder(value: string): boolean {
+  return value.trim() === "请升级至最新版本客户端，以查看内容"
+    || /^please upgrade to the latest .*client.* view/iu.test(value.trim());
+}
+
 function renderPost(
   content: Record<string, unknown>,
   mentions: MergedForwardMessageItem["mentions"],

package/src/feishu/types.ts

@@ -72,7 +72,7 @@ export interface FeishuOutbound {
   sendText(contextKey: string, text: string): Promise<string | undefined>;
   sendFile?(contextKey: string, filePath: string): Promise<string | undefined>;
   sendMarkdown(contextKey: string, markdown: string, idempotencyKey?: string): Promise<string | undefined>;
-  sendInteractiveCard(contextKey: string, card: Record<string, unknown>): Promise<string | undefined>;
+  sendInteractiveCard(contextKey: string, card: Record<string, unknown>, idempotencyKey?: string): Promise<string | undefined>;
   replyText?(
     contextKey: string,
     target: MessageReplyTarget,

package/src/index.ts

@@ -29,6 +29,9 @@ import { ProxySessionController } from "./proxy/ProxySessionController.js";
 import type { AgentEnvironmentContext } from "./runtime/agentEnvironment.js";
 import { createAgentRuntimeRegistry } from "./runtime/createAgentRuntimeRegistry.js";
 import { StateStore } from "./state/StateStore.js";
+import { DailyUpdateMonitor } from "./updates/DailyUpdateMonitor.js";
+import { readLatestStableVersion, readReleaseNotes } from "./updates/PublishedRelease.js";
+import { checkAutomaticUpdateSupport, prepareAutomaticUpdate } from "./updates/AutomaticUpdatePreparer.js";
 import { StartupNotifier } from "./startup/StartupNotifier.js";
 import { SessionMetadataHydrator } from "./startup/SessionMetadataHydrator.js";
 import { startFeishu } from "./startup/startFeishu.js";
@@ -106,6 +109,7 @@ let feishuConnector: FeishuConnector | undefined;
 let consoleConnector: ConsoleConnector | undefined;
 let startupNotifier: StartupNotifier | undefined;
 let safeRestartNotifier: SafeRestartNotifier | undefined;
+let dailyUpdateMonitor: DailyUpdateMonitor | undefined;
 let controlServer: LocalControlServer | undefined;
 let serverReady = false;
 
@@ -157,14 +161,48 @@ const safeRestart = new SafeRestartScheduler({
   onStatus: (status) => safeRestartNotifier?.update(status),
   onStatusError: (error) => logger.warn({ error }, "Failed to publish safe restart status."),
 });
+if (feishuOutbound && config.updates?.enabled !== false) {
+  dailyUpdateMonitor = new DailyUpdateMonitor({
+    store, outbound: feishuOutbound, logger, currentVersion: agentBotVersion,
+    userOpenId: () => config.feishu.userOpenId,
+    readLatest: readLatestStableVersion,
+    readNotes: readReleaseNotes,
+    checkSupport: () => checkAutomaticUpdateSupport({ home: agentBotHome(), configPath: activeConfigPath }),
+    hasPendingUpdate: () => shuttingDown || restartRequested || !!pendingSelfUpdatePlanPath || safeRestart.scheduled,
+    pendingVersion: () => pendingSelfUpdatePlanPath ? readPendingSelfUpdate(agentBotHome())?.plan.toVersion : undefined,
+    applyUpdate: async (version) => {
+      const prepared = await prepareAutomaticUpdate(version, { home: agentBotHome(), configPath: activeConfigPath });
+      try {
+        if (shuttingDown || restartRequested || pendingSelfUpdatePlanPath || safeRestart.scheduled) {
+          throw new Error("服务正在停止或已有更新/重启等待执行，本次自动更新已停止。");
+        }
+        const target = privateRestartNotificationTarget(config.feishu.userOpenId);
+        if (prepared.status === "prepared") {
+          assertSelfUpdatePlanPath(prepared.planPath, agentBotHome());
+          pendingSelfUpdatePlanPath = prepared.planPath;
+        }
+        safeRestart.schedule(`Agent Bot 自动更新到 ${version}`, target);
+      } catch (error) {
+        if (prepared.status === "prepared") releaseSelfUpdatePlan(prepared.planPath);
+        throw error;
+      }
+    },
+  });
+}
 const controller = new ProxySessionController(config, store, runtimes, outbound, logger, {
   supervised,
   restart: requestRestart,
+  cancelAutomaticUpdate: async (action) => {
+    if (!dailyUpdateMonitor) throw new Error("自动更新功能未启用。");
+    await dailyUpdateMonitor.cancel(action);
+  },
   cancelSafeRestart: async (scheduleId) => {
     const cancelled = await safeRestart.cancelScheduled(scheduleId);
     if (cancelled && pendingSelfUpdatePlanPath) {
+      const version = readPendingSelfUpdate(agentBotHome())?.plan.toVersion;
       releaseSelfUpdatePlan(pendingSelfUpdatePlanPath);
       pendingSelfUpdatePlanPath = undefined;
+      if (version) await dailyUpdateMonitor?.cancelPreparedUpdate(version);
     }
     return cancelled;
   },
@@ -229,6 +267,7 @@ await controller.recoverInterruptedTasks().catch((error: unknown) => {
 });
 consoleConnector?.start();
 recoverPendingSelfUpdate();
+await dailyUpdateMonitor?.start();
 
 function recoverPendingSelfUpdate(): void {
   const pending = readPendingSelfUpdate(agentBotHome());
@@ -511,6 +550,15 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
           request.agentName,
         ),
       };
+    case "task_clone":
+    case "task_clone_group":
+      return {
+        ok: true,
+        data: await controller.controlCloneTask(
+          request.localSessionId, request.title, request.agentName,
+          request.action === "task_clone_group", config.feishu.userOpenId,
+        ),
+      };
     case "task_fork_group":
       return {
         ok: true,
@@ -530,6 +578,7 @@ async function shutdown(
 ): Promise<void> {
   if (shuttingDown) return;
   shuttingDown = true;
+  await dailyUpdateMonitor?.stop();
   if (pendingSelfUpdatePlanPath) {
     releaseSelfUpdatePlan(pendingSelfUpdatePlanPath);
     pendingSelfUpdatePlanPath = undefined;