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

package/src/cli/taskListOutput.ts

@@ -0,0 +1,91 @@
+import type { SessionRecord } from "../state/StateStore.js";
+import { cliLanguage, cliText, type CliLanguage } from "./i18n.js";
+
+export type CurrentTaskResolution =
+  | { status: "found"; session: SessionRecord }
+  | { status: "missing-thread-id" }
+  | { status: "not-found"; threadIds: string[] }
+  | { status: "ambiguous"; sessions: SessionRecord[]; threadIds: string[] };
+
+export function formatTaskList(
+  sessions: SessionRecord[],
+  language: CliLanguage = cliLanguage,
+  currentThreadIds: readonly string[] = [],
+): string {
+  if (sessions.length === 0) return cliText("No tasks.\n", "没有任务。\n", language);
+
+  const current = resolveCurrentTask(sessions, currentThreadIds);
+  const currentLocalSessionId = current.status === "found" ? current.session.localSessionId : undefined;
+  return sessions.map((session, index) => {
+    const title = session.title ?? cliText("Untitled task", "未命名任务", language);
+    const current = session.localSessionId === currentLocalSessionId
+      ? ` [${cliText("Current", "当前任务", language)}]`
+      : "";
+    const nativeId = nativeTaskIdLabel(session, language);
+    return [
+      `${index + 1}.${current} [${taskStateLabel(session.status, language)}/${taskStateLabel(session.lastTurnStatus, language)}] ${title}`,
+      `   ${cliText("Agent: ", "Agent：", language)}${session.agentName} · ${cliText("AgentBot task ID: ", "AgentBot 任务 ID：", language)}${session.localSessionId}`,
+      `   ${nativeId ? `${nativeId} · ` : ""}${session.contextKey} · ${session.updatedAt}`,
+    ].join("\n");
+  }).join("\n") + "\n";
+}
+
+export function currentAppServerThreadIds(env: NodeJS.ProcessEnv): string[] {
+  return [...new Set([
+    env.CODEX_THREAD_ID?.trim(),
+    env.TRAECLI_THREAD_ID?.trim(),
+  ].filter((value): value is string => Boolean(value)))];
+}
+
+export function resolveCurrentTask(
+  sessions: SessionRecord[],
+  currentThreadIds: readonly string[],
+): CurrentTaskResolution {
+  const threadIds = [...new Set(currentThreadIds.map((value) => value.trim()).filter(Boolean))];
+  if (threadIds.length === 0) return { status: "missing-thread-id" };
+
+  const candidates = new Set(threadIds);
+  const matches = sessions.filter((session) => session.remoteSessionId && candidates.has(session.remoteSessionId));
+  if (matches.length === 0) return { status: "not-found", threadIds };
+  if (matches.length === 1) return { status: "found", session: matches[0]! };
+
+  const running = matches.filter((session) =>
+    session.status === "running" || session.lastTurnStatus === "running");
+  if (running.length === 1) return { status: "found", session: running[0]! };
+  return { status: "ambiguous", sessions: matches, threadIds };
+}
+
+export function taskStateLabel(
+  status: string | undefined,
+  language: CliLanguage = cliLanguage,
+): string {
+  if (!status) return "-";
+  const chinese: Record<string, string> = {
+    starting: "启动中",
+    ready: "就绪",
+    running: "运行中",
+    closed: "已关闭",
+    failed: "失败",
+    completed: "已完成",
+    cancelled: "已取消",
+    interrupted: "已中断",
+    inProgress: "进行中",
+    active: "活动中",
+    idle: "空闲",
+    not_loaded: "未加载",
+    error: "错误",
+  };
+  return language === "zh" ? chinese[status] ?? status : status;
+}
+
+function nativeTaskIdLabel(session: SessionRecord, language: CliLanguage): string | undefined {
+  if (session.runtimeKind === "acp" || session.acpSessionId) {
+    const sessionId = session.acpSessionId ?? session.remoteSessionId;
+    return sessionId
+      ? `${cliText("ACP session ID: ", "ACP Session ID：", language)}${sessionId}`
+      : undefined;
+  }
+  return session.remoteSessionId
+    ? `${cliText("App Server thread ID: ", "App Server 原生任务 ID（Thread ID）：", language)}${session.remoteSessionId}`
+    : undefined;
+}

package/src/cli.ts

@@ -65,6 +65,13 @@ import {
   type ServerStartResult,
 } from "./cli/ServerStarter.js";
 import { taskChatRoute } from "./cli/taskChatRoute.js";
+import {
+  currentAppServerThreadIds,
+  formatTaskList,
+  resolveCurrentTask,
+  taskStateLabel,
+} from "./cli/taskListOutput.js";
+import { isThreadContextKey } from "./feishu/contextKey.js";
 import { refreshedSystemEnvironment } from "./supervision/systemEnvironment.js";
 import {
   parseTaskForkGroupOptions,
@@ -136,6 +143,7 @@ interface InitCommandResult extends InitializationResult {
   feishu: {
     status: FeishuInitializationStatus;
     appId?: string;
+    userOpenIdStatus?: "configured" | "pending";
     configuration?: EnsureFeishuAppConfigurationResult;
   };
   server: InitializationServerResult;
@@ -448,6 +456,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 +524,7 @@ async function initializeFeishu(
     return {
       status,
       appId: credentials.appId,
+      userOpenIdStatus: credentials.userOpenId ? "configured" : "pending",
       configuration,
     };
   } finally {
@@ -659,12 +671,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,12 +688,58 @@ 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();
   const store = new StateStore(config.storage.sqlitePath);
   try {
     const allSessions = store.listAllSessions();
+    if (action === "current") {
+      const unsupported = rest.filter((value) => value !== "--json");
+      if (unsupported.length > 0) throw new Error(cliText(
+        `task current does not accept arguments: ${unsupported.join(" ")}`,
+        `task current 不接受这些参数：${unsupported.join(" ")}`,
+      ));
+      const session = resolveCurrentTaskFromEnvironment(allSessions);
+      await outputTaskStatus(config.storage.sqlitePath, store, session, rest.includes("--json"));
+      return;
+    }
     if (action === "prompt" || action === "send") {
       const [reference, ...promptParts] = rest;
       if (!reference) throw new Error(cliText(
@@ -765,28 +825,7 @@ async function taskCommand(input: string[]): Promise<void> {
       return;
     }
     if (action === "status") {
-      const endpoint = controlEndpoint(config.storage.sqlitePath);
-      let live: TaskStatusControlData | undefined;
-      let response: ControlResponse | undefined;
-      try {
-        response = await sendControlRequest(endpoint, {
-          action: "task_status",
-          localSessionId: session.localSessionId,
-        });
-      } catch {
-        // The server can be stopped or still run an older control protocol
-        // while a safe restart is pending. Preserve the local read-only fallback.
-      }
-      if (response) {
-        ensureOk(response);
-        live = response.data as TaskStatusControlData;
-      }
-      const statusSession = live?.session ?? session;
-      const snapshot = live?.snapshot
-        ?? (statusSession.lastTurnId ? store.getTurnSnapshot(statusSession.lastTurnId) : undefined);
-      const result = { ...statusSession, snapshot, ...(live?.remote ? { remote: live.remote } : {}) };
-      if (rest.includes("--json")) printJson(result);
-      else printTaskStatus(statusSession, snapshot, live?.remote);
+      await outputTaskStatus(config.storage.sqlitePath, store, session, rest.includes("--json"));
       return;
     }
     const endpoint = controlEndpoint(config.storage.sqlitePath);
@@ -818,6 +857,53 @@ async function taskCommand(input: string[]): Promise<void> {
   }
 }
 
+function resolveCurrentTaskFromEnvironment(sessions: SessionRecord[]): SessionRecord {
+  const resolution = resolveCurrentTask(sessions, currentAppServerThreadIds(process.env));
+  if (resolution.status === "found") return resolution.session;
+  if (resolution.status === "missing-thread-id") throw new Error(cliText(
+    "The current task cannot be detected because neither CODEX_THREAD_ID nor TRAECLI_THREAD_ID is set. Run this command from a Codex or TraeX task.",
+    "无法检测当前任务：CODEX_THREAD_ID 和 TRAECLI_THREAD_ID 均未设置。请从 Codex 或 TraeX 任务中运行此命令。",
+  ));
+  if (resolution.status === "not-found") throw new Error(cliText(
+    `No AgentBot task matches the current App Server Thread ID (${resolution.threadIds.join(", ")}). Check that the correct Profile is selected.`,
+    `没有 AgentBot 任务匹配当前 App Server Thread ID（${resolution.threadIds.join("，")}）。请检查是否选择了正确的 Profile。`,
+  ));
+  throw new Error(cliText(
+    "The current task is ambiguous because multiple injected Thread IDs match AgentBot tasks. Use task status <task> with an explicit AgentBot task ID.",
+    "当前任务存在歧义：多个注入的 Thread ID 匹配到了 AgentBot 任务。请使用明确的 AgentBot 任务 ID 执行 task status <任务>。",
+  ));
+}
+
+async function outputTaskStatus(
+  sqlitePath: string,
+  store: StateStore,
+  session: SessionRecord,
+  json: boolean,
+): Promise<void> {
+  const endpoint = controlEndpoint(sqlitePath);
+  let live: TaskStatusControlData | undefined;
+  let response: ControlResponse | undefined;
+  try {
+    response = await sendControlRequest(endpoint, {
+      action: "task_status",
+      localSessionId: session.localSessionId,
+    });
+  } catch {
+    // The server can be stopped or still run an older control protocol
+    // while a safe restart is pending. Preserve the local read-only fallback.
+  }
+  if (response) {
+    ensureOk(response);
+    live = response.data as TaskStatusControlData;
+  }
+  const statusSession = live?.session ?? session;
+  const snapshot = live?.snapshot
+    ?? (statusSession.lastTurnId ? store.getTurnSnapshot(statusSession.lastTurnId) : undefined);
+  const result = { ...statusSession, snapshot, ...(live?.remote ? { remote: live.remote } : {}) };
+  if (json) printJson(result);
+  else printTaskStatus(statusSession, snapshot, live?.remote);
+}
+
 function filterSessions(sessions: SessionRecord[], args: string[]): SessionRecord[] {
   const context = optionValue(args, "--context");
   const status = optionValue(args, "--status");
@@ -852,19 +938,12 @@ function resolveTask(sessions: SessionRecord[], reference: string): SessionRecor
 }
 
 function printTaskList(sessions: SessionRecord[]): void {
-  if (sessions.length === 0) {
-    process.stdout.write(cliText("No tasks.\n", "没有任务。\n"));
-    return;
-  }
-  for (const [index, session] of sessions.entries()) {
-    const id = session.remoteSessionId ?? session.acpSessionId ?? session.localSessionId;
-    process.stdout.write(`${index + 1}. [${taskStateLabel(session.status)}/${taskStateLabel(session.lastTurnStatus)}] ${session.title ?? cliText("Untitled task", "未命名任务")}\n`);
-    process.stdout.write(`   ${id} · ${session.contextKey} · ${session.updatedAt}\n`);
-  }
+  process.stdout.write(formatTaskList(sessions, cliLanguage, currentAppServerThreadIds(process.env)));
 }
 
 function printTaskStatus(session: SessionRecord, snapshot: unknown, remote?: TaskStatusControlData["remote"]): void {
   process.stdout.write(`${cliText("Title: ", "标题：")}${session.title ?? cliText("Untitled task", "未命名任务")}\n`);
+  process.stdout.write(`${cliText("Agent: ", "Agent：")}${session.agentName}\n`);
   process.stdout.write(`${cliText("Task ID: ", "任务 ID：")}${session.remoteSessionId ?? session.acpSessionId ?? session.localSessionId}\n`);
   process.stdout.write(`${cliText("Local ID: ", "本地 ID：")}${session.localSessionId}\n`);
   process.stdout.write(`${cliText("Context: ", "上下文：")}${session.contextKey}\n`);
@@ -945,6 +1024,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 +1069,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);
 }
 
@@ -1144,26 +1236,6 @@ function initializationStatusLabel(status: InitializationStatus): string {
   return cliText("already exists; unchanged", "已存在，未修改");
 }
 
-function taskStateLabel(status: string | undefined): string {
-  if (!status) return "-";
-  const chinese: Record<string, string> = {
-    starting: "启动中",
-    ready: "就绪",
-    running: "运行中",
-    closed: "已关闭",
-    failed: "失败",
-    completed: "已完成",
-    cancelled: "已取消",
-    interrupted: "已中断",
-    inProgress: "进行中",
-    active: "活动中",
-    idle: "空闲",
-    not_loaded: "未加载",
-    error: "错误",
-  };
-  return cliLanguage === "zh" ? chinese[status] ?? status : status;
-}
-
 function ensureOk(response: ControlResponse): void {
   if (response.ok) return;
   const message = response.message?.trim();

package/src/codex/CodexProcessManager.ts

@@ -5,12 +5,17 @@ import readline from "node:readline";
 import type { Logger } from "pino";
 import { AppServerConnection } from "./AppServerConnection.js";
 import type { AppServerClient, AppServerClientProvider } from "./CodexRuntime.js";
-import { agentBotEnvironment } from "../runtime/agentEnvironment.js";
+import {
+  agentBotEnvironment,
+  type AgentEnvironmentContext,
+} from "../runtime/agentEnvironment.js";
+import type { AgentProcessInfo } from "../runtime/types.js";
 import { spawnStdioCommand } from "../utils/spawnCommand.js";
 
 export class CodexProcessManager implements AppServerClientProvider {
   private client?: AppServerConnection;
   private child?: ChildProcessWithoutNullStreams;
+  private version?: string;
   private readonly disconnectListeners = new Set<(error: Error) => void>();
 
   constructor(
@@ -18,11 +23,17 @@ export class CodexProcessManager implements AppServerClientProvider {
     private readonly args: string[],
     private readonly env: Record<string, string>,
     private readonly logger: Logger,
+    private readonly environmentContext: () => AgentEnvironmentContext = () => ({}),
   ) {}
 
   async getClient(): Promise<AppServerClient> {
     if (this.client) return this.client;
-    const child = spawnStdioCommand(this.command, this.args, agentBotEnvironment(process.env, this.env));
+    this.version = undefined;
+    const child = spawnStdioCommand(
+      this.command,
+      this.args,
+      agentBotEnvironment(process.env, this.env, this.environmentContext()),
+    );
     this.child = child;
     const client = new AppServerConnection(child, this.logger.child({ component: "codex-app-server" }));
     this.client = client;
@@ -38,14 +49,24 @@ export class CodexProcessManager implements AppServerClientProvider {
       const error = new Error(`App Server exited (code=${code ?? "null"}, signal=${signal ?? "null"}).`);
       for (const listener of this.disconnectListeners) listener(error);
     });
-    await client.request("initialize", {
+    const initializeResult = await client.request("initialize", {
       clientInfo: { name: "agent-bot", title: "Agent Bot", version: "0.1.0" },
       capabilities: { experimentalApi: true },
     });
+    this.version = initializedAgentVersion(initializeResult);
     client.notify("initialized", {});
     return client;
   }
 
+  getProcessInfo(): AgentProcessInfo {
+    const pid = this.child?.pid;
+    if (!pid) return {};
+    return {
+      pid,
+      ...(this.version ? { version: this.version } : {}),
+    };
+  }
+
   getCodexHome(): string {
     return this.env.CODEX_HOME ?? process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
   }
@@ -62,3 +83,17 @@ export class CodexProcessManager implements AppServerClientProvider {
     return () => this.disconnectListeners.delete(listener);
   }
 }
+
+function initializedAgentVersion(value: unknown): string | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const result = value as Record<string, unknown>;
+  const serverInfo = result.serverInfo && typeof result.serverInfo === "object"
+    ? result.serverInfo as Record<string, unknown>
+    : undefined;
+  for (const candidate of [serverInfo?.version, result.version, result.userAgent]) {
+    if (typeof candidate !== "string") continue;
+    const match = /\b(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)\b/u.exec(candidate);
+    if (match?.[1]) return match[1];
+  }
+  return undefined;
+}

package/src/codex/CodexRuntime.ts

@@ -1,6 +1,7 @@
 import type { Logger } from "pino";
 import type {
   AgentRuntime,
+  AgentProcessInfo,
   ApprovalDecision,
   CreateRuntimeSessionInput,
   ForkRuntimeSessionInput,
@@ -55,6 +56,7 @@ export interface AppServerClient {
 
 export interface AppServerClientProvider {
   getClient(): Promise<AppServerClient>;
+  getProcessInfo?(): AgentProcessInfo;
   getCodexHome?(): string;
   onDisconnect?(listener: (error: Error) => void): () => void;
   close(): void;
@@ -100,6 +102,10 @@ export class CodexRuntime implements AgentRuntime {
     return this.sessions.get(localSessionId);
   }
 
+  getProcessInfo(): AgentProcessInfo {
+    return this.provider.getProcessInfo?.() ?? {};
+  }
+
   async createSession(input: CreateRuntimeSessionInput): Promise<RuntimeSession> {
     const client = await this.client();
     const response = await client.request<ThreadResponse>("thread/start", {

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,