ai-project-manage-cli 6.0.79 → 6.0.81

package/README.md

@@ -31,8 +31,31 @@ apm sync-project-documents
 apm sync-project-documents --push
 apm update-skills
 apm branch <sessionId>
+apm branch prune [--dry-run] [-A|--all]
 ```
 
+## 常驻连接（后台守护）
+
+```bash
+apm connect --daemon              # 长期在线（后台）
+apm connect --daemon -f           # 长期在线，并在当前终端实时看日志
+apm connect --daemon --server https://your-server.com
+
+# 运维
+apm daemon status
+apm daemon logs
+apm daemon logs -f                # 随时重新跟踪日志
+apm daemon restart
+apm daemon stop
+apm daemon delete
+
+# 备选启动
+apm daemon start
+apm daemon start -f
+```
+
+PM2 已内置；同一时刻仅允许一个 connect。启动时会自动检测 CLI 更新并刷新守护配置。
+
 `apm pull` 会自动将平台登记的**仓库项目文档**同步到 `.apm/project/`（含 `manifest.json`）。Agent 修改 `.apm/project/` 下文件后，`apm connect` 处理完消息会自动推回平台。
 
 详见仓库根目录 [docs/CLI.md](../../docs/CLI.md)。

package/dist/index.js

@@ -1180,22 +1180,47 @@ async function ensureGitRepo2(cwd) {
 async function getCurrentBranch2(cwd) {
   return (await execGit3(cwd, ["rev-parse", "--abbrev-ref", "HEAD"], true)).trim();
 }
-async function resolveDefaultBranch(cwd) {
+async function resolveBaselineBranch(cwd, api) {
+  const workdirPath = resolveWorkdirPath(cwd);
+  const baseline = await api.cli.workspaceBaseline({ workdirPath });
+  if (!baseline.repositoryId) {
+    const detail = baseline.diagnostic?.message ?? `\u672A\u5728\u5E73\u53F0\u627E\u5230\u4E0E\u5F53\u524D\u76EE\u5F55\u5339\u914D\u7684\u5DE5\u4F5C\u76EE\u5F55\u767B\u8BB0\uFF1A${workdirPath}\uFF08\u89C4\u8303\u5316\uFF1A${baseline.workdirPath}\uFF09
+\u8BF7\u5148\u5728\u5E73\u53F0\u767B\u8BB0\u8BE5\u8DEF\u5F84\u5BF9\u5E94\u7684\u5DE5\u4F5C\u76EE\u5F55\u4E0E\u4ED3\u5E93\u3002`;
+    throw new Error(`[apm] ${detail}`);
+  }
+  const baselineBranch = (baseline.defaultBranch ?? "").trim();
+  if (!baselineBranch) {
+    throw new Error("[apm] \u5E73\u53F0\u8FD4\u56DE\u7684\u57FA\u7EBF\u5206\u652F\u540D\u4E3A\u7A7A");
+  }
+  await execGit3(cwd, ["fetch", "origin", baselineBranch], true);
+  if (!await remoteBranchExists(cwd, baselineBranch)) {
+    throw new Error(
+      `[apm] \u8FDC\u7A0B\u4E0D\u5B58\u5728\u57FA\u7EBF\u5206\u652F origin/${baselineBranch}\uFF0C\u8BF7\u786E\u8BA4\u4ED3\u5E93\u9ED8\u8BA4\u5206\u652F\u5DF2\u63A8\u9001\u5230 origin`
+    );
+  }
+  return baselineBranch;
+}
+async function isBranchBasedOnBaseline(cwd, branch, baselineBranch) {
+  const ref = await localBranchExists2(cwd, branch) ? branch : `origin/${branch}`;
   try {
-    const ref = (await execGit3(cwd, ["symbolic-ref", "refs/remotes/origin/HEAD"], true)).trim();
-    const match = ref.match(/^refs\/remotes\/origin\/(.+)$/);
-    if (match?.[1]) {
-      return match[1];
-    }
+    await execGit3(
+      cwd,
+      ["merge-base", "--is-ancestor", `origin/${baselineBranch}`, ref],
+      true
+    );
+    return true;
   } catch {
+    return false;
   }
-  const out = await execGit3(cwd, ["remote", "show", "origin"], true);
-  const headLine = out.split(/\r?\n/).find((line) => line.includes("HEAD branch"));
-  const branch = headLine?.split(":").pop()?.trim();
-  if (branch) {
-    return branch;
+}
+async function listCandidateSessionBranches(cwd, includeRemote) {
+  const names = new Set(await listLocalSessionBranches(cwd));
+  if (includeRemote) {
+    for (const branch of await listRemoteSessionBranches(cwd)) {
+      names.add(branch);
+    }
   }
-  throw new Error("[apm] \u65E0\u6CD5\u89E3\u6790 origin \u9ED8\u8BA4\u5206\u652F\uFF0C\u8BF7\u5148\u6267\u884C git fetch origin");
+  return [...names].sort((a, b) => a.localeCompare(b));
 }
 async function listLocalSessionBranches(cwd) {
   const out = await execGit3(
@@ -1268,20 +1293,27 @@ async function isBranchMergedIntoDefault(cwd, branch, defaultBranch) {
 async function runCleanBranches(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const dryRun = options.dryRun ?? false;
+  const includeRemote = options.includeRemote ?? false;
   await ensureGitRepo2(cwd);
   await execGit3(cwd, ["fetch", "--prune", "origin"], true);
   const cfg = await ensureLoggedConfig();
   const api = createApmApiClient(cfg);
+  const baselineBranch = await resolveBaselineBranch(cwd, api);
   const { sessions } = await api.cli.listSessionsForBranchCleanup({});
   const sessionStatusById = new Map(
     sessions.map((item) => [item.sessionId, item.taskStatus])
   );
-  const branchNames = /* @__PURE__ */ new Set([
-    ...await listLocalSessionBranches(cwd),
-    ...await listRemoteSessionBranches(cwd)
-  ]);
-  if (branchNames.size === 0) {
-    console.log("[apm] \u672A\u53D1\u73B0 feat/session-* \u5206\u652F");
+  const candidates = await listCandidateSessionBranches(cwd, includeRemote);
+  const branchNames = [];
+  for (const branch of candidates) {
+    if (await isBranchBasedOnBaseline(cwd, branch, baselineBranch)) {
+      branchNames.push(branch);
+    }
+  }
+  if (branchNames.length === 0) {
+    console.log(
+      `[apm] \u672A\u53D1\u73B0\u4ECE ${baselineBranch} \u884D\u751F\u7684\u672C\u5730 feat/session-* \u5206\u652F${includeRemote ? "\uFF08\u542B\u8FDC\u7A0B\uFF09" : ""}`
+    );
     return;
   }
   const toDelete = [...branchNames].map((branch) => {
@@ -1300,10 +1332,6 @@ async function runCleanBranches(options = {}) {
     return;
   }
   let currentBranch = await getCurrentBranch2(cwd);
-  let defaultBranch = null;
-  if (dryRun) {
-    defaultBranch = await resolveDefaultBranch(cwd);
-  }
   for (const item of toDelete) {
     const { branch, sessionId, reason } = item;
     const label = `${branch} (${sessionId}: ${reason})`;
@@ -1311,16 +1339,15 @@ async function runCleanBranches(options = {}) {
       const merged = await isBranchMergedIntoDefault(
         cwd,
         branch,
-        defaultBranch
+        baselineBranch
       );
       const mergeTag = merged ? "\u5DF2\u5408\u5E76" : "\u672A\u5408\u5E76";
       console.log(`[apm] [dry-run] \u5C06\u5220\u9664 ${label} [${mergeTag}]`);
       continue;
     }
     if (currentBranch === branch) {
-      defaultBranch ??= await resolveDefaultBranch(cwd);
-      await execGit3(cwd, ["checkout", defaultBranch], true);
-      currentBranch = defaultBranch;
+      await execGit3(cwd, ["checkout", baselineBranch], true);
+      currentBranch = baselineBranch;
     }
     if (await localBranchExists2(cwd, branch)) {
       await execGit3(cwd, ["branch", "-D", branch], true);
@@ -2126,7 +2153,6 @@ async function runUpdateMessageStatus(options) {
 }
 
 // src/commands/connect.ts
-import { spawnSync as spawnSync2 } from "child_process";
 import WebSocket from "ws";
 
 // src/ws/protocol.ts
@@ -3232,6 +3258,337 @@ function createRunSlotPool(maxConcurrent = DEFAULT_MAX_CONCURRENT) {
   return { acquire, release };
 }
 
+// src/commands/connect-lock.ts
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync11, unlinkSync, writeFileSync as writeFileSync12 } from "fs";
+import { join as join14 } from "path";
+var CONNECT_LOCK_PATH = join14(APM_CONFIG_DIR, "connect.lock");
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readConnectLock() {
+  if (!existsSync13(CONNECT_LOCK_PATH)) return null;
+  try {
+    const raw = readFileSync11(CONNECT_LOCK_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.pid !== "number" || parsed.mode !== "foreground" && parsed.mode !== "pm2" || typeof parsed.startedAt !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function pruneStaleConnectLock() {
+  const lock = readConnectLock();
+  if (!lock) return;
+  if (isProcessAlive(lock.pid)) return;
+  try {
+    unlinkSync(CONNECT_LOCK_PATH);
+  } catch {
+  }
+}
+function acquireConnectLock(mode) {
+  pruneStaleConnectLock();
+  const existing = readConnectLock();
+  if (existing && isProcessAlive(existing.pid)) {
+    console.error(
+      `[apm] \u5DF2\u6709 apm connect \u5728\u8FD0\u884C (pid=${existing.pid}, mode=${existing.mode})`
+    );
+    process.exit(1);
+  }
+  mkdirSync6(APM_CONFIG_DIR, { recursive: true });
+  const lock = {
+    pid: process.pid,
+    mode,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync12(CONNECT_LOCK_PATH, JSON.stringify(lock, null, 2) + "\n", "utf8");
+}
+function releaseConnectLock() {
+  const lock = readConnectLock();
+  if (lock?.pid !== process.pid) return;
+  try {
+    unlinkSync(CONNECT_LOCK_PATH);
+  } catch {
+  }
+}
+function forceReleaseConnectLock() {
+  try {
+    if (existsSync13(CONNECT_LOCK_PATH)) {
+      unlinkSync(CONNECT_LOCK_PATH);
+    }
+  } catch {
+  }
+}
+
+// src/commands/daemon.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { createRequire } from "node:module";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, writeFileSync as writeFileSync13 } from "fs";
+import { join as join15 } from "path";
+var PM2_APP_NAME = "apm-connect";
+var PM2_ECOSYSTEM_PATH = join15(APM_CONFIG_DIR, "connect.ecosystem.cjs");
+function resolveConnectArgs(server) {
+  const args = ["connect"];
+  const trimmed = server?.trim();
+  if (trimmed) {
+    args.push("--server", trimmed.replace(/\/+$/, ""));
+  }
+  return args;
+}
+function buildConnectPm2Ecosystem(options) {
+  const env = {};
+  const baseUrl = options.baseUrl?.trim().replace(/\/+$/, "");
+  if (baseUrl) {
+    env.AI_PM_SERVER = baseUrl;
+  }
+  return {
+    apps: [
+      {
+        name: PM2_APP_NAME,
+        script: options.apmScript,
+        interpreter: options.nodePath,
+        args: options.connectArgs,
+        autorestart: true,
+        min_uptime: "10s",
+        max_restarts: 100,
+        restart_delay: 3e3,
+        exp_backoff_restart_delay: 1e3,
+        max_memory_restart: "1G",
+        env
+      }
+    ]
+  };
+}
+function formatConnectPm2EcosystemFile(ecosystem) {
+  return `module.exports = ${JSON.stringify(ecosystem, null, 2)};
+`;
+}
+function resolvePm2Bin() {
+  const require2 = createRequire(import.meta.url);
+  return require2.resolve("pm2/bin/pm2");
+}
+var useNpmShell2 = process.platform === "win32";
+function resolveApmEntryPath(entryArg = process.argv[1]) {
+  const fromArgv = entryArg?.trim();
+  if (fromArgv && existsSync14(fromArgv)) {
+    return fromArgv;
+  }
+  const npmResult = spawnSync2(useNpmShell2 ? "npm.cmd" : "npm", ["root", "-g"], {
+    encoding: "utf8",
+    shell: useNpmShell2,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (npmResult.status === 0) {
+    const globalRoot = npmResult.stdout?.toString().trim();
+    if (globalRoot) {
+      const candidate = join15(globalRoot, CLI_PACKAGE_NAME, "dist", "index.js");
+      if (existsSync14(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  if (fromArgv) {
+    return fromArgv;
+  }
+  console.error("[apm] \u65E0\u6CD5\u89E3\u6790 apm \u5165\u53E3\u8DEF\u5F84");
+  process.exit(1);
+}
+function isRunningUnderPm2() {
+  return process.env.name === PM2_APP_NAME && process.env.pm_id !== void 0;
+}
+function runPm2(args, options) {
+  let pm2Bin;
+  try {
+    pm2Bin = resolvePm2Bin();
+  } catch {
+    console.error(
+      "[apm] \u672A\u627E\u5230\u5185\u7F6E pm2\uFF0C\u8BF7\u91CD\u65B0\u5B89\u88C5 apm CLI\uFF1Anpm install -g ai-project-manage-cli@latest"
+    );
+    process.exit(1);
+  }
+  const spawnOptions = {
+    encoding: "utf8",
+    stdio: options?.inherit ? "inherit" : ["ignore", "pipe", "pipe"]
+  };
+  const result = spawnSync2(process.execPath, [pm2Bin, ...args], spawnOptions);
+  if (result.error) {
+    console.error("[apm] \u6267\u884C pm2 \u5931\u8D25:", result.error.message);
+    process.exit(1);
+  }
+  if (result.status !== 0) {
+    const stderr = result.stderr?.toString().trim();
+    const stdout = result.stdout?.toString().trim();
+    const detail = stderr || stdout || `exit code ${result.status}`;
+    console.error(`[apm] pm2 ${args.join(" ")} \u5931\u8D25: ${detail}`);
+    process.exit(result.status ?? 1);
+  }
+}
+function runPm2Json(args) {
+  let pm2Bin;
+  try {
+    pm2Bin = resolvePm2Bin();
+  } catch {
+    return "[]";
+  }
+  const result = spawnSync2(process.execPath, [pm2Bin, ...args], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.status !== 0) return "[]";
+  return result.stdout?.toString() ?? "[]";
+}
+function isPm2ConnectOnline() {
+  try {
+    const raw = runPm2Json(["jlist"]);
+    const list = JSON.parse(raw);
+    return list.some(
+      (app) => app.name === PM2_APP_NAME && (app.pm2_env?.status === "online" || app.pm2_env?.status === "launching")
+    );
+  } catch {
+    return false;
+  }
+}
+function assertConnectNotRunning() {
+  pruneStaleConnectLock();
+  const lock = readConnectLock();
+  if (lock && isProcessAlive(lock.pid)) {
+    console.error(
+      `[apm] \u5DF2\u6709 apm connect \u5728\u8FD0\u884C (pid=${lock.pid}, mode=${lock.mode})\uFF0C\u8BF7\u5148\u505C\u6B62\u540E\u518D\u542F\u52A8`
+    );
+    process.exit(1);
+  }
+  if (isPm2ConnectOnline()) {
+    console.error(
+      "[apm] \u5DF2\u6709 apm connect \u5B88\u62A4\u8FDB\u7A0B\u5728\u8FD0\u884C\uFF0C\u8BF7\u5148\u6267\u884C apm daemon stop"
+    );
+    process.exit(1);
+  }
+}
+function resolveRuntimePaths() {
+  return {
+    apmScript: resolveApmEntryPath(),
+    nodePath: process.execPath
+  };
+}
+function reexecConnectWithResolvedPath(options) {
+  const apmScript = resolveApmEntryPath();
+  const args = [apmScript, "connect"];
+  const server = options.server?.trim();
+  if (server) {
+    args.push("--server", server);
+  }
+  const result = spawnSync2(process.execPath, args, { stdio: "inherit" });
+  if (result.error) {
+    console.error("[apm] \u91CD\u542F connect \u5931\u8D25:", result.error.message);
+    process.exit(1);
+  }
+  process.exit(result.status ?? 0);
+}
+async function handleConnectAfterUpdate(options) {
+  console.log("[apm] \u66F4\u65B0\u5B8C\u6210\uFF0C\u6B63\u5728\u4EE5\u65B0\u7248\u672C\u91CD\u65B0\u8FDE\u63A5\u2026");
+  await prepareEcosystem(options.server);
+  if (isRunningUnderPm2()) {
+    runPm2(["startOrRestart", PM2_ECOSYSTEM_PATH, "--update-env"], {
+      inherit: true
+    });
+    console.log("[apm] \u5DF2\u901A\u77E5 PM2 \u4F7F\u7528\u65B0\u7248\u672C\u91CD\u542F connect");
+    process.exit(0);
+  }
+  reexecConnectWithResolvedPath(options);
+}
+async function resolveBaseUrl(server) {
+  if (server?.trim()) {
+    return server.trim().replace(/\/+$/, "");
+  }
+  const cfg = await tryReadApmConfig();
+  return cfg?.baseUrl;
+}
+function writeEcosystemFile(options) {
+  mkdirSync7(APM_CONFIG_DIR, { recursive: true });
+  const ecosystem = buildConnectPm2Ecosystem(options);
+  writeFileSync13(
+    PM2_ECOSYSTEM_PATH,
+    formatConnectPm2EcosystemFile(ecosystem),
+    "utf8"
+  );
+}
+async function prepareEcosystem(server) {
+  await ensureLoggedConfig();
+  const cfg = await ensureApmConfig();
+  const { apmScript, nodePath } = resolveRuntimePaths();
+  const connectArgs = resolveConnectArgs(server);
+  const baseUrl = await resolveBaseUrl(server);
+  writeEcosystemFile({
+    apmScript,
+    nodePath,
+    connectArgs,
+    baseUrl
+  });
+  return cfg;
+}
+async function runDaemonStart(options) {
+  assertConnectNotRunning();
+  await runUpdate();
+  const cfg = await prepareEcosystem(options.server);
+  runPm2(["start", PM2_ECOSYSTEM_PATH, "--update-env"], { inherit: true });
+  console.log(
+    `[apm] ${PM2_APP_NAME} \u5DF2\u7531 PM2 \u542F\u52A8\uFF08server=${options.server?.trim() || cfg.baseUrl}\uFF09`
+  );
+  if (options.follow) {
+    console.log(
+      "[apm] \u6B63\u5728\u8DDF\u8E2A\u65E5\u5FD7\uFF08Ctrl+C \u4EC5\u9000\u51FA\u65E5\u5FD7\u67E5\u770B\uFF0C\u5B88\u62A4\u8FDB\u7A0B\u7EE7\u7EED\u8FD0\u884C\uFF09"
+    );
+    runDaemonLogs({ follow: true });
+    return;
+  }
+  console.log("[apm] \u67E5\u770B\u72B6\u6001: apm daemon status");
+  console.log("[apm] \u67E5\u770B\u65E5\u5FD7: apm daemon logs -f");
+  console.log("[apm] \u505C\u6B62: apm daemon stop");
+}
+async function runDaemonStop() {
+  runPm2(["stop", PM2_APP_NAME], { inherit: true });
+  forceReleaseConnectLock();
+  console.log(`[apm] ${PM2_APP_NAME} \u5DF2\u505C\u6B62`);
+}
+async function runDaemonRestart(options) {
+  pruneStaleConnectLock();
+  const lock = readConnectLock();
+  if (lock && isProcessAlive(lock.pid) && !isPm2ConnectOnline()) {
+    console.error(
+      `[apm] \u5DF2\u6709\u524D\u53F0 apm connect \u5728\u8FD0\u884C (pid=${lock.pid})\uFF0C\u8BF7\u5148\u505C\u6B62\u540E\u518D\u542F\u52A8\u5B88\u62A4\u8FDB\u7A0B`
+    );
+    process.exit(1);
+  }
+  await runUpdate();
+  await prepareEcosystem(options.server);
+  runPm2(["startOrRestart", PM2_ECOSYSTEM_PATH, "--update-env"], {
+    inherit: true
+  });
+  console.log(`[apm] ${PM2_APP_NAME} \u5DF2\u91CD\u542F`);
+}
+async function runDaemonDelete() {
+  runPm2(["delete", PM2_APP_NAME], { inherit: true });
+  forceReleaseConnectLock();
+  console.log(`[apm] ${PM2_APP_NAME} \u5DF2\u4ECE PM2 \u79FB\u9664`);
+}
+async function runDaemonStatus() {
+  runPm2(["describe", PM2_APP_NAME], { inherit: true });
+}
+async function runDaemonLogs(options) {
+  const args = ["logs", PM2_APP_NAME, "--lines", String(options.lines ?? 100)];
+  if (!options.follow) {
+    args.push("--nostream");
+  }
+  runPm2(args, { inherit: true });
+}
+
 // src/commands/connect.ts
 var HEARTBEAT_MS = 3e4;
 async function updateMessageStatus(cfg, messageId, status) {
@@ -3401,23 +3758,10 @@ function startHeartbeat(ws, clientMachineId) {
   const timer = setInterval(send, HEARTBEAT_MS);
   return () => clearInterval(timer);
 }
-function reexecConnect(options) {
-  const args = [process.argv[1], "connect"];
-  const server = options.server?.trim();
-  if (server) {
-    args.push("--server", server);
-  }
-  const result = spawnSync2(process.execPath, args, { stdio: "inherit" });
-  if (result.error) {
-    console.error("[apm] \u91CD\u542F connect \u5931\u8D25:", result.error.message);
-    process.exit(1);
-  }
-  process.exit(result.status ?? 0);
-}
 async function runConnect(options) {
   const { didUpdate } = await runUpdate();
   if (didUpdate) {
-    reexecConnect(options);
+    await handleConnectAfterUpdate(options);
   }
   const cfg = await ensureLoggedConfig();
   if (options.server?.trim()) {
@@ -3428,6 +3772,9 @@ async function runConnect(options) {
     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) => {
@@ -3459,6 +3806,7 @@ async function runConnect(options) {
         ]);
       } catch {
       }
+      releaseConnectLock();
       resolve5();
       process.exit(code);
     };
@@ -3615,20 +3963,20 @@ async function runCreatePr(options) {
 import { spawnSync as spawnSync5 } from "node:child_process";
 
 // src/commands/deploy/internal/apm-config.ts
-import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync15, readFileSync as readFileSync12 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join14, resolve as resolve4 } from "node:path";
+import { join as join16, resolve as resolve4 } from "node:path";
 function loadApmConfig(options) {
   const p = resolve4(
     process.cwd(),
     options?.configPath ?? resolve4(workspaceApmDir(), "apm.config.json")
   );
-  if (!existsSync13(p)) {
+  if (!existsSync15(p)) {
     console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
     process.exit(1);
   }
   try {
-    const raw = readFileSync11(p, "utf8");
+    const raw = readFileSync12(p, "utf8");
     return JSON.parse(raw);
   } catch (e) {
     console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
@@ -3812,12 +4160,12 @@ function readMavenLocalRepoFromEnv(env = process.env) {
   return null;
 }
 function readMavenLocalRepoFromSettings() {
-  const settingsPath = join14(homedir2(), ".m2", "settings.xml");
-  if (!existsSync13(settingsPath)) {
+  const settingsPath = join16(homedir2(), ".m2", "settings.xml");
+  if (!existsSync15(settingsPath)) {
     return null;
   }
   try {
-    const xml = readFileSync11(settingsPath, "utf8");
+    const xml = readFileSync12(settingsPath, "utf8");
     const match = xml.match(
       /<localRepository>\s*([^<]+?)\s*<\/localRepository>/
     );
@@ -3848,7 +4196,7 @@ function resolveMavenLocalRepoWithSource() {
     };
   }
   return {
-    path: join14(homedir2(), ".m2", "repository"),
+    path: join16(homedir2(), ".m2", "repository"),
     source: "default",
     sourceDetail: "~/.m2/repository"
   };
@@ -3918,18 +4266,18 @@ function posixBasename(p) {
 }
 
 // src/commands/deploy/internal/wisdom-auto-deploy.ts
-import { existsSync as existsSync15, readFileSync as readFileSync13 } from "node:fs";
+import { existsSync as existsSync17, readFileSync as readFileSync14 } from "node:fs";
 import path3 from "node:path";
 import { spawnSync as spawnSync4 } from "node:child_process";
 
 // src/commands/deploy/internal/wisdom-backend-deploy.ts
 import {
-  existsSync as existsSync14,
-  mkdirSync as mkdirSync6,
+  existsSync as existsSync16,
+  mkdirSync as mkdirSync8,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync12,
+  readFileSync as readFileSync13,
   statSync as statSync5,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync14
 } from "node:fs";
 import { spawnSync as spawnSync3 } from "node:child_process";
 import path2 from "node:path";
@@ -4136,15 +4484,15 @@ function fileSignature(filePath) {
 }
 function loadManifest4() {
   const manifestPath2 = manifestFilePath();
-  if (!existsSync14(manifestPath2)) {
+  if (!existsSync16(manifestPath2)) {
     return {};
   }
-  return JSON.parse(readFileSync12(manifestPath2, "utf8"));
+  return JSON.parse(readFileSync13(manifestPath2, "utf8"));
 }
 function saveManifest4(manifest) {
   const dir = deployCacheDir();
-  mkdirSync6(dir, { recursive: true });
-  writeFileSync12(manifestFilePath(), JSON.stringify(manifest, null, 2), "utf8");
+  mkdirSync8(dir, { recursive: true });
+  writeFileSync14(manifestFilePath(), JSON.stringify(manifest, null, 2), "utf8");
 }
 function isProjectLibJar(jarName) {
   return jarName.startsWith("jeecg-");
@@ -4200,12 +4548,12 @@ function updateManifestEntries(manifest, entries, projectRoot) {
 }
 async function createUpdatePackage(entries, packageName) {
   const dir = deployCacheDir();
-  mkdirSync6(dir, { recursive: true });
+  mkdirSync8(dir, { recursive: true });
   const zipPath = path2.join(dir, packageName);
   log(`\u521B\u5EFA\u66F4\u65B0\u5305: ${path2.basename(zipPath)}\uFF08${entries.length} \u4E2A\u6587\u4EF6\uFF09`);
   const zip = new JSZip2();
   for (const entry of entries) {
-    const content = readFileSync12(entry.path);
+    const content = readFileSync13(entry.path);
     zip.file(entry.arcname, content);
     log(`  \u6253\u5305: ${entry.arcname} (${entry.reason})`);
   }
@@ -4214,7 +4562,7 @@ async function createUpdatePackage(entries, packageName) {
     compression: "DEFLATE",
     compressionOptions: { level: 6 }
   });
-  writeFileSync12(zipPath, buffer);
+  writeFileSync14(zipPath, buffer);
   return zipPath;
 }
 function getMvnExecutable() {
@@ -4263,11 +4611,11 @@ function runMavenBuild(projectRoot, mavenLocalRepo, repoSource) {
 }
 function locateLibDir(projectRoot) {
   const targetDir = getTargetDir(projectRoot);
-  if (!existsSync14(targetDir)) {
+  if (!existsSync16(targetDir)) {
     fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
   }
   const libDir = path2.join(targetDir, "lib");
-  if (!existsSync14(libDir) || !statSync5(libDir).isDirectory()) {
+  if (!existsSync16(libDir) || !statSync5(libDir).isDirectory()) {
     fail(`lib \u76EE\u5F55\u4E0D\u5B58\u5728: ${libDir}`);
   }
   const libJars = readdirSync5(libDir).filter((name) => name.endsWith(".jar"));
@@ -4279,7 +4627,7 @@ function locateLibDir(projectRoot) {
 }
 function locateMainJar(projectRoot) {
   const targetDir = getTargetDir(projectRoot);
-  if (!existsSync14(targetDir)) {
+  if (!existsSync16(targetDir)) {
     fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
   }
   const jarFiles = readdirSync5(targetDir).filter((name) => name.endsWith(".jar") && !name.endsWith(".jar.original")).map((name) => path2.join(targetDir, name)).sort((a, b) => statSync5(b).mtimeMs - statSync5(a).mtimeMs);
@@ -4698,15 +5046,15 @@ function isWisdomLegacyDeploy(cfg) {
   return !hasNewFrontend && !hasNewBackend;
 }
 function detectWisdomProjectType(cwd) {
-  return existsSync15(path3.join(cwd, "package.json")) ? "frontend" : "backend";
+  return existsSync17(path3.join(cwd, "package.json")) ? "frontend" : "backend";
 }
 function readPackageScripts(cwd) {
   const pkgPath = path3.join(cwd, "package.json");
-  if (!existsSync15(pkgPath)) {
+  if (!existsSync17(pkgPath)) {
     return {};
   }
   try {
-    const raw = readFileSync13(pkgPath, "utf8");
+    const raw = readFileSync14(pkgPath, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.scripts ?? {};
   } catch {
@@ -4816,7 +5164,7 @@ import path7 from "node:path";
 import Docker from "dockerode";
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/connection-options.ts
-import { existsSync as existsSync16, readFileSync as readFileSync14 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync15 } from "node:fs";
 import path4 from "node:path";
 function asOptionalTlsBuffer(value) {
   if (typeof value !== "string") {
@@ -4828,8 +5176,8 @@ function asOptionalTlsBuffer(value) {
   if (normalized === "") {
     return void 0;
   }
-  if (existsSync16(normalized)) {
-    return readFileSync14(normalized);
+  if (existsSync18(normalized)) {
+    return readFileSync15(normalized);
   }
   const looksLikePath = /[\\/]/.test(normalized) || normalized.endsWith(".pem");
   if (looksLikePath) {
@@ -5039,7 +5387,7 @@ var DockerodeClient = class {
 var createDockerodeClient = (config) => new DockerodeClient(config);
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/env.ts
-import { existsSync as existsSync17, readFileSync as readFileSync15, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync16, statSync as statSync6 } from "node:fs";
 import path5 from "node:path";
 function stripSurroundingQuotes(value) {
   const t = value.trim();
@@ -5056,10 +5404,10 @@ function loadEnvFromFile(envFilePath) {
     return {};
   }
   const targetPath = path5.resolve(envFilePath);
-  if (!existsSync17(targetPath) || !statSync6(targetPath).isFile()) {
+  if (!existsSync19(targetPath) || !statSync6(targetPath).isFile()) {
     return {};
   }
-  const raw = readFileSync15(targetPath, "utf-8");
+  const raw = readFileSync16(targetPath, "utf-8");
   const result = {};
   for (const line of raw.split(/\r?\n/)) {
     const normalized = line.trim();
@@ -5230,12 +5578,12 @@ function dockerPushImage(params, cwd) {
 }
 
 // src/commands/deploy/internal/backend-deploy/resolve-dockerfile.ts
-import { existsSync as existsSync18 } from "node:fs";
+import { existsSync as existsSync20 } from "node:fs";
 import path6 from "node:path";
 function resolveDockerBuildPaths(cwd) {
   const dockerfilePath = path6.join(cwd, "Dockerfile");
   Logger.info(`\u67E5\u627EDockerfile\u6587\u4EF6\uFF0C\u8DEF\u5F84: ${dockerfilePath}`);
-  if (!existsSync18(dockerfilePath)) {
+  if (!existsSync20(dockerfilePath)) {
     throw new Error(`Dockerfile \u4E0D\u5B58\u5728\uFF1A${dockerfilePath}`);
   }
   Logger.info("\u2713 Dockerfile \u5B58\u5728");
@@ -5785,20 +6133,65 @@ function buildProgram() {
   });
   program.command("connect").description(
     "\u8FDE\u63A5\u5E73\u53F0 WebSocket\uFF08/ws/agent\uFF09\uFF0C\u7EF4\u6301\u5FC3\u8DF3\u5E76\u5904\u7406\u4E0B\u884C message\uFF08TYPING \u2192 Cursor \u2192 SUCCESS/FAILED\uFF09\uFF1B\u542F\u52A8\u524D\u81EA\u52A8 apm update \u5230\u5F53\u524D\u5927\u7248\u672C\u6700\u65B0\u7248"
-  ).option("--server <url>", "API \u6839\u5730\u5740\uFF0C\u8986\u76D6 config \u4E2D\u7684 baseUrl").action(async (opts) => {
-    await runConnect(opts);
+  ).option("--server <url>", "API \u6839\u5730\u5740\uFF0C\u8986\u76D6 config \u4E2D\u7684 baseUrl").option(
+    "--daemon",
+    "\u540E\u53F0\u5B88\u62A4\u8FD0\u884C\uFF08\u5185\u7F6E PM2\uFF0C\u65AD\u7EBF\u6216\u9000\u51FA\u540E\u81EA\u52A8\u91CD\u542F\uFF1B\u63A8\u8350\u7528\u4E8E\u957F\u671F\u5728\u7EBF\uFF09"
+  ).option("-f, --follow", "\u4E0E --daemon \u5408\u7528\uFF1A\u542F\u52A8\u540E\u5728\u5F53\u524D\u7EC8\u7AEF\u5B9E\u65F6\u8DDF\u8E2A\u65E5\u5FD7").action(
+    async (opts) => {
+      if (opts.follow && !opts.daemon) {
+        console.error("[apm] --follow \u4EC5\u53EF\u4E0E --daemon \u540C\u65F6\u4F7F\u7528");
+        process.exit(1);
+      }
+      if (opts.daemon === true) {
+        await runDaemonStart({ server: opts.server, follow: opts.follow });
+        return;
+      }
+      await runConnect({ server: opts.server });
+    }
+  );
+  const daemon = program.command("daemon").description(
+    "\u540E\u53F0 connect \u8FD0\u7EF4\u547D\u4EE4\uFF08\u542F\u52A8\u8BF7\u4F18\u5148\u4F7F\u7528 apm connect --daemon\uFF1B\u6B64\u5904\u4F9B status/logs/stop \u7B49\uFF09"
+  );
+  daemon.command("start").description("\u542F\u52A8\u540E\u53F0 connect\uFF08\u7B49\u6548 apm connect --daemon\uFF09").option("--server <url>", "API \u6839\u5730\u5740\uFF0C\u8986\u76D6 config \u4E2D\u7684 baseUrl").option("-f, --follow", "\u542F\u52A8\u540E\u5728\u5F53\u524D\u7EC8\u7AEF\u5B9E\u65F6\u8DDF\u8E2A\u65E5\u5FD7").action(async (opts) => {
+    await runDaemonStart({ server: opts.server, follow: opts.follow });
+  });
+  daemon.command("stop").description("\u505C\u6B62 PM2 \u5B88\u62A4\u7684 apm connect").action(async () => {
+    await runDaemonStop();
+  });
+  daemon.command("restart").description("\u91CD\u542F PM2 \u5B88\u62A4\u7684 apm connect\uFF08\u672A\u542F\u52A8\u65F6\u4F1A\u76F4\u63A5\u542F\u52A8\uFF09").option("--server <url>", "API \u6839\u5730\u5740\uFF0C\u8986\u76D6 config \u4E2D\u7684 baseUrl").action(async (opts) => {
+    await runDaemonRestart(opts);
+  });
+  daemon.command("delete").description("\u4ECE PM2 \u4E2D\u79FB\u9664 apm connect \u8FDB\u7A0B").action(async () => {
+    await runDaemonDelete();
+  });
+  daemon.command("status").description("\u67E5\u770B PM2 \u5B88\u62A4\u7684 apm connect \u72B6\u6001").action(async () => {
+    await runDaemonStatus();
   });
-  program.command("branch").description("\u5207\u6362\u6216\u521B\u5EFA\u4F1A\u8BDD\u5206\u652F feat/session-<sessionId>").argument("<sessionId>", "\u6C9F\u901A\u7FA4 ID").option(
+  daemon.command("logs").description("\u67E5\u770B PM2 \u5B88\u62A4\u7684 apm connect \u65E5\u5FD7").option("-f, --follow", "\u6301\u7EED\u8DDF\u8E2A\u65E5\u5FD7").option("-n, --lines <n>", "\u663E\u793A\u884C\u6570", "100").action(async (opts) => {
+    const lines = Number.parseInt(opts.lines ?? "100", 10);
+    await runDaemonLogs({
+      follow: opts.follow === true,
+      lines: Number.isFinite(lines) && lines > 0 ? lines : 100
+    });
+  });
+  const branch = program.command("branch").description("\u4F1A\u8BDD\u5206\u652F feat/session-<sessionId>");
+  branch.command("prune").description(
+    "\u6E05\u7406\u672C\u5730\u4E0E\u8FDC\u7A0B feat/session-* \u5206\u652F\uFF08\u7C7B\u4F3C git fetch --prune\uFF09\uFF1A\u6C9F\u901A\u7FA4\u4E0D\u5728\u4EFB\u52A1\u5217\u8868\u4E2D\uFF0C\u6216\u5173\u8054\u4EFB\u52A1\u5DF2\u5B8C\u6210\u65F6\u5220\u9664"
+  ).option("--dry-run", "\u4EC5\u5217\u51FA\u5C06\u88AB\u5220\u9664\u7684\u5206\u652F\uFF0C\u4E0D\u5B9E\u9645\u6267\u884C").option(
+    "-A, --all",
+    "\u5305\u542B\u4EC5\u5B58\u5728\u4E8E\u8FDC\u7A0B\u3001\u672C\u5730\u672A checkout \u7684 feat/session-* \u5206\u652F\uFF08\u9ED8\u8BA4\u4EC5\u5904\u7406\u672C\u5730\u5206\u652F\uFF09"
+  ).action(async (opts) => {
+    await runCleanBranches({
+      dryRun: opts.dryRun,
+      includeRemote: opts.all
+    });
+  });
+  branch.description("\u5207\u6362\u6216\u521B\u5EFA\u4F1A\u8BDD\u5206\u652F feat/session-<sessionId>").argument("<sessionId>", "\u6C9F\u901A\u7FA4 ID").option(
     "-m, --message <text>",
     "\u5DF2\u5728\u76EE\u6807\u5206\u652F\u4E14\u9700\u63D0\u4EA4\u672C\u5730\u6539\u52A8\u65F6\u4F7F\u7528\u7684\u63D0\u4EA4\u8BF4\u660E"
   ).action(async (sessionId, opts) => {
     await runBranch(sessionId, { message: opts.message });
   });
-  program.command("clean-branches").description(
-    "\u6E05\u7406\u672C\u5730\u4E0E\u8FDC\u7A0B feat/session-* \u5206\u652F\uFF1A\u6C9F\u901A\u7FA4\u4E0D\u5728\u4EFB\u52A1\u5217\u8868\u4E2D\uFF0C\u6216\u5173\u8054\u4EFB\u52A1\u5DF2\u5B8C\u6210\u65F6\u5220\u9664"
-  ).option("--dry-run", "\u4EC5\u5217\u51FA\u5C06\u88AB\u5220\u9664\u7684\u5206\u652F\uFF0C\u4E0D\u5B9E\u9645\u6267\u884C").action(async (opts) => {
-    await runCleanBranches({ dryRun: opts.dryRun });
-  });
   program.command("create-pr").description(
     "\u4E3A\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u7684\u4F1A\u8BDD\u7279\u6027\u5206\u652F\u521B\u5EFA PR\uFF08\u6807\u9898\u81EA\u52A8\u52A0 [AI] \u6807\u8BC6\uFF1B\u8FDC\u7A0B\u521B\u5EFA\u5931\u8D25\u65F6\u5E73\u53F0\u6570\u636E\u56DE\u6EDA\uFF09"
   ).requiredOption("--session <sessionId>", "\u6C9F\u901A\u7FA4 ID").requiredOption("--title <title>", "PR \u6807\u9898").option("--content <content>", "PR \u6B63\u6587\uFF08Markdown\uFF09", "").action(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-project-manage-cli",
-  "version": "6.0.79",
+  "version": "6.0.81",
   "description": "命令行工具：后续用于调用平台后端 API 完成运维与自动化操作",
   "type": "module",
   "private": false,
@@ -44,6 +44,7 @@
     "dockerode": "~5.0.0",
     "ssh2": "~1.16.0",
     "ssh2-sftp-client": "~12.0.1",
-    "jszip": "~3.10.1"
+    "jszip": "~3.10.1",
+    "pm2": "~5.4.3"
   }
 }