@keyou007/agent-bot 0.1.10 → 0.1.12

package/src/feishu/FeishuMessageClient.ts

@@ -233,8 +233,16 @@ export class FeishuMessageClient implements FeishuOutbound {
   }
 
   async updateInteractiveCard(messageId: string, card: Record<string, unknown>): Promise<void> {
+    const preparedCard = await this.prepareInteractiveCard(card);
+    await this.updateInteractiveCardNow(messageId, preparedCard);
+  }
+
+  private async updateInteractiveCardNow(
+    messageId: string,
+    card: Record<string, unknown>,
+    allowAuditFallback = true,
+  ): Promise<void> {
     try {
-      const preparedCard = await this.prepareInteractiveCard(card);
       const token = await this.getTenantAccessToken();
       const response = await fetch(`https://open.feishu.cn/open-apis/im/v1/messages/${messageId}`, {
         method: "PATCH",
@@ -242,14 +250,26 @@ export class FeishuMessageClient implements FeishuOutbound {
           Authorization: `Bearer ${token}`,
           "Content-Type": "application/json; charset=utf-8",
         },
-        body: JSON.stringify({ content: JSON.stringify(preparedCard) }),
+        body: JSON.stringify({ content: JSON.stringify(card) }),
       });
       const payload = (await response.json()) as SendMessageResponse;
       if (!response.ok || payload.code !== 0) {
         throw new FeishuApiError(payload.msg || response.statusText, payload.code, payload, "update", response.status);
       }
     } catch (error) {
-      throw normalizeTransportError(error, "update");
+      const normalized = normalizeTransportError(error, "update");
+      const fallback = allowAuditFallback && normalized.isEmailAddressAuditFailure
+        ? sanitizeEmailAddressesInContent(card)
+        : undefined;
+      if (fallback) {
+        this.logger.warn(
+          { code: normalized.code, messageId },
+          "Feishu rejected a card update as email-sensitive; retrying with audit-safe text.",
+        );
+        await this.updateInteractiveCardNow(messageId, fallback, false);
+        return;
+      }
+      throw normalized;
     }
   }
 
@@ -278,6 +298,7 @@ export class FeishuMessageClient implements FeishuOutbound {
     msgType: string,
     content: Record<string, unknown>,
     idempotencyKey?: string,
+    allowAuditFallback = true,
   ): Promise<string | undefined> {
     let token: string;
     try {
@@ -317,6 +338,16 @@ export class FeishuMessageClient implements FeishuOutbound {
       lastError = error;
 
       if (!error.isRetryable || attempt === 2) {
+        const fallback = allowAuditFallback && error.isEmailAddressAuditFailure
+          ? sanitizeEmailAddressesInContent(content)
+          : undefined;
+        if (fallback) {
+          this.logger.warn(
+            { code: error.code, messageId: target.messageId, msgType },
+            "Feishu rejected a reply as email-sensitive; retrying with audit-safe text.",
+          );
+          return this.replyMessageNow(target, msgType, fallback, idempotencyKey, false);
+        }
         this.logger.error({ error, messageId: target.messageId, msgType }, "Failed to reply to Feishu message.");
         throw error;
       }
@@ -334,6 +365,7 @@ export class FeishuMessageClient implements FeishuOutbound {
     msgType: string,
     content: Record<string, unknown>,
     idempotencyKey?: string,
+    allowAuditFallback = true,
   ): Promise<string | undefined> {
     let token: string;
     try {
@@ -376,6 +408,16 @@ export class FeishuMessageClient implements FeishuOutbound {
       lastError = error;
 
       if (!error.isRetryable || attempt === 2) {
+        const fallback = allowAuditFallback && error.isEmailAddressAuditFailure
+          ? sanitizeEmailAddressesInContent(content)
+          : undefined;
+        if (fallback) {
+          this.logger.warn(
+            { code: error.code, contextKey, msgType },
+            "Feishu rejected a message as email-sensitive; retrying with audit-safe text.",
+          );
+          return this.sendMessageNow(contextKey, msgType, fallback, idempotencyKey, false);
+        }
         this.logger.error({ error, contextKey, msgType }, "Failed to send Feishu message.");
         throw error;
       }
@@ -573,6 +615,7 @@ export class FeishuMessageClient implements FeishuOutbound {
 export class FeishuApiError extends Error {
   readonly isRateLimit: boolean;
   readonly isRetryable: boolean;
+  readonly isEmailAddressAuditFailure: boolean;
 
   constructor(
     message: string,
@@ -591,6 +634,7 @@ export class FeishuApiError extends Error {
     this.name = "FeishuApiError";
     this.isRateLimit = code === 230020 || message.toLowerCase().includes("frequency limit");
     this.isRetryable = forceRetryable || this.isRateLimit || (httpStatus !== undefined && httpStatus >= 500);
+    this.isEmailAddressAuditFailure = code === 230028 && message.includes("EMAIL_ADDRESS");
   }
 }
 
@@ -642,6 +686,25 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+function sanitizeEmailAddressesInContent(content: Record<string, unknown>): Record<string, unknown> | undefined {
+  let changed = false;
+  const sanitize = (value: unknown): unknown => {
+    if (typeof value === "string") {
+      const sanitized = value.replace(
+        /\b([a-z0-9._%+-]+)@([a-z0-9.-]+\.[a-z]{2,})\b/gi,
+        "$1 [at] $2",
+      );
+      if (sanitized !== value) changed = true;
+      return sanitized;
+    }
+    if (Array.isArray(value)) return value.map(sanitize);
+    if (!isRecord(value)) return value;
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, sanitize(child)]));
+  };
+  const sanitized = sanitize(content) as Record<string, unknown>;
+  return changed ? sanitized : undefined;
+}
+
 function cardImageLabel(image: Record<string, unknown>): string {
   const alt = image.alt;
   if (isRecord(alt) && typeof alt.content === "string" && alt.content.trim()) return alt.content;

package/src/feishu/FeishuTurnPresenter.ts

@@ -64,6 +64,7 @@ export class FeishuTurnPresenter {
   private readonly sessionContexts = new Map<string, string>();
   private readonly sessionTitles = new Map<string, string>();
   private readonly sessionCwds = new Map<string, string>();
+  private readonly sessionAgentLabels = new Map<string, string>();
   private readonly entries = new Map<string, TurnEntry>();
   private readonly pendingEntries = new Map<string, TurnEntry>();
   private readonly renderer: CardRenderer;
@@ -77,10 +78,17 @@ export class FeishuTurnPresenter {
     this.renderer = renderer ?? new CardRenderer();
   }
 
-  registerSession(sessionId: string, contextKey: string, taskTitle?: string, projectCwd?: string): void {
+  registerSession(
+    sessionId: string,
+    contextKey: string,
+    taskTitle?: string,
+    projectCwd?: string,
+    agentLabel?: string,
+  ): void {
     this.sessionContexts.set(sessionId, contextKey);
     if (taskTitle) this.sessionTitles.set(sessionId, taskTitle);
     if (projectCwd) this.sessionCwds.set(sessionId, projectCwd);
+    if (agentLabel) this.sessionAgentLabels.set(sessionId, agentLabel);
   }
 
   updateSessionTitle(sessionId: string, taskTitle: string): void {
@@ -97,6 +105,7 @@ export class FeishuTurnPresenter {
     this.sessionContexts.delete(sessionId);
     this.sessionTitles.delete(sessionId);
     this.sessionCwds.delete(sessionId);
+    this.sessionAgentLabels.delete(sessionId);
   }
 
   async startPendingTurn(
@@ -126,6 +135,7 @@ export class FeishuTurnPresenter {
       replyTarget,
       this.sessionCwds.get(sessionId),
       prompt,
+      this.sessionAgentLabels.get(sessionId),
     );
     const entry = { contextKey, state, initializing: Promise.resolve() } as TurnEntry;
     this.entries.set(state.turnId, entry);
@@ -152,6 +162,7 @@ export class FeishuTurnPresenter {
       await entry.scheduler?.flush(entry.state);
     } catch (error) {
       this.options.onError?.(error);
+      return;
     }
     await this.syncThinkingCardReaction(entry);
   }
@@ -178,6 +189,8 @@ export class FeishuTurnPresenter {
               this.sessionTitles.get(sessionId),
               undefined,
               this.sessionCwds.get(sessionId),
+              undefined,
+              this.sessionAgentLabels.get(sessionId),
             ),
             status: "running" as const,
           };
@@ -212,6 +225,7 @@ export class FeishuTurnPresenter {
             pending.state.replyTarget,
             pending.state.projectCwd,
             pending.state.prompt,
+            pending.state.agentLabel,
           ),
           event,
         );
@@ -346,6 +360,7 @@ export class FeishuTurnPresenter {
           undefined,
           this.sessionCwds.get(event.sessionId),
           undefined,
+          this.sessionAgentLabels.get(event.sessionId),
         );
     const state = reduceTurnEvent(
       initial,
@@ -393,16 +408,20 @@ export class FeishuTurnPresenter {
   }
 
   private async finalize(entry: TurnEntry, state: TurnViewState): Promise<void> {
+    let terminalCardError: unknown;
     if (!entry.historySnapshot) {
       try {
         await entry.scheduler?.flush(state);
       } catch (error) {
         this.options.onError?.(error);
+        terminalCardError = error;
       }
     }
+    if (state.status === "completed" && state.finalResponse) {
+      await this.deliverFinal(entry.contextKey, state);
+    }
+    if (terminalCardError) throw terminalCardError;
     await this.syncThinkingCardReaction(entry);
-    if (state.status !== "completed" || !state.finalResponse) return;
-    await this.deliverFinal(entry.contextKey, state);
   }
 
   private async syncThinkingCardReaction(entry: TurnEntry): Promise<void> {

package/src/feishu/transport.ts

@@ -8,7 +8,7 @@ type FeishuTransportConfig = Pick<
 export function requireServerFeishuTransport(config: FeishuTransportConfig): "sdk" {
   if (!config.appId || !config.appSecret) {
     throw new Error(
-      "The Lark bot is not configured. Run agent-bot init first, or use agent-bot console for local-only testing.",
+      "The Lark bot is not configured. Run agentbot init first, or use agentbot console for local-only testing.",
     );
   }
   return "sdk";

package/src/index.ts

@@ -1,10 +1,6 @@
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { AcpProcessManager } from "./acp/AcpProcessManager.js";
-import { AcpSessionManager } from "./acp/AcpSessionManager.js";
-import { CodexProcessManager } from "./codex/CodexProcessManager.js";
-import { CodexRuntime } from "./codex/CodexRuntime.js";
 import { LocalControlServer } from "./cli/LocalControlServer.js";
 import { controlEndpoint, type ControlRequest, type ControlResponse } from "./cli/controlProtocol.js";
 import { readPackageVersion } from "./cli/packageVersion.js";
@@ -20,8 +16,7 @@ import { requireServerFeishuTransport } from "./feishu/transport.js";
 import { createLogger } from "./logging/logger.js";
 import { OutboundRouter, type OutboundRoute } from "./presentation/OutboundRouter.js";
 import { ProxySessionController } from "./proxy/ProxySessionController.js";
-import { AcpRuntimeAdapter } from "./runtime/AcpRuntimeAdapter.js";
-import { AgentRuntimeRegistry } from "./runtime/AgentRuntimeRegistry.js";
+import { createAgentRuntimeRegistry } from "./runtime/createAgentRuntimeRegistry.js";
 import { StateStore } from "./state/StateStore.js";
 import { StartupNotifier } from "./startup/StartupNotifier.js";
 import { SessionMetadataHydrator } from "./startup/SessionMetadataHydrator.js";
@@ -35,6 +30,7 @@ import {
   prepareCrashReportDirectory,
   resolveSupervisorDiagnosticsPaths,
 } from "./supervision/SupervisorDiagnostics.js";
+import { refreshedSystemEnvironment } from "./supervision/systemEnvironment.js";
 
 const processStartedAt = new Date();
 const agentBotVersion = readPackageVersion();
@@ -47,18 +43,7 @@ const transport = consoleOnly ? "console" : requireServerFeishuTransport(config.
 const logger = createLogger(config);
 const store = new StateStore(config.storage.sqlitePath);
 
-const acpProcessManager = new AcpProcessManager(logger);
-const acpSessionManager = new AcpSessionManager(config, acpProcessManager, logger);
-const acpRuntime = new AcpRuntimeAdapter(acpSessionManager);
-const codexAgent = Object.values(config.agents).find((agent) => agent.kind === "codex");
-const codexProcessManager = new CodexProcessManager(
-  codexAgent?.command ?? "codex",
-  codexAgent?.args ?? ["app-server", "--listen", "stdio://"],
-  codexAgent?.env ?? {},
-  logger,
-);
-const codexRuntime = new CodexRuntime(codexProcessManager, logger);
-const runtimes = new AgentRuntimeRegistry({ acp: acpRuntime, codex: codexRuntime });
+const runtimes = createAgentRuntimeRegistry(config, logger);
 
 const routes: OutboundRoute[] = [];
 let feishuConnector: FeishuConnector | undefined;
@@ -85,7 +70,7 @@ if (feishuOutbound) {
     defaultAgentName,
     defaultAgentTitle: defaultAgent?.title ?? defaultAgentName,
     cwd: path.resolve(config.defaults.cwd),
-    workspaceKind: defaultAgent?.kind === "codex" ? "projectless" : "project",
+    workspaceKind: defaultAgent?.kind === "app-server" ? "projectless" : "project",
     defaultUserOpenId: config.feishu.userOpenId,
   }, metadataHydrator);
   safeRestartNotifier = new SafeRestartNotifier(store, feishuOutbound, renderer, logger);
@@ -149,8 +134,24 @@ if (feishuConnector && startupNotifier) {
 }
 consoleConnector?.start();
 
-async function requestRestart(contextKey: string): Promise<void> {
-  await initiateRestart("用户执行 /restart 命令", contextKey);
+async function requestRestart(contextKey: string, force: boolean): Promise<void> {
+  if (restartRequested) {
+    await outbound.sendText(contextKey, "Agent Bot 已在重启中，请稍候。").catch(() => undefined);
+    return;
+  }
+  if (force) {
+    await initiateRestart("用户执行 /restart --force 命令", contextKey);
+    return;
+  }
+  const newlyScheduled = safeRestart.schedule("用户执行 /restart 命令");
+  await outbound.sendText(
+    contextKey,
+    newlyScheduled
+      ? "已安排安全重启。Agent Bot 会等待所有任务完成、最终结果投递完成，并保持 15 秒无新消息后重启。"
+      : "安全重启已在等待中，已更新重启原因。",
+  ).catch((error: unknown) => {
+    logger.warn({ error, contextKey }, "Failed to send safe restart acknowledgement.");
+  });
 }
 
 async function initiateRestart(reason: string, contextKey?: string): Promise<void> {
@@ -159,7 +160,7 @@ async function initiateRestart(reason: string, contextKey?: string): Promise<voi
     return;
   }
   restartRequested = true;
-  safeRestart.cancel();
+  await safeRestart.cancelCurrent();
   await safeRestartNotifier?.flush();
   if (contextKey) {
     await outbound.sendText(contextKey, "Agent Bot 正在重启，恢复在线后会发送启动状态通知。").catch((error: unknown) => {
@@ -210,6 +211,27 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
       return { ok: true, message: await controller.controlSetTaskTitle(request.localSessionId, request.title) };
     case "task_prompt":
       return { ok: true, message: await controller.controlSendTaskPrompt(request.localSessionId, request.text) };
+    case "task_new_group":
+      return {
+        ok: true,
+        data: await controller.controlCreateTaskGroup(
+          request.localSessionId,
+          request.title,
+          config.feishu.userOpenId,
+          request.cwd,
+          request.projectless === true,
+          request.agentName,
+        ),
+      };
+    case "task_fork_group":
+      return {
+        ok: true,
+        data: await controller.controlForkTaskGroup(
+          request.localSessionId,
+          request.title,
+          config.feishu.userOpenId,
+        ),
+      };
   }
 }
 
@@ -226,7 +248,6 @@ async function shutdown(exitCode: number, restartReason?: string): Promise<void>
     delay(5_000),
   ]);
   runtimes.close();
-  acpProcessManager.stopAll();
   await controlServer?.close().catch((error: unknown) => logger.warn({ error }, "Failed to close local control endpoint."));
   store.close();
   if (restartReason) startReplacementSupervisor(restartReason);
@@ -237,6 +258,15 @@ function startReplacementSupervisor(restartReason: string): void {
   const supervisorEntry = fileURLToPath(new URL("./supervisor.js", import.meta.url));
   const reportDirectory = resolveSupervisorDiagnosticsPaths(config).crashReportDirectory;
   prepareCrashReportDirectory(reportDirectory);
+  const environmentRefresh = refreshedSystemEnvironment();
+  if (environmentRefresh.error) {
+    logger.warn({ error: environmentRefresh.error }, "Failed to refresh the Windows environment for the replacement Supervisor.");
+  } else if (environmentRefresh.refreshed) {
+    logger.info(
+      { pathChanged: environmentRefresh.pathChanged },
+      "Refreshed the Windows environment for the replacement Supervisor.",
+    );
+  }
   const supervisor = spawn(process.execPath, [
     ...nodeDiagnosticReportArguments(reportDirectory),
     supervisorEntry,
@@ -245,7 +275,7 @@ function startReplacementSupervisor(restartReason: string): void {
     detached: true,
     windowsHide: true,
     stdio: "ignore",
-    env: replacementSupervisorEnvironment(restartReason),
+    env: replacementSupervisorEnvironment(restartReason, environmentRefresh.environment),
   });
   supervisor.unref();
 }

package/src/presentation/OutboundRouter.ts

@@ -8,7 +8,13 @@ import type {
 } from "../feishu/types.js";
 
 export interface TurnPresenter {
-  registerSession(sessionId: string, contextKey: string, taskTitle?: string, projectCwd?: string): void;
+  registerSession(
+    sessionId: string,
+    contextKey: string,
+    taskTitle?: string,
+    projectCwd?: string,
+    agentLabel?: string,
+  ): void;
   updateSessionTitle(sessionId: string, taskTitle: string): void;
   unregisterSession(sessionId: string): void;
   startPendingTurn(
@@ -48,11 +54,17 @@ export class OutboundRouter {
     if (routes.length === 0) throw new Error("At least one outbound route is required.");
   }
 
-  registerSession(sessionId: string, contextKey: string, taskTitle?: string, projectCwd?: string): void {
+  registerSession(
+    sessionId: string,
+    contextKey: string,
+    taskTitle?: string,
+    projectCwd?: string,
+    agentLabel?: string,
+  ): void {
     const route = this.route(contextKey);
     this.sessionRoutes.set(sessionId, route);
     this.sessionContextKeys.set(sessionId, contextKey);
-    route.presenter.registerSession(sessionId, contextKey, taskTitle, projectCwd);
+    route.presenter.registerSession(sessionId, contextKey, taskTitle, projectCwd, agentLabel);
   }
 
   getSessionContextKey(sessionId: string): string | undefined {

package/src/presentation/TurnStateReducer.ts

@@ -16,10 +16,12 @@ export function createTurnViewState(
   replyTarget?: MessageReplyTarget,
   projectCwd?: string,
   prompt?: string,
+  agentLabel?: string,
 ): TurnViewState {
   return {
     sessionId,
     turnId,
+    agentLabel,
     taskTitle,
     prompt,
     projectCwd,

package/src/presentation/turnViewTypes.ts

@@ -25,6 +25,7 @@ export type TurnActivity =
 export interface TurnViewState {
   sessionId: string;
   turnId: string;
+  agentLabel?: string;
   taskTitle?: string;
   prompt?: string;
   projectCwd?: string;