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

package/src/proxy/ProxySessionController.ts

@@ -59,6 +59,7 @@ import type { AgentRuntimeRegistry } from "../runtime/AgentRuntimeRegistry.js";
 import type {
   AgentRuntime,
   ApprovalDecision,
+  ConversationTurn,
   ModelOption,
   PermissionMode,
   RemoteCompletedTurnSummary,
@@ -81,6 +82,7 @@ import {
 import {
   StateStore,
   type CardActionBinding,
+  type ForkHistorySourceRecord,
   type MessageReactionRecord,
   type MessageReactionStatus,
   type QueuedPromptRecord,
@@ -92,6 +94,7 @@ import { createId } from "../utils/id.js";
 import { formatStorageSize } from "../utils/formatStorageSize.js";
 import { truncateMiddle, truncateText } from "../utils/markdown.js";
 import { normalizeTaskTitle } from "../utils/taskTitle.js";
+import { conversationImportPrompt, exportConversation } from "./ConversationExport.js";
 import {
   executeShellCommand,
   type ShellCommandOptions,
@@ -260,6 +263,8 @@ const HELP_COMMAND_SECTIONS: Array<{
         usage: "[序号或任务 ID]",
         description: "从当前或指定任务最近完成轮次创建分支",
       },
+      { command: "/clone", usage: "[title] [--agent &#60;name&#62;]", description: "导出用户 Prompt 和最终回答，交给新 Agent 任务读取" },
+      { command: "/clonegroup", usage: "[title] [--agent &#60;name&#62;]", description: "将对话上下文交给新群中的 Agent 任务" },
       { command: "/turns", usage: "[Turn ID 或序号]", description: "浏览历史轮次，并可 Reset 对话上下文；带参数查看运行详情" },
       {
         command: "/title",
@@ -477,6 +482,14 @@ export interface ControlTaskGroupResult {
   task: SessionRecord;
 }
 
+export interface ControlTaskCloneResult {
+  sourceLocalSessionId: string;
+  contextFile: string;
+  turnCount: number;
+  task: SessionRecord;
+  group?: CreatedFeishuGroupContext;
+}
+
 export interface ControlTaskReleaseResult {
   agentName: string;
   status: "waiting" | "released";
@@ -487,6 +500,7 @@ export interface ProxyLifecycle {
   supervised?: boolean;
   restart(contextKey: string, force: boolean, replyTarget?: MessageReplyTarget): Promise<void>;
   cancelSafeRestart?(scheduleId: number): Promise<boolean>;
+  cancelAutomaticUpdate?(action: CardAction): Promise<void>;
   rememberFeishuUserOpenId?(userOpenId: string): Promise<void> | void;
   persistAgentExecutionDefaults?(
     agentName: string,
@@ -975,7 +989,10 @@ export class ProxySessionController {
     await this.outbound.withReplyTarget(contextKey, replyTarget, async () => {
       try {
         const kind = String(scopedAction.value.action ?? "");
-        if (kind === "help_command") {
+        if (kind === "agentbot_update_cancel") {
+          if (!this.lifecycle?.cancelAutomaticUpdate) throw new Error("自动更新功能未启用。");
+          await this.lifecycle.cancelAutomaticUpdate(scopedAction);
+        } else if (kind === "help_command") {
           await this.executeHelpCommandAction(scopedAction, contextKey, replyTarget);
         } else if (kind === "turn_details") {
           await this.outbound.showDetails(contextKey, String(scopedAction.value.turnId ?? ""));
@@ -1508,6 +1525,22 @@ export class ProxySessionController {
     };
   }
 
+  async controlCloneTask(
+    localSessionId: string,
+    requestedTitle?: string,
+    requestedAgentName?: string,
+    newGroup = false,
+    userOpenId?: string,
+  ): Promise<ControlTaskCloneResult> {
+    const source = this.requireControlSession(localSessionId);
+    const contextKey = this.controlSessionContextKey(source);
+    const replyTarget = this.controlSessionReplyTarget(source);
+    return this.outbound.withReplyTarget(contextKey, replyTarget, () => this.cloneSession(
+      contextKey, { ...source, contextKey }, requestedTitle, requestedAgentName,
+      newGroup, userOpenId, replyTarget,
+    ));
+  }
+
   async controlForkTaskGroup(
     localSessionId: string,
     requestedTitle: string | undefined,
@@ -1708,6 +1741,7 @@ export class ProxySessionController {
         await loaded.runtime.setReasoningEffort(record.localSessionId, nextEffort);
       }
       this.store.updateRuntimeSession(record.localSessionId, { model: nextValue, reasoningEffort: nextEffort });
+      this.outbound.updateSessionModel(record.localSessionId, nextValue);
     } else if (setting === "thinking" && nextValue) {
       const models = await loaded.runtime.listModels(loaded.session.modelProvider, loaded.session.model);
       const currentModel = models.find((candidate) => candidate.id === loaded.session.model)
@@ -2010,6 +2044,22 @@ export class ProxySessionController {
           command.projectless === true,
         );
         return;
+      case "clone":
+      case "clonegroup": {
+        let source = this.currentSession(contextKey);
+        let throughTurnId: string | undefined;
+        if (incomingMessage?.threadContext && (!source
+          || !this.store.findLatestCompletedTurnId(source.localSessionId, contextKey))) {
+          const resolved = this.resolveThreadForkAnchor(incomingMessage, false);
+          source = resolved.source;
+          throughTurnId = resolved.anchor.turnId;
+        }
+        await this.cloneSession(
+          contextKey, source ?? this.requireCurrentSession(contextKey), command.title,
+          command.agentName, command.type === "clonegroup", userId, replyTarget, throughTurnId,
+        );
+        return;
+      }
       case "forkgroup":
         await this.forkCurrentSessionToFeishuGroup(contextKey, command.title, userId, incomingMessage);
         return;
@@ -3013,7 +3063,7 @@ export class ProxySessionController {
     }
   }
 
-  private resolveThreadForkAnchor(message: IncomingMessage): ResolvedThreadForkAnchor {
+  private resolveThreadForkAnchor(message: IncomingMessage, includeSnapshot = true): ResolvedThreadForkAnchor {
     if (!message.threadContext || !message.threadId || !message.chatId) {
       throw new Error("当前消息不属于可识别的飞书话题。");
     }
@@ -3034,8 +3084,9 @@ export class ProxySessionController {
       throw new Error("话题来源任务不属于当前会话，已拒绝创建分支。");
     }
 
-    const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(anchor.turnId));
-    if (isTurnStillRunning(snapshot?.status)
+    const snapshot = includeSnapshot ? turnViewSnapshot(this.store.getTurnSnapshot(anchor.turnId)) : undefined;
+    const status = includeSnapshot ? snapshot?.status : this.store.getTurnPromptSummary(anchor.turnId)?.status;
+    if (isTurnStillRunning(status)
       || (source.lastTurnId === anchor.turnId && source.lastTurnStatus === "running")) {
       throw new Error("话题对应的轮次仍在执行，App Server 暂时不能从这一轮 fork。请等待该轮完成后再在话题中发送消息。");
     }
@@ -3734,6 +3785,10 @@ export class ProxySessionController {
       while (true) {
         let pendingTurnId: string | undefined;
         try {
+          this.outbound.updateSessionModel(
+            loaded.record.localSessionId,
+            loaded.runtime.getSession(loaded.record.localSessionId)?.model ?? loaded.session.model,
+          );
           pendingTurnId = await this.outbound.startPendingTurn(
             loaded.record.localSessionId,
             loaded.record.contextKey,
@@ -3828,6 +3883,7 @@ export class ProxySessionController {
     replyTarget?: MessageReplyTarget,
     requestedTitle?: string,
     executionSettings: SessionExecutionSettings = {},
+    activate = true,
   ): Promise<SessionRecord> {
     const agent = this.ensureAgent(agentName);
     const resolvedExecutionSettings = mergeExecutionSettings(agent.defaults ?? {}, executionSettings);
@@ -3847,7 +3903,7 @@ export class ProxySessionController {
         permissionMode: resolvedExecutionSettings.permissionMode,
       });
     }
-    this.store.setCurrentSession(contextKey, localSessionId);
+    if (activate) this.store.setCurrentSession(contextKey, localSessionId);
     this.outbound.registerSession(
       localSessionId,
       contextKey,
@@ -4000,6 +4056,105 @@ export class ProxySessionController {
     return { group, task };
   }
 
+  private async cloneSession(
+    sourceContextKey: string,
+    source: SessionRecord,
+    requestedTitle: string | undefined,
+    requestedAgentName: string | undefined,
+    newGroup: boolean,
+    userId?: string,
+    replyTarget?: MessageReplyTarget,
+    throughTurnId?: string,
+  ): Promise<ControlTaskCloneResult> {
+    const context = this.store.getOrCreateUserContext(sourceContextKey, this.config.defaults.agent!);
+    const agentName = requestedAgentName?.trim() || context.defaultAgent;
+    this.ensureAgent(agentName);
+    if (newGroup && !userId?.startsWith("ou_")) {
+      throw new Error("/clonegroup 只能由具有 open_id 的飞书用户触发。");
+    }
+    await this.outbound.sendText(sourceContextKey, `正在导出对话并创建 ${this.agentLabel(agentName)} 克隆任务，请稍后。`);
+    const exported = await exportConversation(
+      path.join(path.dirname(this.config.storage.sqlitePath), "context-transfers"),
+      this.readCloneConversation(source, throughTurnId),
+    );
+    const title = normalizeTaskTitle(requestedTitle) ?? `${source.title ?? "任务"}（克隆）`;
+    const cwd = detectProjectlessWorkspace(source.cwd) ? undefined : source.cwd;
+    const group = newGroup ? await this.createFeishuGroupContext(
+      sourceContextKey, agentName, title, userId, cwd, "/clonegroup",
+    ) : undefined;
+    const contextKey = group?.contextKey ?? sourceContextKey;
+    let task: SessionRecord;
+    try {
+      task = await this.createSession(
+        contextKey, agentName, cwd, false, false, undefined, undefined, title,
+        { permissionMode: source.permissionMode ?? "auto" }, false,
+      );
+    } catch (error) {
+      await this.outbound.sendText(contextKey,
+        `${group ? "群已创建，但" : ""}克隆任务创建失败；上下文文件已保留：${exported.filePath}`);
+      throw error;
+    }
+    this.store.audit(contextKey, "session_cloned", {
+      sourceLocalSessionId: source.localSessionId,
+      clonedLocalSessionId: task.localSessionId,
+      contextFile: exported.filePath,
+      turnCount: exported.turnCount,
+    });
+    try {
+      await this.startTurn(
+        await this.loadSession(task), conversationImportPrompt(exported.filePath),
+        group ? undefined : replyTarget, undefined,
+        { displayPrompt: `读取历史上下文（${exported.turnCount} 轮对话）` },
+      );
+    } catch (error) {
+      await this.outbound.sendText(contextKey,
+        `克隆任务已创建，但上下文读取启动失败。任务 ID：${task.localSessionId}；上下文文件：${exported.filePath}`);
+      throw error;
+    }
+    this.store.setCurrentSession(contextKey, task.localSessionId);
+    await this.outbound.sendText(sourceContextKey, group
+      ? `已创建克隆群：${group.name}，正在读取 ${exported.turnCount} 轮历史对话。`
+      : `已切换到 ${this.agentLabel(agentName)} 克隆任务：${title}，正在读取 ${exported.turnCount} 轮历史对话。`);
+    return {
+      sourceLocalSessionId: source.localSessionId,
+      contextFile: exported.filePath,
+      turnCount: exported.turnCount,
+      task: this.store.getSession(task.localSessionId) ?? task,
+      ...(group ? { group } : {}),
+    };
+  }
+
+  private async *readCloneConversation(source: SessionRecord, throughTurnId?: string): AsyncIterable<ConversationTurn> {
+    const runtime = this.runtimes.forAgent(source.agentName);
+    if (!source.remoteSessionId || !runtime.readConversation) {
+      yield* this.store.readConversation(source.localSessionId, throughTurnId);
+      return;
+    }
+    let localSessionId: string | undefined = source.localSessionId;
+    let remoteSessionId = source.remoteSessionId;
+    const visited = new Set<string>();
+    while (!visited.has(remoteSessionId)) {
+      visited.add(remoteSessionId);
+      const fork: ForkHistorySourceRecord | undefined = localSessionId
+        ? this.store.getForkHistorySource(localSessionId) : undefined;
+      if (fork && runtime.readRemoteForkSource) {
+        const remote = await runtime.readRemoteForkSource(remoteSessionId);
+        const completed = remote.lastCompletedTurnId
+          ?? (remote.lastTurnStatus === "completed" ? remote.lastTurnId : undefined);
+        if (!completed) {
+          if (!fork.sourceRemoteSessionId) throw new Error("找不到分支的原始任务，无法导出继承的上下文。");
+          throughTurnId ??= fork.sourceTurnId;
+          localSessionId = fork.sourceLocalSessionId;
+          remoteSessionId = fork.sourceRemoteSessionId;
+          continue;
+        }
+      }
+      yield* runtime.readConversation(remoteSessionId, throughTurnId);
+      return;
+    }
+    throw new Error("分支来源包含循环，无法导出上下文。");
+  }
+
   private async forkCurrentSessionToFeishuGroup(
     sourceContextKey: string,
     requestedTitle: string | undefined,
@@ -4098,7 +4253,7 @@ export class ProxySessionController {
     taskTitle: string,
     userId: string | undefined,
     boundProjectCwd: string | undefined,
-    commandName: "/newgroup" | "/forkgroup",
+    commandName: "/newgroup" | "/forkgroup" | "/clonegroup",
   ): Promise<CreatedFeishuGroupContext> {
     if (!userId?.startsWith("ou_")) {
       throw new Error(`${commandName} 只能由具有 open_id 的飞书用户消息触发。`);
@@ -5187,7 +5342,9 @@ export class ProxySessionController {
         throw error;
       }
     };
-    return loaded.runtime.setExecutionSettings(loaded.record.localSessionId, settings, persist);
+    const session = await loaded.runtime.setExecutionSettings(loaded.record.localSessionId, settings, persist);
+    this.outbound.updateSessionModel(loaded.record.localSessionId, session.model);
+    return session;
   }
 
   private async assertProviderModelSettings(
@@ -5249,6 +5406,7 @@ export class ProxySessionController {
       await loaded.runtime.setReasoningEffort(loaded.record.localSessionId, nextEffort);
     }
     this.store.updateRuntimeSession(loaded.record.localSessionId, { model, reasoningEffort: nextEffort });
+    this.outbound.updateSessionModel(loaded.record.localSessionId, model);
     await this.persistAgentExecutionDefaults(loaded.record.localSessionId);
     const effortMessage = nextEffort && nextEffort !== currentEffort
       ? `，思考强度已自动调整为 ${nextEffort}`
@@ -8318,7 +8476,7 @@ function latestRemoteTimestamp(...values: Array<number | undefined>): number | u
   return timestamps.length > 0 ? Math.max(...timestamps) : undefined;
 }
 
-function isTurnStillRunning(status?: TurnViewState["status"]): boolean {
+function isTurnStillRunning(status?: string): boolean {
   return status === "starting"
     || status === "running"
     || status === "tool_running"

package/src/runtime/types.ts

@@ -124,6 +124,11 @@ export interface RemoteCompletedTurnSummary {
   completedAt?: number;
 }
 
+export interface ConversationTurn {
+  turnId: string;
+  messages: Array<{ role: "user" | "assistant"; text: string }>;
+}
+
 export interface RemoteTurnPage {
   turns: RemoteCompletedTurnSummary[];
   nextCursor?: string;
@@ -256,6 +261,7 @@ export interface AgentRuntime {
   readRemoteSessionMetrics?(remoteSessionId: string): Promise<RemoteSessionMetrics>;
   readRemoteForkSource?(remoteSessionId: string): Promise<RemoteSessionSummary>;
   listRemoteTurnSummaries?(remoteSessionId: string, input: { cursor?: string; limit: number }): Promise<RemoteTurnPage>;
+  readConversation?(remoteSessionId: string, throughTurnId?: string): AsyncIterable<ConversationTurn>;
   inspectRemoteSessionActivity?(remoteSessionId: string): Promise<RemoteSessionActivity>;
   synchronizeSession(sessionId: string): Promise<RuntimeSession>;
   startTurn(sessionId: string, prompt: RuntimePrompt): Promise<string>;

package/src/state/StateStore.ts

@@ -2,6 +2,8 @@ import fs from "node:fs";
 import path from "node:path";
 import Database from "better-sqlite3";
 import { migrations } from "./migrations.js";
+import type { UpdateCheckSchedule, UpdateNotice } from "../updates/types.js";
+import type { ConversationTurn } from "../runtime/types.js";
 
 export type SessionStatus = "starting" | "ready" | "running" | "closed" | "failed";
 
@@ -287,6 +289,36 @@ export class StateStore {
     `);
   }
 
+  getUpdateCheckSchedule(): UpdateCheckSchedule | undefined {
+    const row = this.db.prepare("SELECT value_json FROM update_check_schedule WHERE id = 1")
+      .get() as { value_json: string } | undefined;
+    return row ? JSON.parse(row.value_json) as UpdateCheckSchedule : undefined;
+  }
+
+  saveUpdateCheckSchedule(schedule: UpdateCheckSchedule): void {
+    this.db.prepare(`INSERT INTO update_check_schedule (id, value_json) VALUES (1, ?)
+      ON CONFLICT(id) DO UPDATE SET value_json = excluded.value_json`).run(JSON.stringify(schedule));
+  }
+
+  getUpdateNotice(version: string): UpdateNotice | undefined {
+    const row = this.db.prepare("SELECT value_json FROM update_notices WHERE version = ?")
+      .get(version) as { value_json: string } | undefined;
+    return row ? JSON.parse(row.value_json) as UpdateNotice : undefined;
+  }
+
+  saveUpdateNotice(notice: UpdateNotice): void {
+    this.db.prepare(`INSERT INTO update_notices (version, status, value_json) VALUES (?, ?, ?)
+      ON CONFLICT(version) DO UPDATE SET status = excluded.status, value_json = excluded.value_json`)
+      .run(notice.version, notice.status, JSON.stringify(notice));
+  }
+
+  listPendingUpdateNotices(): UpdateNotice[] {
+    const rows = this.db.prepare(`SELECT value_json FROM update_notices
+      WHERE status IN ('announcing', 'countdown', 'preparing', 'scheduled')`)
+      .all() as Array<{ value_json: string }>;
+    return rows.map((row) => JSON.parse(row.value_json) as UpdateNotice);
+  }
+
   saveGoalCardDelivery(localSessionId: string, contextKey: string, messageId: string): void {
     const updatedAt = new Date().toISOString();
     this.db.prepare(`
@@ -1047,6 +1079,43 @@ export class StateStore {
     return row ? JSON.parse(row.snapshot_json) : undefined;
   }
 
+  *readConversation(localSessionId: string, throughTurnId?: string): Iterable<ConversationTurn> {
+    const index = this.listTaskTurnGraphIndex(localSessionId);
+    const byId = new Map(index.map((turn) => [turn.turnId, turn]));
+    const current = this.getSession(localSessionId)?.lastTurnId;
+    const parent = current ? this.getTurnParent(current, localSessionId) : undefined;
+    const head = throughTurnId ?? (current && byId.has(current) ? current : undefined)
+      ?? (parent && byId.has(parent) ? parent : undefined)
+      ?? this.findLatestCompletedTurnId(localSessionId) ?? index[0]?.turnId;
+    const branch: string[] = [];
+    const seen = new Set<string>();
+    let turnId: string | undefined = head;
+    while (turnId && !seen.has(turnId)) {
+      seen.add(turnId);
+      const turn = byId.get(turnId);
+      if (!turn) throw new Error("上下文历史不完整，无法导出当前分支。");
+      branch.push(turnId);
+      turnId = turn.parentTurnId;
+    }
+    if (turnId) throw new Error("上下文历史包含循环，无法导出当前分支。");
+    const read = this.db.prepare(`SELECT
+      json_extract(snapshot_json, '$.prompt') AS prompt,
+      json_extract(snapshot_json, '$.finalResponse') AS answer,
+      (SELECT json_group_array(json_extract(value, '$.text'))
+        FROM json_each(snapshot_json, '$.activities')
+        WHERE json_extract(value, '$.kind') = 'user') AS followups
+      FROM turn_snapshots WHERE turn_id = ?`);
+    for (const id of branch.reverse()) {
+      const row = read.get(id) as { prompt: string | null; answer: string | null; followups: string };
+      const messages: ConversationTurn["messages"] = [];
+      for (const text of [row.prompt, ...(JSON.parse(row.followups) as string[])]) {
+        if (text?.trim()) messages.push({ role: "user", text });
+      }
+      if (row.answer?.trim()) messages.push({ role: "assistant", text: row.answer });
+      yield { turnId: id, messages };
+    }
+  }
+
   getTurnPromptSummary(turnId: string): TurnPromptSummary | undefined {
     const row = this.db.prepare(`SELECT
       json_extract(snapshot_json, '$.status') AS status,

package/src/state/migrations.ts

@@ -195,4 +195,16 @@ export const migrations = [
   CREATE INDEX IF NOT EXISTS idx_card_action_bindings_created
     ON card_action_bindings(created_at);
   `,
+  `
+  CREATE TABLE IF NOT EXISTS update_check_schedule (
+    id INTEGER PRIMARY KEY CHECK (id = 1),
+    value_json TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS update_notices (
+    version TEXT PRIMARY KEY,
+    status TEXT NOT NULL,
+    value_json TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_update_notices_status ON update_notices(status);
+  `,
 ] as const;

package/src/updates/AutomaticUpdatePreparer.ts

@@ -0,0 +1,76 @@
+import { execFile, type ExecFileOptionsWithStringEncoding } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { loadConfig } from "../config/loadConfig.js";
+import { controlEndpoint } from "../cli/controlProtocol.js";
+import { finalizeSelfUpdatePlan, prepareSelfUpdate, releaseSelfUpdatePlan, requireNpmSelfUpdateInstallation } from "../cli/SelfUpdater.js";
+import { stableVersionSchema } from "./PublishedRelease.js";
+
+const resultSchema = z.discriminatedUnion("status", [
+  z.object({ status: z.literal("current") }),
+  z.object({ status: z.literal("prepared"), planPath: z.string().min(1), targetVersion: stableVersionSchema }),
+]);
+const runFile = promisify(execFile);
+type RunPreparation = (file: string, args: string[], options: ExecFileOptionsWithStringEncoding) => Promise<{ stdout: string }>;
+interface UpdateProfile { home: string; configPath: string }
+
+export async function checkAutomaticUpdateSupport(profile: UpdateProfile, run: RunPreparation = runFile): Promise<void> {
+  z.object({ status: z.literal("supported") }).parse(await runPreparer("--check", profile, run));
+}
+
+export async function prepareAutomaticUpdate(
+  version: string,
+  profile: UpdateProfile,
+  run: RunPreparation = runFile,
+): Promise<z.infer<typeof resultSchema>> {
+  stableVersionSchema.parse(version);
+  const result = resultSchema.parse(await runPreparer(version, profile, run));
+  if (result.status === "prepared" && result.targetVersion !== version) {
+    throw new Error("The prepared update does not match the announced version.");
+  }
+  return result;
+}
+
+async function runPreparer(argument: string, profile: UpdateProfile, run: RunPreparation): Promise<unknown> {
+  const environment: NodeJS.ProcessEnv = { ...process.env, AGENT_BOT_HOME: profile.home, AGENT_BOT_CONFIG: profile.configPath };
+  delete environment.AGENT_BOT;
+  // npm preparation is synchronous and can take minutes; keep it off the live worker's event loop.
+  const { stdout } = await run(process.execPath, [fileURLToPath(import.meta.url), argument], {
+    env: environment, windowsHide: true, encoding: "utf8", maxBuffer: 1_000_000,
+  });
+  return JSON.parse(String(stdout)) as unknown;
+}
+
+async function main(): Promise<void> {
+  if (process.argv[2] === "--check") {
+    requireNpmSelfUpdateInstallation();
+    process.stdout.write(JSON.stringify({ status: "supported" }));
+    return;
+  }
+  const version = stableVersionSchema.parse(process.argv[2]);
+  const config = loadConfig();
+  const prepared = await prepareSelfUpdate({ version, channel: "latest" });
+  if (prepared.status === "prepared") {
+    try {
+      finalizeSelfUpdatePlan(prepared.planPath, {
+        controlEndpoint: controlEndpoint(config.storage.sqlitePath),
+        databasePath: config.storage.sqlitePath,
+        restartService: true,
+        workingDirectory: process.cwd(),
+        reason: `Agent Bot 自动更新到 ${version}`,
+      });
+    } catch (error) {
+      releaseSelfUpdatePlan(prepared.planPath);
+      throw error;
+    }
+  }
+  process.stdout.write(JSON.stringify(prepared));
+}
+
+if (process.argv[1] && pathToFileURL(process.argv[1]).href === import.meta.url) {
+  void main().catch((error: unknown) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  });
+}