@keyou007/agent-bot 0.1.12 → 0.1.13-alpha.1

package/src/codex/CodexRuntime.ts

@@ -163,7 +163,7 @@ export class CodexRuntime implements AgentRuntime {
       if (!isUnsupportedExcludeTurnsError(error)) throw error;
       this.logger.warn(
         { error },
-        "Codex App Server does not support thread/fork excludeTurns; retrying without it.",
+        "App Server does not support thread/fork excludeTurns; retrying without it.",
       );
       response = await client.request<ThreadResponse>("thread/fork", forkParams, FORK_REQUEST_TIMEOUT_MS);
     }
@@ -343,7 +343,7 @@ export class CodexRuntime implements AgentRuntime {
     );
     this.logger.info(
       { ...(sessionId ? { sessionId } : {}), threadId: remoteSessionId, turnId },
-      "Codex accepted the turn interrupt request.",
+      "App Server accepted the turn interrupt request.",
     );
   }
 
@@ -554,7 +554,7 @@ export class CodexRuntime implements AgentRuntime {
       const session = [...this.sessions.values()].find((candidate) => candidate.remoteSessionId === threadId);
       if (session?.activeTurnId && status && status !== "active") {
         void this.synchronizeSession(session.localSessionId).catch((error: unknown) => {
-          this.logger.warn({ error, sessionId: session.localSessionId, status }, "Failed to reconcile Codex thread status.");
+          this.logger.warn({ error, sessionId: session.localSessionId, status }, "Failed to reconcile App Server thread status.");
         });
       }
       return;
@@ -566,7 +566,7 @@ export class CodexRuntime implements AgentRuntime {
     if (session.terminalTurnIds.has(mapped.turnId)) {
       this.logger.debug(
         { sessionId: session.localSessionId, turnId: mapped.turnId, method },
-        "Ignoring a replayed terminal Codex turn event.",
+        "Ignoring a replayed terminal App Server turn event.",
       );
       return;
     }
@@ -586,7 +586,7 @@ export class CodexRuntime implements AgentRuntime {
             notificationTurnId: mapped.turnId,
             notificationStartedAt: mapped.startedAt,
           },
-          "Ignoring a replayed historical Codex turn start.",
+          "Ignoring a replayed historical App Server turn start.",
         );
         return;
       }
@@ -597,10 +597,10 @@ export class CodexRuntime implements AgentRuntime {
     if (!session.activeTurnId || session.activeTurnId !== mapped.turnId) {
       this.logger.debug(
         { sessionId: session.localSessionId, activeTurnId: session.activeTurnId, notificationTurnId: mapped.turnId, method },
-        "Ignoring out-of-order Codex notification and scheduling reconciliation.",
+        "Ignoring out-of-order App Server notification and scheduling reconciliation.",
       );
       void this.synchronizeSession(session.localSessionId).catch((error: unknown) => {
-        this.logger.warn({ error, sessionId: session.localSessionId }, "Failed to reconcile out-of-order Codex notification.");
+        this.logger.warn({ error, sessionId: session.localSessionId }, "Failed to reconcile out-of-order App Server notification.");
       });
       return;
     }
@@ -671,9 +671,12 @@ export class CodexRuntime implements AgentRuntime {
       if (mapped.status === "cancelled") {
         this.emit({ type: "turn_cancelled", sessionId, turnId: mapped.turnId });
       } else if (mapped.status === "failed") {
-        this.emit({ type: "turn_failed", sessionId, turnId: mapped.turnId, message: mapped.error ?? "Codex turn failed." });
+        this.emit({ type: "turn_failed", sessionId, turnId: mapped.turnId, message: mapped.error ?? "App Server turn failed." });
       } else {
-        const finalResponse = appendGeneratedImageMarkdown(session.finalText, session.generatedImagePaths);
+        const finalResponse = appendModelSwitchGuidance(
+          appendGeneratedImageMarkdown(session.finalText, session.generatedImagePaths),
+          session.model,
+        );
         this.emit({
           type: "turn_completed",
           sessionId,
@@ -703,7 +706,7 @@ export class CodexRuntime implements AgentRuntime {
       turnId,
       request: {
         id: requestId,
-        title: stringValue(params.command) ?? "Codex approval request",
+        title: stringValue(params.command) ?? "Agent approval request",
         command: stringValue(params.command),
         reason: stringValue(params.reason),
         options: [
@@ -781,7 +784,7 @@ export class CodexRuntime implements AgentRuntime {
           type: "turn_failed",
           sessionId: session.localSessionId,
           turnId: activeTurnId,
-          message: "Codex no longer reports this execution in the thread history.",
+          message: "The App Server no longer reports this execution in the thread history.",
         });
       }
       return;
@@ -828,7 +831,7 @@ export class CodexRuntime implements AgentRuntime {
         type: "turn_failed",
         sessionId: session.localSessionId,
         turnId: turn.id,
-        message: turn.error?.message ?? "Codex turn failed.",
+        message: turn.error?.message ?? "App Server turn failed.",
       });
       return;
     }
@@ -836,9 +839,12 @@ export class CodexRuntime implements AgentRuntime {
       ...session.generatedImagePaths,
       ...extractGeneratedImagePaths(turn),
     ]);
-    const finalResponse = appendGeneratedImageMarkdown(
-      extractFinalResponse(turn) || session.finalText,
-      generatedImagePaths,
+    const finalResponse = appendModelSwitchGuidance(
+      appendGeneratedImageMarkdown(
+        extractFinalResponse(turn) || session.finalText,
+        generatedImagePaths,
+      ),
+      session.model,
     );
     session.finalText = finalResponse;
     session.generatedImagePaths = [];
@@ -888,13 +894,13 @@ export class CodexRuntime implements AgentRuntime {
 
   private requireSession(sessionId: string): CodexSession {
     const session = this.sessions.get(sessionId);
-    if (!session) throw new Error(`Unknown Codex session: ${sessionId}`);
+    if (!session) throw new Error(`Unknown App Server session: ${sessionId}`);
     return session;
   }
 
   private requireActiveTurn(sessionId: string, turnId: string): CodexSession {
     const session = this.requireSession(sessionId);
-    if (session.activeTurnId !== turnId) throw new Error(`Codex turn is no longer active: ${turnId}`);
+    if (session.activeTurnId !== turnId) throw new Error(`App Server turn is no longer active: ${turnId}`);
     return session;
   }
 
@@ -917,7 +923,7 @@ export class CodexRuntime implements AgentRuntime {
         type: "turn_failed",
         sessionId: session.localSessionId,
         turnId,
-        message: `Codex App Server disconnected: ${error.message}`,
+        message: `App Server disconnected: ${error.message}`,
       });
     }
     for (const [requestId, pending] of this.approvals) {
@@ -978,6 +984,20 @@ function permissionParams(mode: PermissionMode): { approvalPolicy: "never" | "on
     : { approvalPolicy: "on-request", sandbox: "workspace-write" };
 }
 
+const MODEL_SWITCH_GUIDANCE = "请发送 `/model` 切换到其他模型后重试。";
+
+function appendModelSwitchGuidance(response: string, model?: string): string {
+  if (!hasKnownCodeModeFailure(response) || response.includes(MODEL_SWITCH_GUIDANCE)) return response;
+  const modelLabel = model?.trim() ? ` \`${model.trim()}\`` : "";
+  const guidance = `> 当前模型${modelLabel} 的本地工具执行通道异常。${MODEL_SWITCH_GUIDANCE}`;
+  return response.trimEnd() ? `${response.trimEnd()}\n\n${guidance}` : guidance;
+}
+
+function hasKnownCodeModeFailure(response: string): boolean {
+  return /code-mode host closed its stdout/i.test(response)
+    || /exec expects an object containing raw JavaScript in [`'"]?input[`'"]?/i.test(response);
+}
+
 function threadLifecycleParams(cwd: string): {
   developerInstructions: string;
 } {

package/src/commands/CommandRouter.ts

@@ -20,6 +20,7 @@ const COMMAND_NAMES = [
   "switch",
   "thinking",
   "title",
+  "turns",
 ] as const;
 
 type CommandName = (typeof COMMAND_NAMES)[number];
@@ -93,6 +94,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 "turns":
+        if (args.length > 0) throw new Error("/turns 不接受参数，请在历史轮次卡片中选择 turn。");
+        return { type: "turns" };
       case "model":
         return settingsCommand("/model", args, { type: "model" });
       case "provider":

package/src/commands/commandTypes.ts

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

package/src/config/FeishuUserOpenIdStore.ts

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseDotEnv } from "dotenv";
+
+const USER_OPEN_ID_KEY = "FEISHU_USER_OPEN_ID";
+
+export interface FeishuUserOpenIdPersistenceResult {
+  status: "stored" | "existing";
+  userOpenId: string;
+}
+
+export function persistFeishuUserOpenIdIfMissing(
+  envPath: string,
+  userOpenId: string,
+): FeishuUserOpenIdPersistenceResult {
+  if (!/^ou_[A-Za-z0-9_-]+$/u.test(userOpenId)) {
+    throw new Error("Cannot persist an invalid Lark user Open ID.");
+  }
+
+  const original = fs.existsSync(envPath) ? fs.readFileSync(envPath, "utf8") : "";
+  const existing = parseDotEnv(original)[USER_OPEN_ID_KEY]?.trim();
+  if (existing) return { status: "existing", userOpenId: existing };
+
+  fs.mkdirSync(path.dirname(envPath), { recursive: true });
+  writeFileAtomically(envPath, upsertDotEnvValue(original, USER_OPEN_ID_KEY, userOpenId));
+  return { status: "stored", userOpenId };
+}
+
+function upsertDotEnvValue(contents: string, key: string, value: string): string {
+  const newline = contents.includes("\r\n") ? "\r\n" : "\n";
+  const lines = contents.length > 0 ? contents.split(/\r?\n/u) : [];
+  const matcher = new RegExp(`^\\s*(?:export\\s+)?${key}\\s*=`);
+  let replaced = false;
+  const updated = lines.map((line) => {
+    if (!matcher.test(line)) return line;
+    replaced = true;
+    return `${key}=${value}`;
+  });
+  while (updated.length > 0 && updated.at(-1) === "") updated.pop();
+  if (!replaced) updated.push(`${key}=${value}`);
+  return `${updated.join(newline)}${newline}`;
+}
+
+function writeFileAtomically(filePath: string, contents: string): void {
+  const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  let temporaryFile: number | undefined;
+  try {
+    const mode = fs.statSync(filePath, { throwIfNoEntry: false })?.mode ?? 0o600;
+    temporaryFile = fs.openSync(temporaryPath, "wx", mode);
+    fs.writeFileSync(temporaryFile, contents, "utf8");
+    fs.fsyncSync(temporaryFile);
+    fs.closeSync(temporaryFile);
+    temporaryFile = undefined;
+    fs.renameSync(temporaryPath, filePath);
+    restrictFilePermissions(filePath);
+    syncDirectory(path.dirname(filePath));
+  } finally {
+    if (temporaryFile !== undefined) fs.closeSync(temporaryFile);
+    fs.rmSync(temporaryPath, { force: true });
+  }
+}
+
+function restrictFilePermissions(filePath: string): void {
+  try {
+    fs.chmodSync(filePath, 0o600);
+  } catch {
+    // Windows and some mounted filesystems do not implement POSIX modes.
+  }
+}
+
+function syncDirectory(directoryPath: string): void {
+  let directory: number | undefined;
+  try {
+    directory = fs.openSync(directoryPath, "r");
+    fs.fsyncSync(directory);
+  } catch {
+    // Directory fsync is not supported on every Windows or mounted filesystem.
+  } finally {
+    if (directory !== undefined) fs.closeSync(directory);
+  }
+}

package/src/config/loadConfig.ts

@@ -43,30 +43,6 @@ agents:
       - "stdio://"
     env: {}
 
-  coco:
-    title: "Coco"
-    command: "coco"
-    args:
-      - "acp"
-      - "serve"
-    env: {}
-
-  coco-yolo:
-    title: "Coco YOLO"
-    command: "coco"
-    args:
-      - "acp"
-      - "serve"
-      - "--yolo"
-    env: {}
-
-  example:
-    title: "Example ACP Agent"
-    command: "node"
-    args:
-      - "./examples/example-acp-agent.js"
-    env: {}
-
 defaults:
   agent: "codex"
   cwd: "."
@@ -82,6 +58,9 @@ logging:
 export function loadConfig(
   configPath?: string,
 ): AppConfig {
+  if (process.env.FEISHU_USER_OPEN_ID !== undefined && !process.env.FEISHU_USER_OPEN_ID.trim()) {
+    delete process.env.FEISHU_USER_OPEN_ID;
+  }
   loadDotEnv({
     path: defaultDotEnvPath(),
     quiet: true,

package/src/console/ConsoleConnector.ts

@@ -12,8 +12,8 @@ export class ConsoleConnector {
 
   start(): void {
     if (this.reader) return;
-    this.logger.info("Starting local Codex test console.");
-    console.log("Codex console ready. Type /help or enter a prompt.");
+    this.logger.info("Starting the local Agent Bot console.");
+    console.log("Agent Bot console ready. Type /help or enter a prompt.");
     const reader = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "agentbot> " });
     this.reader = reader;
     reader.prompt();

package/src/feishu/CardRenderer.ts

@@ -142,6 +142,19 @@ export interface TaskListCardAction {
 export interface TaskListCardEntry {
   lines: string[];
   actions?: TaskListCardAction[];
+  current?: boolean;
+}
+
+export interface ResetHistoryCardEntry extends TaskListCardEntry {
+  sequence: number;
+  graphNodeLine: string;
+  graphConnectorLine?: string;
+}
+
+export interface ResetHistoryCardView {
+  entries: ResetHistoryCardEntry[];
+  footerLines: string[];
+  pageActions: TaskListCardAction[];
 }
 
 export class CardRenderer {
@@ -163,7 +176,7 @@ export class CardRenderer {
           : `**默认 Agent**：${inlineCode(view.currentAgent)}`,
         ...(view.runtimeSettingsAvailable
           ? [
-              `**Provider / 模型**：${inlineCode(view.currentProvider ?? "Codex 默认")} / ${inlineCode(view.currentModel ?? "默认")}`,
+              `**Provider / 模型**：${inlineCode(view.currentProvider ?? "Agent 默认")} / ${inlineCode(view.currentModel ?? "默认")}`,
               `**思考强度 / 权限**：${inlineCode(view.currentEffort ?? "自动")} / ${inlineCode(permissionModeLabel(view.currentPermissionMode))}`,
             ]
           : []),
@@ -190,7 +203,7 @@ export class CardRenderer {
       if (!view.providerSupported) {
         elements.push(markdown("当前运行时不支持 Provider 切换；其他设置仍可通过上方 tab 修改。"));
       } else if (view.providers.length === 0) {
-        elements.push(markdown("Codex 配置中没有可用的 Provider。"));
+        elements.push(markdown("当前 Agent 配置中没有可用的 Provider。"));
       } else {
         elements.push(...view.providers.map((provider) => settingsOptionRow({
           label: [
@@ -270,14 +283,14 @@ export class CardRenderer {
   renderProviderSelector(view: ProviderSelectorCardView): Record<string, unknown> {
     const elements: Record<string, unknown>[] = [
       markdown([
-        `**当前 Provider**：${inlineCode(view.currentProvider ?? "Codex 默认")}`,
+        `**当前 Provider**：${inlineCode(view.currentProvider ?? "Agent 默认")}`,
         `**模型 / 思考强度 / 权限**：${inlineCode(view.currentModel ?? "默认")} / ${inlineCode(view.reasoningEffort ?? "自动")} / ${inlineCode(permissionModeLabel(view.permissionMode))}`,
         ...(view.notice ? [view.notice] : []),
       ].join("\n")),
       { tag: "hr" },
     ];
     if (view.providers.length === 0) {
-      elements.push(markdown("Codex 配置中没有可用的 Provider。"));
+      elements.push(markdown("当前 Agent 配置中没有可用的 Provider。"));
     } else {
       elements.push(...view.providers.map((provider) => ({
         tag: "column_set",
@@ -635,14 +648,14 @@ export class CardRenderer {
       ? [
         `**当前任务**：${inlineCode(view.currentTask.title ?? view.currentTask.id)}`,
         workspaceLine,
-        `**Provider / 模型 / 思考强度 / 权限**：${inlineCode(view.currentTask.modelProvider ?? "Codex 默认")} / ${inlineCode(view.currentTask.model ?? "默认")} / ${inlineCode(view.currentTask.reasoningEffort ?? "自动")} / ${inlineCode(permissionModeLabel(view.currentTask.permissionMode))}`,
+        `**Provider / 模型 / 思考强度 / 权限**：${inlineCode(view.currentTask.modelProvider ?? "Agent 默认")} / ${inlineCode(view.currentTask.model ?? "默认")} / ${inlineCode(view.currentTask.reasoningEffort ?? "自动")} / ${inlineCode(permissionModeLabel(view.currentTask.permissionMode))}`,
         `**任务状态 / Agent**：${persistedTaskStatus(view.currentTask.sessionStatus, view.currentTask.lastTurnStatus)} / ${inlineCode(view.currentTask.agentName)}`,
         `**任务 ID**：${inlineCode(view.currentTask.id)}`,
       ]
       : [
         "**当前任务**：无，下一条普通消息会创建新任务",
         workspaceLine,
-        `**Provider / 模型 / 思考强度 / 权限**：${inlineCode("Codex 默认")} / ${inlineCode("默认")} / ${inlineCode("自动")} / ${inlineCode(permissionModeLabel())}`,
+        `**Provider / 模型 / 思考强度 / 权限**：${inlineCode("Agent 默认")} / ${inlineCode("默认")} / ${inlineCode("自动")} / ${inlineCode(permissionModeLabel())}`,
         `**默认 Agent**：${view.defaultAgentTitle} (${inlineCode(view.defaultAgentName)})`,
       ];
     lines.push(
@@ -662,6 +675,18 @@ export class CardRenderer {
         type: "danger",
         value: { action: "turn_cancel", sessionId: state.sessionId, turnId: state.turnId },
       }]));
+    } else if (state.status === "completed") {
+      elements.push(
+        { tag: "hr" },
+        taskActionRow([{
+          text: "Reset",
+          value: { action: "turn_reset", sessionId: state.sessionId, turnId: state.turnId },
+        }]),
+        {
+          ...markdown("<font color='grey'>Reset 会将当前任务的对话上下文恢复到本轮完成时；不会回退本地文件。</font>"),
+          text_size: "notation",
+        },
+      );
     }
     return turnCard(
       turnTitle(state.status, state.prompt ?? state.taskTitle),
@@ -673,8 +698,8 @@ export class CardRenderer {
 
   renderTurnDetails(state: TurnViewState): Record<string, unknown> {
     const title = state.taskTitle
-      ? `Codex 执行详情：${truncateText(state.taskTitle.replace(/\s+/g, " ").trim(), 60)}`
-      : "Codex 执行详情";
+      ? `任务执行详情：${truncateText(state.taskTitle.replace(/\s+/g, " ").trim(), 60)}`
+      : "任务执行详情";
     return turnCard(title, "blue", renderTurnElements(state, "always"), renderTurnSubtitle(state));
   }
 
@@ -774,7 +799,7 @@ export class CardRenderer {
     sectionTitle: string,
     entries: TaskListCardEntry[],
     footerLines: string[],
-    footerAction?: TaskListCardAction,
+    footerActions: TaskListCardAction[] = [],
   ): Record<string, unknown> {
     const elements: Record<string, unknown>[] = [markdown(`**${sectionTitle}**`)];
     if (entries.length === 0) {
@@ -791,27 +816,7 @@ export class CardRenderer {
     if (footerLines.length > 0) {
       elements.push({ tag: "hr" }, markdown(footerLines.join("\n")));
     }
-    if (footerAction) {
-      elements.push({
-        tag: "column_set",
-        flex_mode: "none",
-        columns: [{
-          tag: "column",
-          width: "weighted",
-          weight: 1,
-          elements: [{
-            tag: "button",
-            text: { tag: "plain_text", content: footerAction.text },
-            type: footerAction.type ?? "default",
-            width: "fill",
-            behaviors: [{
-              type: "callback",
-              value: footerAction.value,
-            }],
-          }],
-        }],
-      });
-    }
+    if (footerActions.length > 0) elements.push(taskActionRow(footerActions));
     return {
       schema: "2.0",
       config: {
@@ -831,6 +836,39 @@ export class CardRenderer {
     };
   }
 
+  renderResetHistoryCard(view: ResetHistoryCardView): Record<string, unknown> {
+    const elements: Record<string, unknown>[] = [
+      {
+        ...markdown("<font color='grey'>Reset 会将当前任务的对话上下文恢复到所选轮次完成时；不会回退本地文件。</font>"),
+        text_size: "notation",
+      },
+      { tag: "hr" },
+      markdown("**历史对话轮次**"),
+    ];
+    if (view.entries.length === 0) {
+      elements.push(markdown("当前任务还没有成功完成的 turn。"));
+    } else {
+      view.entries.forEach((entry) => {
+        const action = entry.actions?.[0];
+        elements.push(resetHistoryEntryRow(
+          entry.graphNodeLine,
+          entry.graphConnectorLine,
+          entry.lines,
+          action,
+          entry.current === true,
+        ));
+      });
+    }
+    if (view.footerLines.length > 0) {
+      elements.push({ tag: "hr" }, {
+        ...markdown(view.footerLines.join("\n")),
+        text_size: "notation",
+      });
+    }
+    if (view.pageActions.length > 0) elements.push(taskActionRow(view.pageActions));
+    return sectionCard("历史对话轮次", elements);
+  }
+
   private baseCard(title: string, template: string, elements: unknown[]): Record<string, unknown> {
     return {
       config: {
@@ -1470,6 +1508,55 @@ function settingsOptionRow(input: {
   };
 }
 
+function resetHistoryEntryRow(
+  graphNodeLine: string,
+  graphConnectorLine: string | undefined,
+  lines: string[],
+  action: TaskListCardAction | undefined,
+  current: boolean,
+): Record<string, unknown> {
+  const graph = [
+    `<font color='${current ? "green" : "blue"}'>${escapeCardHtml(graphNodeLine)}</font>`,
+    ...(graphConnectorLine
+      ? [`<font color='grey'>${escapeCardHtml(graphConnectorLine)}</font>`]
+      : []),
+  ].join("\n");
+  return {
+    tag: "column_set",
+    flex_mode: "none",
+    horizontal_spacing: "12px",
+    vertical_align: "top",
+    columns: [
+      {
+        tag: "column",
+        width: "auto",
+        vertical_align: "top",
+        elements: [{
+          ...markdown(graph),
+          text_align: "center",
+        }],
+      },
+      {
+        tag: "column",
+        width: "weighted",
+        weight: 1,
+        vertical_align: "top",
+        elements: [markdown(lines.join("\n"))],
+      },
+      {
+        tag: "column",
+        width: "auto",
+        vertical_align: "top",
+        elements: current
+          ? [markdown("✅ 当前")]
+          : action
+            ? [taskActionElement(action)]
+            : [],
+      },
+    ],
+  };
+}
+
 function taskActionRow(actions: TaskListCardAction[]): Record<string, unknown> {
   return {
     tag: "column_set",