ai-project-manage-cli 6.0.82 → 6.0.84

package/dist/index.js

@@ -110,8 +110,8 @@ function toFsPath(inputPath) {
   }
   return `\\\\?\\${normalized}`;
 }
-function normalizeWorkdirPath(path12) {
-  let normalized = path12.trim().replace(/\\/g, "/").normalize("NFC");
+function normalizeWorkdirPath(path13) {
+  let normalized = path13.trim().replace(/\\/g, "/").normalize("NFC");
   if (normalized.startsWith("//?/")) {
     normalized = normalized.slice(4);
   }
@@ -326,9 +326,9 @@ function assertTemplateCopiedToApm(apmDir, workdir) {
     "sessions"
   ];
   for (const item of required) {
-    const path12 = join2(apmDir, item);
-    if (!existsSync(toFsPath(path12))) {
-      throw new Error(`[apm] \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path12}`);
+    const path13 = join2(apmDir, item);
+    if (!existsSync(toFsPath(path13))) {
+      throw new Error(`[apm] \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path13}`);
     }
   }
   const leakedRules = join2(workdir, "rules");
@@ -473,6 +473,10 @@ var requestConfig = {
       method: "DELETE",
       path: "/cli/repository-project-documents"
     }),
+    createTaskDeployment: defineEndpoint({
+      method: "POST",
+      path: "/cli/task-deployments"
+    }),
     updateTaskDeploymentStatus: defineEndpoint({
       method: "PUT",
       path: "/cli/task-deployments/status"
@@ -606,14 +610,14 @@ function projectDocumentLocalPath(apmRoot, documentPath) {
   const normalized = normalizeLocalDocumentPath(documentPath);
   return join4(projectDocumentsDir(apmRoot), ...normalized.split("/"));
 }
-function normalizeLocalDocumentPath(path12) {
-  const trimmed = path12.trim().replace(/\\/g, "/");
+function normalizeLocalDocumentPath(path13) {
+  const trimmed = path13.trim().replace(/\\/g, "/");
   if (!trimmed || trimmed.startsWith("/") || /^[a-zA-Z]:/.test(trimmed)) {
-    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path12}`);
+    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path13}`);
   }
   const segments = trimmed.split("/").filter(Boolean);
   if (segments.some((segment) => segment === ".." || segment === ".")) {
-    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path12}`);
+    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path13}`);
   }
   return segments.join("/");
 }
@@ -664,15 +668,15 @@ function diffManifestPaths(remote, local) {
     (local?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
   );
   const download = [];
-  for (const [path12, hash] of remoteMap) {
-    if (localMap.get(path12) !== hash) {
-      download.push(path12);
+  for (const [path13, hash] of remoteMap) {
+    if (localMap.get(path13) !== hash) {
+      download.push(path13);
     }
   }
   const deleteLocal = [];
-  for (const path12 of localMap.keys()) {
-    if (!remoteMap.has(path12)) {
-      deleteLocal.push(path12);
+  for (const path13 of localMap.keys()) {
+    if (!remoteMap.has(path13)) {
+      deleteLocal.push(path13);
     }
   }
   return { download, deleteLocal };
@@ -732,8 +736,8 @@ ${diagnostic ?? ""}`
     }
   }
   let deleted = 0;
-  for (const path12 of deleteLocal) {
-    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path12));
+  for (const path13 of deleteLocal) {
+    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path13));
     if (existsSync2(absPath)) {
       rmSync(absPath, { force: true });
       deleted += 1;
@@ -778,21 +782,21 @@ async function syncRepositoryProjectDocumentsPush(cfg, workdirPath, apmRoot) {
     ])
   );
   let synced = 0;
-  for (const path12 of localPaths) {
-    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path12));
+  for (const path13 of localPaths) {
+    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path13));
     const content = readFileSync3(absPath, "utf8");
     const contentHash = hashLocalFileContent(content);
-    if (remoteHashByPath.get(path12) === contentHash) {
+    if (remoteHashByPath.get(path13) === contentHash) {
       continue;
     }
     await api.cli.upsertRepositoryProjectDocument({
       repositoryId,
-      path: path12,
+      path: path13,
       content,
-      description: remoteDescriptionByPath.get(path12) ?? void 0
+      description: remoteDescriptionByPath.get(path13) ?? void 0
     });
     synced += 1;
-    console.log(`[apm] \u5DF2\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863: ${path12}`);
+    console.log(`[apm] \u5DF2\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863: ${path13}`);
   }
   if (synced === 0) {
     console.log("[apm] \u4ED3\u5E93\u9879\u76EE\u6587\u6863\u65E0\u53D8\u5316\uFF0C\u8DF3\u8FC7\u63A8\u9001");
@@ -1415,13 +1419,13 @@ async function downloadAttachment(cfg, attachmentId) {
   return Buffer.from(await res.arrayBuffer());
 }
 function loadManifest(dir) {
-  const path12 = join6(dir, MANIFEST_FILE2);
-  if (!existsSync4(path12)) {
+  const path13 = join6(dir, MANIFEST_FILE2);
+  if (!existsSync4(path13)) {
     return { version: 1, attachments: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync5(path12, "utf8")
+      readFileSync5(path13, "utf8")
     );
     if (parsed?.version === 1 && parsed.attachments && typeof parsed.attachments === "object") {
       return parsed;
@@ -1502,8 +1506,8 @@ function sanitizeSkillDirName(name) {
 function listBaseSkillDirNames() {
   if (!existsSync5(BASE_SKILLS_TEMPLATE_DIR)) return [];
   return readdirSync3(BASE_SKILLS_TEMPLATE_DIR).filter((name) => {
-    const path12 = join7(BASE_SKILLS_TEMPLATE_DIR, name);
-    return statSync2(path12).isDirectory();
+    const path13 = join7(BASE_SKILLS_TEMPLATE_DIR, name);
+    return statSync2(path13).isDirectory();
   });
 }
 function syncAgentsGuide(apmDir) {
@@ -1515,8 +1519,8 @@ function syncAgentsGuide(apmDir) {
 function listBaseRuleFileNames() {
   if (!existsSync5(BASE_RULES_TEMPLATE_DIR)) return [];
   return readdirSync3(BASE_RULES_TEMPLATE_DIR).filter((name) => {
-    const path12 = join7(BASE_RULES_TEMPLATE_DIR, name);
-    return statSync2(path12).isFile();
+    const path13 = join7(BASE_RULES_TEMPLATE_DIR, name);
+    return statSync2(path13).isFile();
   });
 }
 function syncBaseRules(rulesDir) {
@@ -1579,13 +1583,13 @@ function ruleLocalFileName(ruleName) {
   return `${sanitized}.md`;
 }
 function loadManifest2(rulesDir) {
-  const path12 = join8(rulesDir, MANIFEST_FILE3);
-  if (!existsSync6(toFsPath(path12))) {
+  const path13 = join8(rulesDir, MANIFEST_FILE3);
+  if (!existsSync6(toFsPath(path13))) {
     return { version: 1, rules: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync6(toFsPath(path12), "utf8")
+      readFileSync6(toFsPath(path13), "utf8")
     );
     if (parsed?.version === 1 && parsed.rules && typeof parsed.rules === "object") {
       return parsed;
@@ -2684,12 +2688,12 @@ import { dirname as dirname4, resolve as resolve3 } from "node:path";
 function registryPath(workdir, sessionId) {
   return resolve3(workdir, ".apm", "sessions", sessionId, "cursor-agents.json");
 }
-function readRegistry(path12) {
-  if (!existsSync11(path12)) {
+function readRegistry(path13) {
+  if (!existsSync11(path13)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync9(path12, "utf8"));
+    const parsed = JSON.parse(readFileSync9(path13, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const result = {};
       for (const [key, value] of Object.entries(
@@ -2705,9 +2709,9 @@ function readRegistry(path12) {
   }
   return {};
 }
-function writeRegistry(path12, registry) {
-  mkdirSync5(dirname4(path12), { recursive: true });
-  writeFileSync10(path12, `${JSON.stringify(registry, null, 2)}
+function writeRegistry(path13, registry) {
+  mkdirSync5(dirname4(path13), { recursive: true });
+  writeFileSync10(path13, `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 function loadSessionAgentId(workdir, sessionId, user) {
@@ -2715,19 +2719,19 @@ function loadSessionAgentId(workdir, sessionId, user) {
   return registry[user];
 }
 function saveSessionAgentId(workdir, sessionId, user, agentId) {
-  const path12 = registryPath(workdir, sessionId);
-  const registry = readRegistry(path12);
+  const path13 = registryPath(workdir, sessionId);
+  const registry = readRegistry(path13);
   registry[user] = agentId;
-  writeRegistry(path12, registry);
+  writeRegistry(path13, registry);
 }
 function clearSessionAgentId(workdir, sessionId, user) {
-  const path12 = registryPath(workdir, sessionId);
-  const registry = readRegistry(path12);
+  const path13 = registryPath(workdir, sessionId);
+  const registry = readRegistry(path13);
   if (!(user in registry)) {
     return;
   }
   delete registry[user];
-  writeRegistry(path12, registry);
+  writeRegistry(path13, registry);
 }
 
 // src/commands/connect/cursor-message-log.ts
@@ -3164,13 +3168,13 @@ function manifestPath(apmDir) {
   return join13(apmDir, CLI_VERSION_FILE);
 }
 function loadManifest3(apmDir) {
-  const path12 = toFsPath(manifestPath(apmDir));
-  if (!existsSync12(path12)) {
+  const path13 = toFsPath(manifestPath(apmDir));
+  if (!existsSync12(path13)) {
     return null;
   }
   try {
     const parsed = JSON.parse(
-      readFileSync10(path12, "utf8")
+      readFileSync10(path13, "utf8")
     );
     if (parsed?.version === 1 && typeof parsed.cliVersion === "string" && parsed.cliVersion.trim()) {
       return parsed;
@@ -3935,6 +3939,99 @@ async function runConnect(options) {
   });
 }
 
+// src/commands/create-pr-errors.ts
+import { ApiError as ApiError2 } from "listpage-http";
+function extractMessage(error) {
+  if (error instanceof ApiError2) {
+    return String(error.message ?? "").trim();
+  }
+  if (error instanceof Error) {
+    return error.message.trim();
+  }
+  return String(error).trim();
+}
+function extractHttpStatus(error) {
+  if (error instanceof ApiError2) {
+    return error.httpStatus;
+  }
+  return void 0;
+}
+function buildHints(message, httpStatus) {
+  const hints = [];
+  if (/未配置.*Gitee.*API Key/i.test(message)) {
+    hints.push(
+      "\u8BF7\u5728 APM Web \u2192 \u5BA2\u6237\u673A\u7BA1\u7406 \u2192 \u7F16\u8F91\u5F53\u524D\u5BA2\u6237\u673A \u2192 \u586B\u5199\u300CGitee API Key\u300D\uFF08Gitee \u79C1\u4EBA\u4EE4\u724C\uFF0C\u9700\u6709\u4ED3\u5E93 PR \u6743\u9650\uFF09"
+    );
+  } else if (/未配置.*GitHub.*API Key/i.test(message)) {
+    hints.push(
+      "\u8BF7\u5728 APM Web \u2192 \u5BA2\u6237\u673A\u7BA1\u7406 \u2192 \u7F16\u8F91\u5F53\u524D\u5BA2\u6237\u673A \u2192 \u586B\u5199\u300CGithub API Key\u300D\uFF08GitHub Personal Access Token\uFF0C\u9700\u6709 repo \u6743\u9650\uFF09"
+    );
+  } else if (httpStatus === 401 || /access token does not exist/i.test(message) || /bad credentials/i.test(message) || /Git 平台返回 401|认证失败 \(401\)/i.test(message)) {
+    hints.push(
+      "Git \u5E73\u53F0 Token \u65E0\u6548\u6216\u5DF2\u8FC7\u671F\uFF1A\u8BF7\u5728 Gitee/GitHub \u91CD\u65B0\u751F\u6210\u79C1\u4EBA\u4EE4\u724C\uFF0C\u5E76\u66F4\u65B0\u5230 APM\u300C\u5BA2\u6237\u673A\u7BA1\u7406\u300D"
+    );
+  }
+  if (/未绑定仓库|未关联仓库|选择关联仓库/i.test(message)) {
+    hints.push("\u5728 APM Web \u2192 \u5DE5\u4F5C\u76EE\u5F55 \u2192 \u4E3A\u5F53\u524D\u8DEF\u5F84\u5173\u8054\u5BF9\u5E94 Git \u4ED3\u5E93");
+  }
+  if (/路径.*不匹配|尚未登记任何工作目录/i.test(message)) {
+    hints.push(
+      "\u5728 APM Web \u2192 \u5DE5\u4F5C\u76EE\u5F55 \u2192 \u767B\u8BB0\u5F53\u524D\u9879\u76EE\u8DEF\u5F84\uFF08\u9700\u4E0E apm create-pr \u6267\u884C\u65F6\u7684 cwd \u4E00\u81F4\uFF09"
+    );
+  }
+  if (/no commits between|分支不存在|branch.*not found|找不到.*分支/i.test(
+    message
+  )) {
+    hints.push(
+      "\u7279\u6027\u5206\u652F\u53EF\u80FD\u672A\u63A8\u9001\uFF1A\u5148\u6267\u884C apm branch <sessionId> \u521B\u5EFA\u5206\u652F\u5E76 push\uFF0C\u518D\u91CD\u8BD5 create-pr"
+    );
+  }
+  if (/pull request already exists|已存在.*pull/i.test(message)) {
+    hints.push("\u8BE5\u5206\u652F\u53EF\u80FD\u5DF2\u6709\u5F00\u542F\u7684 PR\uFF0C\u8BF7\u5230 Git \u5E73\u53F0\u6216 APM \u4F1A\u8BDD\u8BE6\u60C5\u67E5\u770B");
+  }
+  if (/403|无权限|forbidden/i.test(message)) {
+    hints.push("\u786E\u8BA4 Token \u5BF9\u76EE\u6807\u4ED3\u5E93\u6709\u521B\u5EFA Pull Request \u7684\u6743\u9650");
+  }
+  if (hints.length === 0) {
+    hints.push(
+      "\u82E5\u65E0\u6CD5\u81EA\u884C\u6392\u67E5\uFF0C\u8BF7\u5728\u4F1A\u8BDD\u4E2D @\u9879\u76EE\u7ECF\u7406\uFF0C\u5E76\u63D0\u4F9B\u4E0A\u8FF0\u4F1A\u8BDD ID \u4E0E\u5DE5\u4F5C\u76EE\u5F55"
+    );
+  }
+  return hints;
+}
+function formatCreatePrErrorLines(error, context) {
+  const message = extractMessage(error);
+  const httpStatus = extractHttpStatus(error);
+  const headBranch = `feat/session-${context.sessionId}`;
+  const lines = [
+    "[apm] \u521B\u5EFA PR \u5931\u8D25",
+    "",
+    `\u4F1A\u8BDD ID: ${context.sessionId}`,
+    `\u5DE5\u4F5C\u76EE\u5F55: ${context.workdir}`,
+    `\u7279\u6027\u5206\u652F: ${headBranch}`
+  ];
+  if (context.clientMachineId) {
+    lines.push(`\u5BA2\u6237\u673A ID: ${context.clientMachineId}`);
+  }
+  lines.push("", "\u539F\u56E0:", message || "(\u672A\u77E5\u9519\u8BEF)");
+  const hints = buildHints(message, httpStatus);
+  if (hints.length > 0) {
+    lines.push("", "\u5EFA\u8BAE:");
+    hints.forEach((hint, index) => {
+      lines.push(`${index + 1}. ${hint}`);
+    });
+  }
+  if (httpStatus !== void 0) {
+    lines.push("", `HTTP \u72B6\u6001: ${httpStatus}`);
+  }
+  return lines;
+}
+function printCreatePrError(error, context) {
+  for (const line of formatCreatePrErrorLines(error, context)) {
+    console.error(line);
+  }
+}
+
 // src/commands/create-pr.ts
 async function runCreatePr(options) {
   const sessionId = options.sessionId.trim();
@@ -3950,17 +4047,27 @@ async function runCreatePr(options) {
   const cfg = await ensureLoggedConfig();
   const api = createApmApiClient(cfg);
   const workdir = resolveWorkdirPath(options.cwd ?? process.cwd());
-  const pr = await api.cli.createPullRequest({
-    sessionId,
-    workdir,
-    title,
-    content: options.content ?? ""
-  });
-  console.log(`[apm] PR \u5DF2\u5C31\u7EEA #${pr.number} (${pr.state}): ${pr.url}`);
+  try {
+    const pr = await api.cli.createPullRequest({
+      sessionId,
+      workdir,
+      title,
+      content: options.content ?? ""
+    });
+    console.log(`[apm] PR \u5DF2\u5C31\u7EEA #${pr.number} (${pr.state}): ${pr.url}`);
+  } catch (error) {
+    printCreatePrError(error, {
+      sessionId,
+      workdir,
+      clientMachineId: resolveClientMachineId(cfg)
+    });
+    process.exit(1);
+  }
 }
 
-// src/commands/deploy/deploy.ts
+// src/commands/deploy/deploy-execute.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
+import path4 from "node:path";
 
 // src/commands/deploy/internal/apm-config.ts
 import { existsSync as existsSync15, readFileSync as readFileSync12 } from "node:fs";
@@ -4152,9 +4259,9 @@ function readMavenLocalRepoFromEnv(env = process.env) {
   }
   const mavenOpts = readEnvVar(env, "MAVEN_OPTS")?.trim();
   if (mavenOpts) {
-    const path12 = readMavenLocalRepoFromMavenOpts(mavenOpts, env);
-    if (path12) {
-      return { path: path12, key: "MAVEN_OPTS" };
+    const path13 = readMavenLocalRepoFromMavenOpts(mavenOpts, env);
+    if (path13) {
+      return { path: path13, key: "MAVEN_OPTS" };
     }
   }
   return null;
@@ -4287,19 +4394,18 @@ function formatWisdomFrontendDeployNotConfiguredLines(env, packageJsonPath) {
     "[apm] \u82E5\u672C\u9879\u76EE\u4E0D\u652F\u6301\u81EA\u52A8\u5316\u90E8\u7F72\uFF0C\u5C5E\u6B63\u5E38\u60C5\u51B5\uFF0C\u53EF\u8DF3\u8FC7\u90E8\u7F72"
   ];
 }
-function printDeployNotConfiguredHint(env, deployCommands) {
-  for (const line of formatDeployNotConfiguredLines(env, deployCommands)) {
-    console.error(line);
-  }
-}
-function printWisdomFrontendDeployNotConfiguredHint(env, packageJsonPath) {
-  for (const line of formatWisdomFrontendDeployNotConfiguredLines(
-    env,
-    packageJsonPath
-  )) {
-    console.error(line);
+
+// src/commands/deploy/deploy-errors.ts
+var DeployExecutionError = class extends Error {
+  exitCode;
+  output;
+  constructor(message, exitCode, output = "") {
+    super(message);
+    this.name = "DeployExecutionError";
+    this.exitCode = exitCode;
+    this.output = output;
   }
-}
+};
 
 // src/commands/deploy/internal/wisdom-auto-deploy.ts
 import { existsSync as existsSync17, readFileSync as readFileSync14 } from "node:fs";
@@ -5105,19 +5211,33 @@ function resolveFrontendDeployCommand(env, cwd) {
   }
   return null;
 }
-function runShellCommand2(command, cwd) {
+function runShellCommand2(command, cwd, captureOutput) {
   const result = spawnSync4(command, {
     cwd,
-    stdio: "inherit",
     shell: true,
-    env: process.env
+    env: process.env,
+    encoding: "utf8",
+    stdio: captureOutput ? ["inherit", "pipe", "pipe"] : "inherit"
   });
+  const stdout = captureOutput ? String(result.stdout ?? "") : "";
+  const stderr = captureOutput ? String(result.stderr ?? "") : "";
+  const output = [stdout, stderr].filter(Boolean).join("\n");
+  if (captureOutput) {
+    if (stdout) process.stdout.write(stdout);
+    if (stderr) process.stderr.write(stderr);
+  }
   if (result.status !== 0) {
-    process.exit(result.status ?? 1);
+    throw new DeployExecutionError(
+      `\u90E8\u7F72\u547D\u4EE4\u9000\u51FA\u7801 ${result.status ?? "unknown"}: ${command}`,
+      result.status ?? 1,
+      output
+    );
   }
+  return output;
 }
 async function runWisdomAutoDeploy(options) {
   const cwd = path3.resolve(options.cwd ?? process.cwd());
+  const captureOutput = options.captureOutput ?? false;
   const projectType = detectWisdomProjectType(cwd);
   console.error(
     `[apm] \u533B\u52A1\u5B58\u91CF\u9879\u76EE\u81EA\u52A8\u8BC6\u522B: ${projectType === "frontend" ? "\u524D\u7AEF Vue" : "\u540E\u7AEF Java"}`
@@ -5125,13 +5245,13 @@ async function runWisdomAutoDeploy(options) {
   if (projectType === "frontend") {
     const deployCmd = resolveFrontendDeployCommand(options.env, cwd);
     if (!deployCmd) {
-      printWisdomFrontendDeployNotConfiguredHint(
+      const lines = formatWisdomFrontendDeployNotConfiguredLines(
         options.env,
         path3.join(cwd, "package.json")
       );
-      process.exit(1);
+      throw new DeployExecutionError(lines.join("\n"), 1, lines.join("\n"));
     }
-    runShellCommand2(deployCmd, cwd);
+    runShellCommand2(deployCmd, cwd, captureOutput);
     return { projectType };
   }
   const configPath = options.configPath ?? path3.join(workspaceApmDir(cwd), "apm.config.json");
@@ -5147,63 +5267,229 @@ async function runWisdomAutoDeploy(options) {
   return { projectType };
 }
 
-// src/commands/deploy/deploy.ts
-function runShellCommand3(command, cwd) {
+// src/commands/deploy/deploy-execute.ts
+function runShellCommand3(command, cwd, captureOutput) {
   const result = spawnSync5(command, {
     cwd,
-    stdio: "inherit",
     shell: true,
-    env: process.env
+    env: process.env,
+    encoding: "utf8",
+    stdio: captureOutput ? ["inherit", "pipe", "pipe"] : "inherit"
   });
+  const stdout = captureOutput ? String(result.stdout ?? "") : "";
+  const stderr = captureOutput ? String(result.stderr ?? "") : "";
+  const output = [stdout, stderr].filter(Boolean).join("\n");
+  if (captureOutput) {
+    if (stdout) process.stdout.write(stdout);
+    if (stderr) process.stderr.write(stderr);
+  }
   if (result.status !== 0) {
-    process.exit(result.status ?? 1);
+    throw new DeployExecutionError(
+      `\u90E8\u7F72\u547D\u4EE4\u9000\u51FA\u7801 ${result.status ?? "unknown"}: ${command}`,
+      result.status ?? 1,
+      output
+    );
+  }
+  return output;
+}
+async function executeDeploy(options) {
+  const cwd = path4.resolve(options.cwd ?? process.cwd());
+  const captureOutput = options.captureOutput ?? false;
+  const cfg = loadApmConfig({ configPath: options.configPath });
+  if (isWisdomLegacyDeploy(cfg)) {
+    try {
+      await runWisdomAutoDeploy({
+        env: options.env,
+        cwd,
+        configPath: options.configPath,
+        captureOutput
+      });
+      return "";
+    } catch (error) {
+      if (error instanceof DeployExecutionError) {
+        throw error;
+      }
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new DeployExecutionError(detail, 1);
+    }
+  }
+  const deployCommands = cfg.deploy ?? {};
+  const command = deployCommands[options.env]?.trim();
+  if (!command) {
+    const lines = formatDeployNotConfiguredLines(options.env, deployCommands);
+    throw new DeployExecutionError(lines.join("\n"), 1, lines.join("\n"));
+  }
+  return runShellCommand3(command, cwd, captureOutput);
+}
+function printDeployExecutionError(error) {
+  if (error.output.trim()) {
+    console.error(error.output);
+    return;
+  }
+  console.error(error.message);
+}
+
+// src/commands/deploy/deploy-tracking.ts
+function normalizeDeployEnvironment(env) {
+  const normalized = env.trim().toLowerCase();
+  if (normalized === "test") return "TEST";
+  if (normalized === "online") return "ONLINE";
+  return null;
+}
+async function completeTrackedDeploy(api, deploymentRunId, logSyncer, input) {
+  logSyncer.updateLog(input.log);
+  await logSyncer.flush();
+  await api.cli.completeTaskDeployment({
+    id: deploymentRunId,
+    status: input.status,
+    log: input.log,
+    error: input.error
+  });
+}
+async function runDeployWithBackendTracking(options) {
+  const cfg = await tryReadApmConfig();
+  if (!cfg || !resolveApiKey(cfg)) {
+    console.warn("[apm] \u672A\u767B\u5F55\uFF0C\u8DF3\u8FC7\u540E\u7AEF\u90E8\u7F72\u8BB0\u5F55");
+    await executeDeploy(options);
+    return;
+  }
+  const environment = normalizeDeployEnvironment(options.env);
+  if (!environment) {
+    console.warn(
+      `[apm] \u672A\u77E5\u90E8\u7F72\u73AF\u5883 ${options.env}\uFF0C\u8DF3\u8FC7\u540E\u7AEF\u90E8\u7F72\u8BB0\u5F55\uFF08\u4EC5\u652F\u6301 test/online\uFF09`
+    );
+    await executeDeploy(options);
+    return;
+  }
+  const api = createApmApiClient(cfg);
+  let deploymentRunId;
+  try {
+    const run = await api.cli.createTaskDeployment({
+      sessionId: options.sessionId,
+      environment,
+      workdirPath: options.cwd ?? process.cwd()
+    });
+    deploymentRunId = run.id;
+    console.log(
+      `[apm] \u5DF2\u521B\u5EFA\u90E8\u7F72\u8BB0\u5F55 id=${deploymentRunId} env=${environment}`
+    );
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    console.warn(`[apm] \u521B\u5EFA\u90E8\u7F72\u8BB0\u5F55\u5931\u8D25\uFF0C\u7EE7\u7EED\u90E8\u7F72: ${detail}`);
+    await executeDeploy(options);
+    return;
+  }
+  await api.cli.updateTaskDeploymentStatus({
+    id: deploymentRunId,
+    status: "DEPLOYING"
+  });
+  const logSyncer = createDeployLogSyncer(api, deploymentRunId);
+  const chunks = [];
+  const appendLog = (line) => {
+    if (!line) return;
+    chunks.push(line);
+    logSyncer.updateLog(chunks.join("\n"));
+  };
+  const originalLog = console.log;
+  const originalError = console.error;
+  console.log = (...args) => {
+    appendLog(args.map(String).join(" "));
+    originalLog.apply(console, args);
+  };
+  console.error = (...args) => {
+    appendLog(args.map(String).join(" "));
+    originalError.apply(console, args);
+  };
+  try {
+    const output = await executeDeploy({ ...options, captureOutput: true });
+    if (output.trim()) {
+      appendLog(output);
+    }
+    const log2 = chunks.join("\n");
+    await completeTrackedDeploy(api, deploymentRunId, logSyncer, {
+      status: "SUCCESS",
+      log: log2
+    });
+    console.log(`[apm] deploy success id=${deploymentRunId}`);
+  } catch (error) {
+    const deployError = error instanceof DeployExecutionError ? error : new DeployExecutionError(
+      error instanceof Error ? error.message : String(error),
+      1
+    );
+    if (deployError.output.trim()) {
+      appendLog(deployError.output);
+    } else {
+      appendLog(deployError.message);
+    }
+    const log2 = chunks.join("\n");
+    await completeTrackedDeploy(api, deploymentRunId, logSyncer, {
+      status: "FAILED",
+      log: log2,
+      error: deployError.message
+    });
+    printDeployExecutionError(deployError);
+    process.exit(deployError.exitCode);
+  } finally {
+    console.log = originalLog;
+    console.error = originalError;
+    logSyncer.dispose();
   }
 }
+
+// src/commands/deploy/deploy.ts
 function registerDeployMainCommand(program) {
   program.command("deploy").description(
     "\u7EDF\u4E00\u90E8\u7F72\uFF1A\u533B\u52A1\u5B58\u91CF\u81EA\u52A8\u8BC6\u522B\u524D\u540E\u7AEF\uFF08\u524D\u7AEF\u6309 deploy:<env> \u811A\u672C\uFF1B\u540E\u7AEF test/online \u540C\u4E00\u5957\uFF09\uFF1B\u5176\u4ED6\u9879\u76EE\u6309 deploy.<\u73AF\u5883> \u6267\u884C shell \u547D\u4EE4"
   ).argument("<env>", "\u90E8\u7F72\u73AF\u5883\u540D\uFF08\u5982 test\u3001online\uFF09").option(
     "--config <path>",
     "apm.config.json \u8DEF\u5F84\uFF08\u9ED8\u8BA4 .apm/apm.config.json\uFF09"
-  ).action(async (env, opts) => {
-    const cwd = process.cwd();
-    const cfg = loadApmConfig({ configPath: opts.config });
-    if (isWisdomLegacyDeploy(cfg)) {
-      await runWisdomAutoDeploy({
-        env,
-        cwd,
-        configPath: opts.config
-      });
-      return;
-    }
-    const deployCommands = cfg.deploy ?? {};
-    const command = deployCommands[env]?.trim();
-    if (!command) {
-      printDeployNotConfiguredHint(env, deployCommands);
-      process.exit(1);
+  ).option(
+    "--session <sessionId>",
+    "\u6C9F\u901A\u7FA4 ID\uFF1B\u4F20\u5165\u65F6\u5728\u5E73\u53F0\u521B\u5EFA\u90E8\u7F72\u8BB0\u5F55\u5E76\u540C\u6B65\u65E5\u5FD7"
+  ).action(
+    async (env, opts) => {
+      const cwd = process.cwd();
+      const sessionId = opts.session?.trim();
+      try {
+        if (sessionId) {
+          await runDeployWithBackendTracking({
+            env,
+            cwd,
+            configPath: opts.config,
+            sessionId
+          });
+          return;
+        }
+        await executeDeploy({ env, cwd, configPath: opts.config });
+      } catch (error) {
+        if (error instanceof DeployExecutionError) {
+          printDeployExecutionError(error);
+          process.exit(error.exitCode);
+        }
+        throw error;
+      }
     }
-    runShellCommand3(command, cwd);
-  });
+  );
 }
 
 // src/commands/deploy/backend.ts
-import path8 from "node:path";
+import path9 from "node:path";
 
 // src/commands/deploy/internal/backend-deploy/backend-deploy-workflow.ts
-import path7 from "node:path";
+import path8 from "node:path";
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/client.ts
 import Docker from "dockerode";
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/connection-options.ts
 import { existsSync as existsSync18, readFileSync as readFileSync15 } from "node:fs";
-import path4 from "node:path";
+import path5 from "node:path";
 function asOptionalTlsBuffer(value) {
   if (typeof value !== "string") {
     console.log("tls filepath not exist");
     return void 0;
   }
-  console.log("tls filepath", path4.join(process.cwd(), value));
+  console.log("tls filepath", path5.join(process.cwd(), value));
   const normalized = value.trim();
   if (normalized === "") {
     return void 0;
@@ -5420,7 +5706,7 @@ var createDockerodeClient = (config) => new DockerodeClient(config);
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/env.ts
 import { existsSync as existsSync19, readFileSync as readFileSync16, statSync as statSync6 } from "node:fs";
-import path5 from "node:path";
+import path6 from "node:path";
 function stripSurroundingQuotes(value) {
   const t = value.trim();
   if (t.length >= 2) {
@@ -5435,7 +5721,7 @@ function loadEnvFromFile(envFilePath) {
   if (!envFilePath) {
     return {};
   }
-  const targetPath = path5.resolve(envFilePath);
+  const targetPath = path6.resolve(envFilePath);
   if (!existsSync19(targetPath) || !statSync6(targetPath).isFile()) {
     return {};
   }
@@ -5611,9 +5897,9 @@ function dockerPushImage(params, cwd) {
 
 // src/commands/deploy/internal/backend-deploy/resolve-dockerfile.ts
 import { existsSync as existsSync20 } from "node:fs";
-import path6 from "node:path";
+import path7 from "node:path";
 function resolveDockerBuildPaths(cwd) {
-  const dockerfilePath = path6.join(cwd, "Dockerfile");
+  const dockerfilePath = path7.join(cwd, "Dockerfile");
   Logger.info(`\u67E5\u627EDockerfile\u6587\u4EF6\uFF0C\u8DEF\u5F84: ${dockerfilePath}`);
   if (!existsSync20(dockerfilePath)) {
     throw new Error(`Dockerfile \u4E0D\u5B58\u5728\uFF1A${dockerfilePath}`);
@@ -5670,7 +5956,7 @@ var BackendDeployWorkflow = class {
       serveraddress
     });
     Logger.success("\u8FDC\u7A0B\u62C9\u53D6\u955C\u50CF\u5B8C\u6210");
-    const envFilePath = path7.resolve(cwd, this.params.envFilePath || ".env");
+    const envFilePath = path8.resolve(cwd, this.params.envFilePath || ".env");
     const envObj = loadEnvFromFile(envFilePath);
     if (this.params.dockerNetwork?.trim()) {
       Logger.info(`\u8FDC\u7A0B\u5BB9\u5668\u5C06\u52A0\u5165 Docker \u7F51\u7EDC\uFF1A${this.params.dockerNetwork.trim()}`);
@@ -5710,7 +5996,7 @@ function registerDeployBackendCommands(program) {
       assertDeployImageTag(tag);
       const cfg = loadApmConfig({ configPath: opts.config });
       const fromApm = resolveBackendDeployFromApmConfig(cfg);
-      const dirAbs = path8.resolve(process.cwd(), opts.dir || "servers/api");
+      const dirAbs = path9.resolve(process.cwd(), opts.dir || "servers/api");
       const params = {
         image: fromApm.name,
         tag,
@@ -5741,12 +6027,12 @@ function registerDeployBackendCommands(program) {
 
 // src/commands/deploy/frontend.ts
 import { copyFile, readdir as readdir3, stat } from "node:fs/promises";
-import path10 from "node:path";
+import path11 from "node:path";
 
 // src/commands/deploy/internal/minio.ts
 import { statSync as statSync7 } from "node:fs";
 import { readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
-import path9 from "node:path";
+import path10 from "node:path";
 import * as Minio from "minio";
 var DEFAULT_MAX_FILE_SIZE_MB = 50;
 async function isDirectoryPath(dir) {
@@ -5776,7 +6062,7 @@ async function collectFiles(root) {
       if (name === "." || name === "..") {
         continue;
       }
-      const abs = path9.join(dir, name);
+      const abs = path10.join(dir, name);
       const rel = prefix ? `${prefix}/${name}` : name;
       if (e.isDirectory()) {
         await walk(abs, rel);
@@ -5819,7 +6105,7 @@ var MIME = {
   ".map": "application/json"
 };
 function detectMimeType(filePath) {
-  const ext = path9.extname(filePath).toLowerCase();
+  const ext = path10.extname(filePath).toLowerCase();
   return MIME[ext] ?? "";
 }
 var MinioClient = class {
@@ -5907,7 +6193,7 @@ function artifactObjectKey(namePrefix, branchSegment, relativePath) {
   return `${base}/${branchSegment}/dist/${rel}`;
 }
 async function ensureArtifactRootIndexHtml(root) {
-  const indexHtmlPath = path10.join(root, "index.html");
+  const indexHtmlPath = path11.join(root, "index.html");
   try {
     const st = await stat(indexHtmlPath);
     if (st.isFile()) {
@@ -5924,7 +6210,7 @@ async function ensureArtifactRootIndexHtml(root) {
   }
   const dirNames = entries.filter((e) => e.isDirectory()).map((e) => String(e.name)).sort();
   for (const name of dirNames) {
-    const candidate = path10.join(root, name, "index.html");
+    const candidate = path11.join(root, name, "index.html");
     try {
       const st = await stat(candidate);
       if (!st.isFile()) {
@@ -5935,7 +6221,7 @@ async function ensureArtifactRootIndexHtml(root) {
     }
     await copyFile(candidate, indexHtmlPath);
     console.error(
-      `\u4EA7\u7269\u534F\u8BAE\uFF1A\u5DF2\u5C06 ${path10.join(name, "index.html")} \u590D\u5236\u4E3A\u6839\u76EE\u5F55 index.html`
+      `\u4EA7\u7269\u534F\u8BAE\uFF1A\u5DF2\u5C06 ${path11.join(name, "index.html")} \u590D\u5236\u4E3A\u6839\u76EE\u5F55 index.html`
     );
     return;
   }
@@ -5971,7 +6257,7 @@ function registerDeployFrontendCommands(program) {
         secretKey: settings.secretKey
       });
       const bucket = settings.bucket;
-      const root = path10.resolve(process.cwd(), opts.dir || "apps/web/dist");
+      const root = path11.resolve(process.cwd(), opts.dir || "apps/web/dist");
       if (!await isDirectoryPath(root)) {
         console.error(`\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${root}`);
         process.exit(1);
@@ -6040,7 +6326,7 @@ function registerDeployFrontendCommands(program) {
 }
 
 // src/commands/deploy/sftp.ts
-import path11 from "node:path";
+import path12 from "node:path";
 function registerDeploySftpCommands(program) {
   program.command("deploy-sftp").description(
     "\u5C06\u6307\u5B9A\u76EE\u5F55\u538B\u7F29\u4E3A zip \u540E\u901A\u8FC7 SFTP \u4E0A\u4F20\u5230\u8FDC\u7A0B\u670D\u52A1\u5668\uFF08\u8FDE\u63A5\u4FE1\u606F\u89C1 apm.config.json wisdomDeploy\uFF09"
@@ -6055,7 +6341,7 @@ function registerDeploySftpCommands(program) {
     async (opts) => {
       const cfg = loadApmConfig({ configPath: opts.config });
       const settings = resolveWisdomDeployFromApmConfig(cfg);
-      const root = path11.resolve(process.cwd(), opts.dir || "apps/web/dist");
+      const root = path12.resolve(process.cwd(), opts.dir || "apps/web/dist");
       if (!await isDirectoryPath(root)) {
         console.error(`\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${root}`);
         process.exit(1);

package/package.json

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

package/template/skills/apm-deploy/SKILL.md

@@ -2,7 +2,9 @@
 
 ## 工作流程
 
-在项目根目录执行 `apm deploy <环境名称>`，**以命令执行结果为准**：
+在项目根目录执行 `apm deploy <环境名称> --session <sessionId>`，**以命令执行结果为准**。
+
+**sessionId**：从当前工作项目录 `.apm/sessions/<sessionId>/` 或 `session.yaml` 获取；必须传入 `--session`，平台才会记录部署。
 
 - **成功**：部署完成，在回信中说明测试环境地址或部署结果。
 - **失败且输出含「未配置自动化部署」或「可跳过部署」**：本项目不支持自动化部署，属正常情况；放弃部署，在回信说明已跳过即可，无需修复配置或重试。
@@ -10,5 +12,5 @@
 
 ## 示例
 
-1. 部署测试环境：`apm deploy test`
-2. 部署正式环境：`apm deploy online`
+1. 部署测试环境：`apm deploy test --session <sessionId>`
+2. 部署正式环境：`apm deploy online --session <sessionId>`