ai-project-manage-cli 6.0.92 → 6.0.94

package/dist/index.js

@@ -2,7 +2,6 @@
 
 // src/index.ts
 import { Command } from "commander";
-import { AssumptionPlanSource } from "@opc/shared";
 
 // src/config.ts
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -2217,6 +2216,7 @@ async function runUpdateMessageStatus(options) {
 
 // src/commands/connect.ts
 import WebSocket from "ws";
+import { setTimeout as delay2 } from "node:timers/promises";
 
 // src/ws/protocol.ts
 function nonEmptyString(v) {
@@ -3655,6 +3655,7 @@ function forceReleaseConnectLock() {
 
 // src/commands/daemon.ts
 import { spawnSync as spawnSync2 } from "child_process";
+import { setTimeout as delay } from "node:timers/promises";
 import { createRequire } from "node:module";
 import { existsSync as existsSync14, mkdirSync as mkdirSync7, writeFileSync as writeFileSync13 } from "fs";
 import { join as join15 } from "path";
@@ -3683,10 +3684,12 @@ function buildConnectPm2Ecosystem(options) {
         args: options.connectArgs,
         autorestart: true,
         min_uptime: "10s",
-        max_restarts: 100,
+        max_restarts: 0,
         restart_delay: 3e3,
         exp_backoff_restart_delay: 1e3,
         max_memory_restart: "1G",
+        kill_timeout: 5e3,
+        shutdown_with_message: true,
         env
       }
     ]
@@ -3879,10 +3882,44 @@ async function runDaemonStart(options) {
   console.log("[apm] \u505C\u6B62: apm daemon stop");
 }
 async function runDaemonStop() {
+  pruneStaleConnectLock();
+  if (!isPm2ConnectOnline()) {
+    killConnectLockProcessIfAlive();
+    forceReleaseConnectLock();
+    console.log(`[apm] ${PM2_APP_NAME} \u672A\u5728\u8FD0\u884C`);
+    return;
+  }
   runPm2(["stop", PM2_APP_NAME], { inherit: true });
+  for (let i = 0; i < 10; i += 1) {
+    if (!isPm2ConnectOnline()) break;
+    await delay(500);
+  }
+  if (isPm2ConnectOnline()) {
+    console.log(`[apm] \u4F18\u96C5\u505C\u6B62\u8D85\u65F6\uFF0C\u5F3A\u5236\u79FB\u9664 ${PM2_APP_NAME}\u2026`);
+    runPm2(["delete", PM2_APP_NAME], { inherit: true });
+  }
+  killConnectLockProcessIfAlive();
   forceReleaseConnectLock();
   console.log(`[apm] ${PM2_APP_NAME} \u5DF2\u505C\u6B62`);
 }
+function killConnectLockProcessIfAlive() {
+  pruneStaleConnectLock();
+  const lock = readConnectLock();
+  if (!lock || !isProcessAlive(lock.pid)) return;
+  try {
+    process.kill(lock.pid, "SIGTERM");
+  } catch {
+    forceReleaseConnectLock();
+    return;
+  }
+  if (isProcessAlive(lock.pid)) {
+    try {
+      process.kill(lock.pid, "SIGKILL");
+    } catch {
+    }
+  }
+  forceReleaseConnectLock();
+}
 async function runDaemonRestart(options) {
   pruneStaleConnectLock();
   const lock = readConnectLock();
@@ -3917,6 +3954,8 @@ async function runDaemonLogs(options) {
 
 // src/commands/connect.ts
 var HEARTBEAT_MS = 3e4;
+var RECONNECT_MIN_MS = 1e3;
+var RECONNECT_MAX_MS = 6e4;
 async function updateMessageStatus(cfg, messageId, status) {
   const api = createApmApiClient(cfg);
   await api.cli.updateMessageStatus({ id: messageId, status });
@@ -4069,6 +4108,17 @@ async function handleInboundMessage(cfg, msg, signal, ctx) {
     }
   }
 }
+function interruptibleSleep(ms, signal) {
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve5) => {
+    const timer = setTimeout(resolve5, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve5();
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
 function startHeartbeat(ws, clientMachineId) {
   const send = () => {
     if (ws.readyState === WebSocket.OPEN) {
@@ -4084,182 +4134,274 @@ function startHeartbeat(ws, clientMachineId) {
   const timer = setInterval(send, HEARTBEAT_MS);
   return () => clearInterval(timer);
 }
-async function runConnect(options) {
-  const { didUpdate } = await runUpdate();
-  if (didUpdate) {
-    await handleConnectAfterUpdate(options);
-  }
-  const cfg = await ensureLoggedConfig();
-  if (options.server?.trim()) {
-    cfg.baseUrl = options.server.trim().replace(/\/+$/, "");
-  }
-  const clientMachineId = resolveClientMachineId(cfg);
-  if (!clientMachineId) {
-    console.error("[apm] config \u7F3A\u5C11 clientMachineId\uFF0C\u8BF7\u91CD\u65B0 apm login");
-    process.exit(1);
-  }
-  assertConnectNotRunning();
-  acquireConnectLock("foreground");
-  process.on("exit", releaseConnectLock);
-  const url = buildAgentWsUrl(cfg.baseUrl, resolveApiKey(cfg));
-  console.log(`[apm] \u8FDE\u63A5 ${cfg.baseUrl} \u2026`);
-  await new Promise((resolve5, reject) => {
-    const ws = new WebSocket(url);
-    let stopHeartbeat;
-    let shuttingDown = false;
-    const shutdownAbort = new AbortController();
-    const runSlots = createRunSlotPool();
-    const activeTasks = /* @__PURE__ */ new Set();
-    const activeRuns = /* @__PURE__ */ new Map();
-    const pendingCancels = /* @__PURE__ */ new Set();
-    const shutdown = async (code = 0) => {
-      if (shuttingDown) return;
-      shuttingDown = true;
-      logAbortSignalStats(
-        shutdownAbort.signal,
-        "connect:shutdown-before-abort"
-      );
-      shutdownAbort.abort();
-      logAbortSignalStats(shutdownAbort.signal, "connect:shutdown-after-abort");
-      stopHeartbeat?.();
-      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
-        ws.terminate();
-      }
-      try {
-        await Promise.race([
-          Promise.all(activeTasks),
-          new Promise((r) => setTimeout(r, SHUTDOWN_DRAIN_MS))
-        ]);
-      } catch {
-      }
-      releaseConnectLock();
-      resolve5();
-      process.exit(code);
-    };
-    ws.on("open", () => {
-      console.log("[apm] WebSocket \u5DF2\u8FDE\u63A5");
-      stopHeartbeat = startHeartbeat(ws, clientMachineId);
-    });
-    ws.on("message", (data) => {
-      if (shuttingDown) return;
-      const text = Buffer.isBuffer(data) ? data.toString("utf8") : String(data);
-      const parsed = parseAgentWsMessage(text);
-      if (parsed === null) {
-        console.error("[apm] \u6536\u5230\u65E0\u6548 JSON");
-        return;
-      }
-      if (typeof parsed === "object" && parsed !== null && parsed.type === "heartbeat") {
-        return;
-      }
-      const validated = validateAgentWsMessage(parsed, "outbound");
-      if (!validated.ok) {
-        console.error(`[apm] \u6536\u5230\u65E0\u6548 WS \u5305: ${validated.reason}`);
-        return;
-      }
-      if (validated.data.type === "cancel") {
-        const { messageId } = validated.data;
-        pendingCancels.add(messageId);
-        activeRuns.get(messageId)?.abort();
-        return;
-      }
-      if (validated.data.type === "deploy") {
-        const msg2 = validated.data;
-        const perDeployController = new AbortController();
-        const signal2 = AbortSignal.any([
-          shutdownAbort.signal,
-          perDeployController.signal
-        ]);
-        const task2 = (async () => {
-          await runSlots.acquire();
-          try {
-            await handleInboundDeploy(cfg, msg2, signal2);
-          } finally {
-            runSlots.release();
-          }
-        })();
-        activeTasks.add(task2);
-        void task2.finally(() => {
-          activeTasks.delete(task2);
-        });
-        return;
-      }
-      if (validated.data.type !== "message") {
-        return;
-      }
-      const msg = validated.data;
-      const perMessageController = new AbortController();
-      activeRuns.set(msg.messageId, perMessageController);
-      if (pendingCancels.has(msg.messageId)) {
-        activeRuns.delete(msg.messageId);
-        pendingCancels.delete(msg.messageId);
-        return;
-      }
-      const signal = AbortSignal.any([
+function attachWsHandlers(ws, ctx, onOpen) {
+  const {
+    cfg,
+    clientMachineId,
+    shutdownAbort,
+    runSlots,
+    activeTasks,
+    activeRuns,
+    pendingCancels,
+    isShuttingDown
+  } = ctx;
+  ws.on("open", () => {
+    console.log("[apm] WebSocket \u5DF2\u8FDE\u63A5");
+    onOpen();
+  });
+  ws.on("message", (data) => {
+    if (isShuttingDown()) return;
+    const text = Buffer.isBuffer(data) ? data.toString("utf8") : String(data);
+    const parsed = parseAgentWsMessage(text);
+    if (parsed === null) {
+      console.error("[apm] \u6536\u5230\u65E0\u6548 JSON");
+      return;
+    }
+    if (typeof parsed === "object" && parsed !== null && parsed.type === "heartbeat") {
+      return;
+    }
+    const validated = validateAgentWsMessage(parsed, "outbound");
+    if (!validated.ok) {
+      console.error(`[apm] \u6536\u5230\u65E0\u6548 WS \u5305: ${validated.reason}`);
+      return;
+    }
+    if (validated.data.type === "cancel") {
+      const { messageId } = validated.data;
+      pendingCancels.add(messageId);
+      activeRuns.get(messageId)?.abort();
+      return;
+    }
+    if (validated.data.type === "deploy") {
+      const msg2 = validated.data;
+      const perDeployController = new AbortController();
+      const signal2 = AbortSignal.any([
         shutdownAbort.signal,
-        perMessageController.signal
+        perDeployController.signal
       ]);
-      const ctx = {
-        shutdownSignal: shutdownAbort.signal,
-        perMessageSignal: perMessageController.signal
-      };
-      const task = (async () => {
+      const task2 = (async () => {
         await runSlots.acquire();
         try {
-          if (signal.aborted || isUserCancelled(ctx)) return;
-          try {
-            await updateMessageStatus(cfg, msg.messageId, "TYPING");
-          } catch (typingErr) {
-            if (isUserCancelled(ctx)) return;
-            console.error(
-              "[apm] \u66F4\u65B0 TYPING \u72B6\u6001\u5931\u8D25:",
-              typingErr instanceof Error ? typingErr.message : typingErr
-            );
-            try {
-              await setMessageError(
-                cfg,
-                msg.messageId,
-                typingErr instanceof Error ? typingErr.message : String(typingErr)
-              );
-              await updateMessageStatus(cfg, msg.messageId, "FAILED");
-            } catch (statusErr) {
-              console.error(
-                "[apm] \u66F4\u65B0 FAILED \u72B6\u6001\u5931\u8D25:",
-                statusErr instanceof Error ? statusErr.message : statusErr
-              );
-            }
-            return;
-          }
-          await handleInboundMessage(cfg, msg, signal, ctx);
+          await handleInboundDeploy(cfg, msg2, signal2);
         } finally {
           runSlots.release();
-          activeRuns.delete(msg.messageId);
-          pendingCancels.delete(msg.messageId);
         }
       })();
-      activeTasks.add(task);
-      void task.finally(() => {
-        activeTasks.delete(task);
+      activeTasks.add(task2);
+      void task2.finally(() => {
+        activeTasks.delete(task2);
       });
+      return;
+    }
+    if (validated.data.type !== "message") {
+      return;
+    }
+    const msg = validated.data;
+    const perMessageController = new AbortController();
+    activeRuns.set(msg.messageId, perMessageController);
+    if (pendingCancels.has(msg.messageId)) {
+      activeRuns.delete(msg.messageId);
+      pendingCancels.delete(msg.messageId);
+      return;
+    }
+    const signal = AbortSignal.any([
+      shutdownAbort.signal,
+      perMessageController.signal
+    ]);
+    const messageCtx = {
+      shutdownSignal: shutdownAbort.signal,
+      perMessageSignal: perMessageController.signal
+    };
+    const task = (async () => {
+      await runSlots.acquire();
+      try {
+        if (signal.aborted || isUserCancelled(messageCtx)) return;
+        try {
+          await updateMessageStatus(cfg, msg.messageId, "TYPING");
+        } catch (typingErr) {
+          if (isUserCancelled(messageCtx)) return;
+          console.error(
+            "[apm] \u66F4\u65B0 TYPING \u72B6\u6001\u5931\u8D25:",
+            typingErr instanceof Error ? typingErr.message : typingErr
+          );
+          try {
+            await setMessageError(
+              cfg,
+              msg.messageId,
+              typingErr instanceof Error ? typingErr.message : String(typingErr)
+            );
+            await updateMessageStatus(cfg, msg.messageId, "FAILED");
+          } catch (statusErr) {
+            console.error(
+              "[apm] \u66F4\u65B0 FAILED \u72B6\u6001\u5931\u8D25:",
+              statusErr instanceof Error ? statusErr.message : statusErr
+            );
+          }
+          return;
+        }
+        await handleInboundMessage(cfg, msg, signal, messageCtx);
+      } finally {
+        runSlots.release();
+        activeRuns.delete(msg.messageId);
+        pendingCancels.delete(msg.messageId);
+      }
+    })();
+    activeTasks.add(task);
+    void task.finally(() => {
+      activeTasks.delete(task);
+    });
+  });
+}
+function connectOnce(url, ctx, connectionAbort, onConnected) {
+  return new Promise((resolve5, reject) => {
+    const ws = new WebSocket(url);
+    let stopHeartbeat;
+    let settled = false;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      connectionAbort.removeEventListener("abort", onConnectionAbort);
+      stopHeartbeat?.();
+      fn();
+    };
+    const onConnectionAbort = () => {
+      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+        ws.terminate();
+      }
+    };
+    connectionAbort.addEventListener("abort", onConnectionAbort);
+    attachWsHandlers(ws, ctx, () => {
+      stopHeartbeat = startHeartbeat(ws, ctx.clientMachineId);
+      onConnected();
     });
     ws.on("close", (code, reason) => {
       console.log(
         `[apm] \u8FDE\u63A5\u5DF2\u65AD\u5F00 code=${code}${reason ? ` reason=${reason.toString()}` : ""}`
       );
-      void shutdown();
+      if (ctx.isShuttingDown()) {
+        finish(() => reject(new Error("shutdown")));
+        return;
+      }
+      finish(resolve5);
     });
     ws.on("error", (err) => {
       console.error("[apm] WebSocket \u9519\u8BEF:", err.message);
-      reject(err);
-    });
-    process.on("SIGINT", () => {
-      console.log("[apm] \u6B63\u5728\u5173\u95ED\u2026");
-      void shutdown();
-    });
-    process.on("SIGTERM", () => {
-      void shutdown();
+      if (ctx.isShuttingDown()) {
+        finish(() => reject(new Error("shutdown")));
+        return;
+      }
+      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+        ws.terminate();
+      }
     });
   });
 }
+async function runConnect(options) {
+  const { didUpdate } = await runUpdate();
+  if (didUpdate) {
+    await handleConnectAfterUpdate(options);
+  }
+  const cfg = await ensureLoggedConfig();
+  if (options.server?.trim()) {
+    cfg.baseUrl = options.server.trim().replace(/\/+$/, "");
+  }
+  const clientMachineId = resolveClientMachineId(cfg);
+  if (!clientMachineId) {
+    console.error("[apm] config \u7F3A\u5C11 clientMachineId\uFF0C\u8BF7\u91CD\u65B0 apm login");
+    process.exit(1);
+  }
+  assertConnectNotRunning();
+  const lockMode = isRunningUnderPm2() ? "pm2" : "foreground";
+  acquireConnectLock(lockMode);
+  process.on("exit", releaseConnectLock);
+  let shuttingDown = false;
+  let shutdownPromise = null;
+  const lifecycleAbort = new AbortController();
+  const shutdownAbort = new AbortController();
+  const runSlots = createRunSlotPool();
+  const activeTasks = /* @__PURE__ */ new Set();
+  const activeRuns = /* @__PURE__ */ new Map();
+  const pendingCancels = /* @__PURE__ */ new Set();
+  let currentConnectionAbort = null;
+  const sessionCtx = {
+    cfg,
+    clientMachineId,
+    shutdownAbort,
+    runSlots,
+    activeTasks,
+    activeRuns,
+    pendingCancels,
+    isShuttingDown: () => shuttingDown
+  };
+  const drainAndExit = async (code = 0) => {
+    const drainMs = isRunningUnderPm2() ? 500 : SHUTDOWN_DRAIN_MS;
+    lifecycleAbort.abort();
+    currentConnectionAbort?.abort();
+    logAbortSignalStats(shutdownAbort.signal, "connect:shutdown-before-abort");
+    shutdownAbort.abort();
+    logAbortSignalStats(shutdownAbort.signal, "connect:shutdown-after-abort");
+    try {
+      await Promise.race([Promise.all(activeTasks), delay2(drainMs)]);
+    } catch {
+    }
+    releaseConnectLock();
+    process.exit(code);
+  };
+  const shutdown = (code = 0) => {
+    if (shuttingDown) return shutdownPromise ?? Promise.resolve();
+    shuttingDown = true;
+    shutdownPromise = drainAndExit(code);
+    return shutdownPromise;
+  };
+  const onStopSignal = (code = 0) => {
+    console.log("[apm] \u6B63\u5728\u5173\u95ED\u2026");
+    void shutdown(code);
+  };
+  process.on("SIGINT", () => onStopSignal(0));
+  process.on("SIGTERM", () => onStopSignal(0));
+  if (isRunningUnderPm2()) {
+    process.on("message", (msg) => {
+      if (msg === "shutdown") onStopSignal(0);
+    });
+  }
+  let reconnectDelay = RECONNECT_MIN_MS;
+  while (!shuttingDown) {
+    currentConnectionAbort = new AbortController();
+    const connectionSignal = AbortSignal.any([
+      lifecycleAbort.signal,
+      currentConnectionAbort.signal
+    ]);
+    const url = buildAgentWsUrl(cfg.baseUrl, resolveApiKey(cfg));
+    console.log(`[apm] \u8FDE\u63A5 ${cfg.baseUrl} \u2026`);
+    try {
+      await connectOnce(url, sessionCtx, connectionSignal, () => {
+        reconnectDelay = RECONNECT_MIN_MS;
+      });
+      if (shuttingDown) break;
+      console.log(`[apm] ${reconnectDelay}ms \u540E\u5C1D\u8BD5\u91CD\u8FDE\u2026`);
+      await interruptibleSleep(reconnectDelay, lifecycleAbort.signal);
+      if (shuttingDown) break;
+      reconnectDelay = Math.min(reconnectDelay * 2, RECONNECT_MAX_MS);
+    } catch (err) {
+      if (shuttingDown) break;
+      const detail = err instanceof Error ? err.message : String(err);
+      if (detail === "shutdown") break;
+      console.error("[apm] \u8FDE\u63A5\u5931\u8D25:", detail);
+      console.log(`[apm] ${reconnectDelay}ms \u540E\u5C1D\u8BD5\u91CD\u8FDE\u2026`);
+      await interruptibleSleep(reconnectDelay, lifecycleAbort.signal);
+      if (shuttingDown) break;
+      reconnectDelay = Math.min(reconnectDelay * 2, RECONNECT_MAX_MS);
+    } finally {
+      currentConnectionAbort = null;
+    }
+  }
+  if (!shuttingDown) {
+    void shutdown(0);
+    return;
+  }
+  if (shutdownPromise) {
+    await shutdownPromise;
+  }
+}
 
 // src/commands/create-pr-errors.ts
 import { ApiError as ApiError2 } from "listpage-http";
@@ -4789,6 +4931,56 @@ async function zipDirectory(distDir, zipPath) {
   console.error(`\u5DF2\u751F\u6210: ${zipPath} (${sizeMb} MB)`);
   return content.length;
 }
+var SFTP_UPLOAD_MAX_ATTEMPTS = 3;
+var SFTP_FAST_PUT_OPTIONS = {
+  chunkSize: 64 * 1024,
+  concurrency: 4
+};
+function buildSftpConnectOptions(settings) {
+  return {
+    host: settings.host,
+    port: settings.port,
+    username: settings.username,
+    password: settings.password,
+    readyTimeout: 3e4,
+    tryKeyboard: true,
+    keepaliveInterval: 1e4,
+    keepaliveCountMax: 3
+  };
+}
+async function sleep(ms) {
+  await new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+async function uploadZipWithRetry(settings, localZip, remoteZipPath) {
+  let lastError;
+  for (let attempt = 1; attempt <= SFTP_UPLOAD_MAX_ATTEMPTS; attempt++) {
+    const sftp = new SftpClient();
+    try {
+      if (attempt > 1) {
+        console.error(
+          `SFTP \u4E0A\u4F20\u91CD\u8BD5 (${attempt}/${SFTP_UPLOAD_MAX_ATTEMPTS})...`
+        );
+      }
+      await sftp.connect(buildSftpConnectOptions(settings));
+      await ensureRemoteDir(sftp, settings.remotePath);
+      await sftp.fastPut(localZip, remoteZipPath, SFTP_FAST_PUT_OPTIONS);
+      return sftp;
+    } catch (err) {
+      lastError = err;
+      try {
+        await sftp.end();
+      } catch {
+      }
+      if (attempt < SFTP_UPLOAD_MAX_ATTEMPTS) {
+        const message = err instanceof Error ? err.message : String(err);
+        const delaySec = attempt * 2;
+        console.error(`SFTP \u4E0A\u4F20\u5931\u8D25 (${message})\uFF0C${delaySec}s \u540E\u91CD\u8BD5...`);
+        await sleep(delaySec * 1e3);
+      }
+    }
+  }
+  throw lastError;
+}
 async function ensureRemoteDir(sftp, dir) {
   const parts = dir.replace(/\\/g, "/").split("/").filter(Boolean);
   let current = dir.startsWith("/") ? "" : ".";
@@ -4848,18 +5040,8 @@ async function uploadAndMaybeExtract(settings, localZip, extract) {
   console.error(
     `\u8FDE\u63A5 ${settings.username}@${settings.host}:${settings.port} ...`
   );
-  const sftp = new SftpClient();
+  const sftp = await uploadZipWithRetry(settings, localZip, remoteZipPath);
   try {
-    await sftp.connect({
-      host: settings.host,
-      port: settings.port,
-      username: settings.username,
-      password: settings.password,
-      readyTimeout: 2e4,
-      tryKeyboard: true
-    });
-    await ensureRemoteDir(sftp, settings.remotePath);
-    await sftp.put(localZip, remoteZipPath);
     console.error(`  \u2713 ${localZip} -> ${remoteZipPath}`);
     if (extract) {
       const target = settings.remotePath.replace(/\/$/, "");
@@ -7006,15 +7188,14 @@ function buildProgram() {
   ).argument("<sessionId>", "\u6C9F\u901A\u7FA4 ID").action(async (sessionId) => {
     await runPull(sessionId);
   });
-  program.command("dev-gate").description("\u67E5\u8BE2\u672C\u7AEF\u5F00\u53D1\u95E8\u7981\u72B6\u6001\uFF08\u5047\u8BBE\u786E\u8BA4 + \u9700\u6C42\u7406\u89E3\u786E\u8BA4\uFF09").argument("<sessionId>", "\u6C9F\u901A\u7FA4 ID").requiredOption(
-    "--source <source>",
-    "FRONTEND_PLAN \u6216 BACKEND_PLAN"
-  ).action(async (sessionId, opts) => {
-    const source = opts.source === "BACKEND_PLAN" ? AssumptionPlanSource.BACKEND_PLAN : AssumptionPlanSource.FRONTEND_PLAN;
+  program.command("dev-gate").description("\u67E5\u8BE2\u672C\u7AEF\u5F00\u53D1\u95E8\u7981\u72B6\u6001\uFF08\u5047\u8BBE\u786E\u8BA4 + \u9700\u6C42\u7406\u89E3\u786E\u8BA4\uFF09").argument("<sessionId>", "\u6C9F\u901A\u7FA4 ID").requiredOption("--source <source>", "FRONTEND_PLAN \u6216 BACKEND_PLAN").action(async (sessionId, opts) => {
+    const source = opts.source === "BACKEND_PLAN" ? "BACKEND_PLAN" /* BACKEND_PLAN */ : "FRONTEND_PLAN" /* FRONTEND_PLAN */;
     await runDevGate(sessionId, source);
   });
   program.command("assumptions").description("\uFF08\u5DF2\u5E9F\u5F03\uFF09\u8BF7\u4F7F\u7528 dev-gate").argument("<sessionId>", "\u6C9F\u901A\u7FA4 ID").action(async () => {
-    console.error("[apm] assumptions \u547D\u4EE4\u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u4F7F\u7528: apm dev-gate <sessionId> --source FRONTEND_PLAN|BACKEND_PLAN");
+    console.error(
+      "[apm] assumptions \u547D\u4EE4\u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u4F7F\u7528: apm dev-gate <sessionId> --source FRONTEND_PLAN|BACKEND_PLAN"
+    );
     process.exit(1);
   });
   program.command("sync-document").description("\u5C06\u672C\u5730 Markdown \u8986\u76D6\u5F0F upsert \u5230\u5E73\u53F0\u4EFB\u52A1\u6587\u6863").argument("<sessionId>", "\u6C9F\u901A\u7FA4 ID").requiredOption(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-project-manage-cli",
-  "version": "6.0.92",
+  "version": "6.0.94",
   "description": "命令行工具：后续用于调用平台后端 API 完成运维与自动化操作",
   "type": "module",
   "private": false,