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

package/src/cli/controlProtocol.ts

@@ -6,7 +6,12 @@ import type { SessionRecord } from "../state/StateStore.js";
 
 export type ControlRequest =
   | { action: "health" }
-  | { action: "server_restart"; mode: "safe" | "immediate"; reason: string }
+  | {
+      action: "server_restart";
+      mode: "safe" | "immediate";
+      reason: string;
+      notificationSessionId?: string;
+    }
   | { action: "server_stop" }
   | { action: "task_status"; localSessionId: string }
   | { action: "task_stop"; localSessionId: string }

package/src/cli/help.ts

@@ -14,7 +14,7 @@ export function renderCliHelp(version: string, language: CliLanguage = cliLangua
   console                           打开本地控制台
   server start                      在后台启动 Agent Bot
   server status                     显示服务、飞书 App ID 和安全重启状态
-  server restart                    安排安全重启
+  server restart [--task <任务>]    安排安全重启并将状态发回指定任务会话
   server stop                       停止 Agent Bot
   task list                         列出任务
   task status <任务>                显示任务状态
@@ -39,6 +39,11 @@ export function renderCliHelp(version: string, language: CliLanguage = cliLangua
   --skip-feishu                     仅初始化 Console 环境
   --reconfigure-feishu              仅替换现有飞书凭据
 
+重启选项：
+  --task <任务>                     将安全重启状态发回任务所在会话
+  --reason <原因>                   设置重启原因
+  --immediate                       立即重启，可能中断任务
+
 示例：
   agentbot init
   agentbot --profile ~/.agent-bot init --reset
@@ -62,7 +67,7 @@ Common commands:
   console                           Open the local console
   server start                      Start Agent Bot in the background
   server status                     Show the server, Lark App ID, and safe-restart status
-  server restart                    Schedule a safe restart
+  server restart [--task <task>]    Schedule a safe restart and return status to the task's conversation
   server stop                       Stop Agent Bot
   task list                         List tasks
   task status <task>                Show task status
@@ -87,6 +92,11 @@ Init options:
   --skip-feishu                     Initialize for Console only
   --reconfigure-feishu              Replace only the existing Lark credentials
 
+Restart options:
+  --task <task>                     Return safe-restart status to the task's conversation
+  --reason <reason>                 Set the restart reason
+  --immediate                       Restart immediately and possibly interrupt tasks
+
 Examples:
   agentbot init
   agentbot --profile ~/.agent-bot init --reset

package/src/cli.ts

@@ -65,6 +65,7 @@ import {
   type ServerStartResult,
 } from "./cli/ServerStarter.js";
 import { taskChatRoute } from "./cli/taskChatRoute.js";
+import { isThreadContextKey } from "./feishu/contextKey.js";
 import { refreshedSystemEnvironment } from "./supervision/systemEnvironment.js";
 import {
   parseTaskForkGroupOptions,
@@ -136,6 +137,7 @@ interface InitCommandResult extends InitializationResult {
   feishu: {
     status: FeishuInitializationStatus;
     appId?: string;
+    userOpenIdStatus?: "configured" | "pending";
     configuration?: EnsureFeishuAppConfigurationResult;
   };
   server: InitializationServerResult;
@@ -448,6 +450,9 @@ async function initializeFeishu(
     return {
       status: "skipped",
       ...(existing.appId ? { appId: existing.appId } : {}),
+      ...(existing.appId && existing.appSecret
+        ? { userOpenIdStatus: existing.userOpenId ? "configured" as const : "pending" as const }
+        : {}),
     };
   }
   if (!options.json) {
@@ -513,6 +518,7 @@ async function initializeFeishu(
     return {
       status,
       appId: credentials.appId,
+      userOpenIdStatus: credentials.userOpenId ? "configured" : "pending",
       configuration,
     };
   } finally {
@@ -659,12 +665,14 @@ async function serverCommand(input: string[]): Promise<void> {
   }
   if (action === "restart") {
     const immediate = rest.includes("--immediate") || rest.includes("--force");
+    const notificationSessionId = resolveRestartNotificationSessionId(config.storage.sqlitePath, rest);
     const reason = optionValue(rest, "--reason")
       ?? (immediate ? "通过 Agent Bot CLI 立即重启" : "通过 Agent Bot CLI 安全重启");
     ensureOk(await sendControlRequest(endpoint, {
       action: "server_restart",
       mode: immediate ? "immediate" : "safe",
       reason,
+      notificationSessionId,
     }));
     process.stdout.write(immediate
       ? cliText("Immediate restart requested.\n", "已请求立即重启。\n")
@@ -674,6 +682,42 @@ async function serverCommand(input: string[]): Promise<void> {
   throw new Error(cliText(`Unknown server command: ${action}`, `未知的 server 命令：${action}`));
 }
 
+function resolveRestartNotificationSessionId(sqlitePath: string, args: string[]): string | undefined {
+  const store = new StateStore(sqlitePath);
+  try {
+    const sessions = store.listAllSessions();
+    if (args.includes("--task")) {
+      const reference = optionValue(args, "--task")?.trim();
+      if (!reference || reference.startsWith("--")) throw new Error(cliText(
+        "server restart --task requires a task number or task ID.",
+        "server restart --task 需要任务序号或任务 ID。",
+      ));
+      const session = resolveTask(sessions, reference);
+      if (
+        isThreadContextKey(session.contextKey)
+        && !store.findLatestMessageIdForSession(session.localSessionId, session.contextKey)
+        && !store.findLatestMessageIdForContext(session.contextKey)
+      ) {
+        throw new Error(cliText(
+          "The task topic has no message anchor for restart notifications. Send /restart in that topic instead.",
+          "该任务话题没有可用于重启通知的消息锚点，请直接在该话题中发送 /restart。",
+        ));
+      }
+      return session.localSessionId;
+    }
+    const runningContexts = new Set(
+      sessions.filter((session) => session.status === "running").map((session) => session.contextKey),
+    );
+    if (runningContexts.size > 1) throw new Error(cliText(
+      "Multiple conversations are running. Pass --task <task> so restart notifications return to the requester.",
+      "当前有多个会话正在运行。请传入 --task <任务>，确保重启通知返回发起会话。",
+    ));
+    return undefined;
+  } finally {
+    store.close();
+  }
+}
+
 async function taskCommand(input: string[]): Promise<void> {
   const [action = "list", ...rest] = input;
   const config = loadConfig();
@@ -945,6 +989,12 @@ function printInitializationResult(result: Omit<InitCommandResult, "server">): v
       "飞书应用：已跳过；请使用 Console 模式或稍后重新运行 init。\n",
     ));
   }
+  if (result.feishu.userOpenIdStatus === "pending") {
+    process.stdout.write(cliText(
+      "Lark user: pending; send the bot a direct message to save FEISHU_USER_OPEN_ID\n",
+      "飞书用户：等待补全；请私聊机器人以保存 FEISHU_USER_OPEN_ID\n",
+    ));
+  }
   if (result.feishu.configuration?.status === "updated") {
     const added = result.feishu.configuration.added;
     process.stdout.write(cliText(
@@ -984,6 +1034,13 @@ function printInitializationServerResult(result: InitCommandResult["server"]): v
     ));
     return;
   }
+  if (result.status === "restart-scheduled") {
+    process.stdout.write(cliText(
+      "Agent Bot server: safe restart scheduled to load the current version.\n",
+      "Agent Bot 服务：已安排安全重启，以加载当前版本。\n",
+    ));
+    return;
+  }
   printServerStartResult(result);
 }
 

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

@@ -58,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/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 {
@@ -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),
@@ -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",