ai-project-manage-cli 6.0.106 → 6.0.108-beta.1

package/dist/index.js

@@ -110,8 +110,8 @@ function toFsPath(inputPath) {
   }
   return `\\\\?\\${normalized}`;
 }
-function normalizeWorkdirPath(path13) {
-  let normalized = path13.trim().replace(/\\/g, "/").normalize("NFC");
+function normalizeWorkdirPath(path19) {
+  let normalized = path19.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 path13 = join2(apmDir, item);
-    if (!existsSync(toFsPath(path13))) {
-      throw new Error(`[apm] \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path13}`);
+    const path19 = join2(apmDir, item);
+    if (!existsSync(toFsPath(path19))) {
+      throw new Error(`[apm] \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path19}`);
     }
   }
   const leakedRules = join2(workdir, "rules");
@@ -790,14 +790,14 @@ function projectDocumentLocalPath(apmRoot, documentPath) {
   const normalized = normalizeLocalDocumentPath(documentPath);
   return join4(projectDocumentsDir(apmRoot), ...normalized.split("/"));
 }
-function normalizeLocalDocumentPath(path13) {
-  const trimmed = path13.trim().replace(/\\/g, "/");
+function normalizeLocalDocumentPath(path19) {
+  const trimmed = path19.trim().replace(/\\/g, "/");
   if (!trimmed || trimmed.startsWith("/") || /^[a-zA-Z]:/.test(trimmed)) {
-    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path13}`);
+    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path19}`);
   }
   const segments = trimmed.split("/").filter(Boolean);
   if (segments.some((segment) => segment === ".." || segment === ".")) {
-    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path13}`);
+    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path19}`);
   }
   return segments.join("/");
 }
@@ -848,15 +848,15 @@ function diffManifestPaths(remote, local) {
     (local?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
   );
   const download = [];
-  for (const [path13, hash] of remoteMap) {
-    if (localMap.get(path13) !== hash) {
-      download.push(path13);
+  for (const [path19, hash] of remoteMap) {
+    if (localMap.get(path19) !== hash) {
+      download.push(path19);
     }
   }
   const deleteLocal = [];
-  for (const path13 of localMap.keys()) {
-    if (!remoteMap.has(path13)) {
-      deleteLocal.push(path13);
+  for (const path19 of localMap.keys()) {
+    if (!remoteMap.has(path19)) {
+      deleteLocal.push(path19);
     }
   }
   return { download, deleteLocal };
@@ -916,8 +916,8 @@ ${diagnostic ?? ""}`
     }
   }
   let deleted = 0;
-  for (const path13 of deleteLocal) {
-    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path13));
+  for (const path19 of deleteLocal) {
+    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path19));
     if (existsSync2(absPath)) {
       rmSync(absPath, { force: true });
       deleted += 1;
@@ -962,21 +962,21 @@ async function syncRepositoryProjectDocumentsPush(cfg, workdirPath, apmRoot) {
     ])
   );
   let synced = 0;
-  for (const path13 of localPaths) {
-    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path13));
+  for (const path19 of localPaths) {
+    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path19));
     const content = readFileSync3(absPath, "utf8");
     const contentHash = hashLocalFileContent(content);
-    if (remoteHashByPath.get(path13) === contentHash) {
+    if (remoteHashByPath.get(path19) === contentHash) {
       continue;
     }
     await api.cli.upsertRepositoryProjectDocument({
       repositoryId,
-      path: path13,
+      path: path19,
       content,
-      description: remoteDescriptionByPath.get(path13) ?? void 0
+      description: remoteDescriptionByPath.get(path19) ?? void 0
     });
     synced += 1;
-    console.log(`[apm] \u5DF2\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863: ${path13}`);
+    console.log(`[apm] \u5DF2\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863: ${path19}`);
   }
   if (synced === 0) {
     console.log("[apm] \u4ED3\u5E93\u9879\u76EE\u6587\u6863\u65E0\u53D8\u5316\uFF0C\u8DF3\u8FC7\u63A8\u9001");
@@ -1228,6 +1228,7 @@ var TASK_STATUS_LABEL = {
   IN_PROGRESS: "\u8FDB\u884C\u4E2D",
   COMPLETED: "\u5DF2\u5B8C\u6210",
   FAILED: "\u5DF2\u5931\u8D25",
+  CLOSED: "\u5DF2\u5173\u95ED",
   SUSPENDED: "\u5DF2\u6682\u505C"
 };
 function taskStatusLabel(status) {
@@ -1265,6 +1266,9 @@ function shouldDeleteMode2(input) {
   if (input.taskStatus === "FAILED") {
     return { delete: true, reason: "\u4EFB\u52A1\u5DF2\u5931\u8D25" };
   }
+  if (input.taskStatus === "CLOSED") {
+    return { delete: true, reason: "\u4EFB\u52A1\u5DF2\u5173\u95ED" };
+  }
   return { delete: false, reason: "" };
 }
 function buildSessionBranchRow(input) {
@@ -1589,13 +1593,13 @@ async function downloadAttachment(cfg, attachmentId) {
   return Buffer.from(await res.arrayBuffer());
 }
 function loadManifest(dir) {
-  const path13 = join6(dir, MANIFEST_FILE2);
-  if (!existsSync4(path13)) {
+  const path19 = join6(dir, MANIFEST_FILE2);
+  if (!existsSync4(path19)) {
     return { version: 1, attachments: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync5(path13, "utf8")
+      readFileSync5(path19, "utf8")
     );
     if (parsed?.version === 1 && parsed.attachments && typeof parsed.attachments === "object") {
       return parsed;
@@ -1676,8 +1680,8 @@ function sanitizeSkillDirName(name) {
 function listBaseSkillDirNames() {
   if (!existsSync5(BASE_SKILLS_TEMPLATE_DIR)) return [];
   return readdirSync3(BASE_SKILLS_TEMPLATE_DIR).filter((name) => {
-    const path13 = join7(BASE_SKILLS_TEMPLATE_DIR, name);
-    return statSync2(path13).isDirectory();
+    const path19 = join7(BASE_SKILLS_TEMPLATE_DIR, name);
+    return statSync2(path19).isDirectory();
   });
 }
 function syncAgentsGuide(apmDir) {
@@ -1689,8 +1693,8 @@ function syncAgentsGuide(apmDir) {
 function listBaseRuleFileNames() {
   if (!existsSync5(BASE_RULES_TEMPLATE_DIR)) return [];
   return readdirSync3(BASE_RULES_TEMPLATE_DIR).filter((name) => {
-    const path13 = join7(BASE_RULES_TEMPLATE_DIR, name);
-    return statSync2(path13).isFile();
+    const path19 = join7(BASE_RULES_TEMPLATE_DIR, name);
+    return statSync2(path19).isFile();
   });
 }
 function syncBaseRules(rulesDir) {
@@ -1753,13 +1757,13 @@ function ruleLocalFileName(ruleName) {
   return `${sanitized}.md`;
 }
 function loadManifest2(rulesDir) {
-  const path13 = join8(rulesDir, MANIFEST_FILE3);
-  if (!existsSync6(toFsPath(path13))) {
+  const path19 = join8(rulesDir, MANIFEST_FILE3);
+  if (!existsSync6(toFsPath(path19))) {
     return { version: 1, rules: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync6(toFsPath(path13), "utf8")
+      readFileSync6(toFsPath(path19), "utf8")
     );
     if (parsed?.version === 1 && parsed.rules && typeof parsed.rules === "object") {
       return parsed;
@@ -2654,93 +2658,17 @@ function validateAgentWsMessage(value, kind) {
   return validateMessagePush(o);
 }
 
-// src/commands/deploy/deploy-log-utils.ts
-import { setTimeout as delay } from "node:timers/promises";
-var DEPLOY_SPAWN_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
-var DEPLOY_LOG_SYNC_MAX_CHUNK_BYTES = 4 * 1024 * 1024;
-var DEPLOY_COMPLETE_LOG_MAX_BYTES = 9 * 1024 * 1024;
-var DEPLOY_LOG_SYNC_MAX_ATTEMPTS = 3;
-async function retryDeployLogSync(fn, attempts = DEPLOY_LOG_SYNC_MAX_ATTEMPTS) {
-  let lastError;
-  for (let attempt = 1; attempt <= attempts; attempt += 1) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-      if (attempt < attempts) {
-        await delay(1e3 * attempt);
-      }
-    }
-  }
-  throw lastError;
-}
-function splitUtf8StringByMaxBytes(value, maxBytes) {
-  if (maxBytes <= 0) {
-    throw new Error("maxBytes must be positive");
-  }
-  const bytes = Buffer.from(value, "utf8");
-  if (bytes.length <= maxBytes) {
-    return [value];
-  }
-  const chunks = [];
-  let offset = 0;
-  while (offset < bytes.length) {
-    let end = Math.min(offset + maxBytes, bytes.length);
-    while (end > offset && (bytes[end] & 192) === 128) {
-      end -= 1;
-    }
-    if (end <= offset) {
-      end = Math.min(offset + maxBytes, bytes.length);
-    }
-    chunks.push(bytes.subarray(offset, end).toString("utf8"));
-    offset = end;
-  }
-  return chunks;
-}
-function truncateDeployLogForComplete(log2) {
-  const bytes = Buffer.from(log2, "utf8");
-  if (bytes.length <= DEPLOY_COMPLETE_LOG_MAX_BYTES) {
-    return { log: log2, truncated: false };
-  }
-  const tailBudget = Math.max(DEPLOY_COMPLETE_LOG_MAX_BYTES - 512, 1024);
-  const prefix = `[apm] \u65E5\u5FD7\u8FC7\u957F\uFF08${Math.ceil(bytes.length / 1024)}KB\uFF09\uFF0C\u4EC5\u4FDD\u7559\u672B\u5C3E ${Math.floor(tailBudget / 1024)}KB
-`;
-  let tail = bytes.subarray(bytes.length - tailBudget).toString("utf8");
-  const brokenPrefix = tail.indexOf("\uFFFD");
-  if (brokenPrefix >= 0) {
-    const newline = tail.indexOf("\n", brokenPrefix);
-    tail = newline >= 0 ? tail.slice(newline + 1) : tail.slice(brokenPrefix + 1);
-  }
-  return { log: prefix + tail, truncated: true };
-}
-
 // src/commands/deploy/deploy-execute.ts
-import path5 from "node:path";
+import path11 from "node:path";
 
 // src/commands/deploy/internal/apm-config.ts
-import { existsSync as existsSync11, readFileSync as readFileSync10 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join13, resolve as resolve3 } from "node:path";
-function loadApmConfig(options) {
-  const p = resolve3(
-    process.cwd(),
-    options?.configPath ?? resolve3(workspaceApmDir(), "apm.config.json")
-  );
-  if (!existsSync11(p)) {
-    console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
-    process.exit(1);
-  }
-  try {
-    const raw = readFileSync10(p, "utf8");
-    return JSON.parse(raw);
-  } catch (e) {
-    console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
-    process.exit(1);
-  }
-}
-function req(v, field) {
+import { existsSync as existsSync12, readFileSync as readFileSync11 } from "node:fs";
+import { resolve as resolve4 } from "node:path";
+
+// src/commands/deploy/internal/config/config-validation.ts
+function req(v, field, section) {
   if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
-    console.error(`apm.config.json \u4E2D backendDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+    console.error(`apm.config.json \u4E2D ${section}.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
     process.exit(1);
   }
   return v;
@@ -2755,17 +2683,19 @@ function reqTopLevelName(cfg) {
   }
   return n;
 }
-function reqBackendPositiveInt(v, field) {
+function reqPositiveInt(v, field, section) {
   const n = Number(v);
   if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) {
-    console.error(`apm.config.json \u4E2D backendDeploy.${field} \u987B\u4E3A\u6B63\u6574\u6570`);
+    console.error(`apm.config.json \u4E2D ${section}.${field} \u987B\u4E3A\u6B63\u6574\u6570`);
     process.exit(1);
   }
   return n;
 }
+
+// src/commands/deploy/internal/config/docker-backend-config.ts
 function resolveBackendDeployFromApmConfig(cfg) {
   const b = cfg.backendDeploy ?? {};
-  const protoRaw = req(b.remoteProtocol, "remoteProtocol").trim().toLowerCase();
+  const protoRaw = req(b.remoteProtocol, "remoteProtocol", "backendDeploy").trim().toLowerCase();
   if (protoRaw !== "http" && protoRaw !== "https") {
     console.error(
       "apm.config.json \u4E2D backendDeploy.remoteProtocol \u53EA\u80FD\u4E3A http \u6216 https"
@@ -2786,12 +2716,20 @@ function resolveBackendDeployFromApmConfig(cfg) {
   }
   return {
     name: reqTopLevelName(cfg),
-    registryHost: req(b.registryHost, "registryHost").trim(),
-    registryNamespace: req(b.registryNamespace, "registryNamespace").trim(),
-    registryUser: req(b.registryUser, "registryUser").trim(),
-    registryPassword: req(b.registryPassword, "registryPassword").trim(),
-    remoteHost: req(b.remoteHost, "remoteHost").trim(),
-    remotePort: reqBackendPositiveInt(b.remotePort, "remotePort"),
+    registryHost: req(b.registryHost, "registryHost", "backendDeploy").trim(),
+    registryNamespace: req(
+      b.registryNamespace,
+      "registryNamespace",
+      "backendDeploy"
+    ).trim(),
+    registryUser: req(b.registryUser, "registryUser", "backendDeploy").trim(),
+    registryPassword: req(
+      b.registryPassword,
+      "registryPassword",
+      "backendDeploy"
+    ).trim(),
+    remoteHost: req(b.remoteHost, "remoteHost", "backendDeploy").trim(),
+    remotePort: reqPositiveInt(b.remotePort, "remotePort", "backendDeploy"),
     remoteProtocol,
     caPath: b.caPath?.trim(),
     certPath: b.certPath?.trim(),
@@ -2801,64 +2739,30 @@ function resolveBackendDeployFromApmConfig(cfg) {
     dockerNetwork: b.dockerNetwork?.trim() || void 0
   };
 }
-function reqFe(v, field) {
-  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
-    console.error(`apm.config.json \u4E2D frontendDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
-    process.exit(1);
-  }
-  return v;
-}
+
+// src/commands/deploy/internal/config/frontend-minio-config.ts
 function resolveFrontendDeployFromApmConfig(cfg) {
   const f = cfg.frontendDeploy ?? {};
   const port = Number(f.port);
   return {
-    endpoint: reqFe(f.endpoint, "endpoint").trim(),
+    endpoint: req(f.endpoint, "endpoint", "frontendDeploy").trim(),
     port: Number.isFinite(port) && port > 0 ? port : 9e3,
     useSsl: Boolean(f.useSsl),
-    accessKey: reqFe(f.accessKey, "accessKey").trim(),
-    secretKey: reqFe(f.secretKey, "secretKey").trim(),
-    bucket: reqFe(f.bucket, "bucket").trim()
-  };
-}
-function reqWd(v, field) {
-  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
-    console.error(`apm.config.json \u4E2D wisdomDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
-    process.exit(1);
-  }
-  return v;
-}
-function reqWisdomPositiveInt(v, field) {
-  const n = Number(v);
-  if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) {
-    console.error(`apm.config.json \u4E2D wisdomDeploy.${field} \u987B\u4E3A\u6B63\u6574\u6570`);
-    process.exit(1);
-  }
-  return n;
-}
-function resolveWisdomDeployFromApmConfig(cfg) {
-  const w = cfg.wisdomDeploy ?? {};
-  return {
-    host: reqWd(w.host, "host").trim(),
-    port: reqWisdomPositiveInt(w.port, "port"),
-    username: reqWd(w.username, "username").trim(),
-    password: reqWd(w.password, "password").trim(),
-    remotePath: reqWd(w.remotePath, "remotePath").trim()
+    accessKey: req(f.accessKey, "accessKey", "frontendDeploy").trim(),
+    secretKey: req(f.secretKey, "secretKey", "frontendDeploy").trim(),
+    bucket: req(f.bucket, "bucket", "frontendDeploy").trim()
   };
 }
-function reqHc(v, field) {
-  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
-    console.error(`apm.config.json \u4E2D healthCheck.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
-    process.exit(1);
-  }
-  return v;
-}
-function reqWb(v, field) {
-  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
-    console.error(`apm.config.json \u4E2D wisdomDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
-    process.exit(1);
-  }
-  return v;
-}
+
+// src/commands/deploy/internal/config/maven-repo.ts
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join13, resolve as resolve3 } from "node:path";
+var MAVEN_REPO_ENV_KEYS = [
+  "MAVEN_LOCAL_REPO",
+  "M2_REPO",
+  "MAVEN_REPOSITORY"
+];
 function readEnvVar(env, name) {
   if (env[name] !== void 0) {
     return env[name];
@@ -2888,11 +2792,6 @@ function expandUserPath(pathStr, env = process.env) {
   }
   return resolve3(expanded);
 }
-var MAVEN_REPO_ENV_KEYS = [
-  "MAVEN_LOCAL_REPO",
-  "M2_REPO",
-  "MAVEN_REPOSITORY"
-];
 function readMavenLocalRepoFromMavenOpts(mavenOpts, env = process.env) {
   const match = mavenOpts.match(/-Dmaven\.repo\.local=(?:"([^"]+)"|(\S+))/);
   const raw = match?.[1]?.trim() || match?.[2]?.trim();
@@ -2907,9 +2806,9 @@ function readMavenLocalRepoFromEnv(env = process.env) {
   }
   const mavenOpts = readEnvVar(env, "MAVEN_OPTS")?.trim();
   if (mavenOpts) {
-    const path13 = readMavenLocalRepoFromMavenOpts(mavenOpts, env);
-    if (path13) {
-      return { path: path13, key: "MAVEN_OPTS" };
+    const path19 = readMavenLocalRepoFromMavenOpts(mavenOpts, env);
+    if (path19) {
+      return { path: path19, key: "MAVEN_OPTS" };
     }
   }
   return null;
@@ -2956,6 +2855,18 @@ function resolveMavenLocalRepoWithSource() {
     sourceDetail: "~/.m2/repository"
   };
 }
+
+// src/commands/deploy/internal/config/wisdom-config.ts
+function resolveWisdomDeployFromApmConfig(cfg) {
+  const w = cfg.wisdomDeploy ?? {};
+  return {
+    host: req(w.host, "host", "wisdomDeploy").trim(),
+    port: reqPositiveInt(w.port, "port", "wisdomDeploy"),
+    username: req(w.username, "username", "wisdomDeploy").trim(),
+    password: req(w.password, "password", "wisdomDeploy").trim(),
+    remotePath: req(w.remotePath, "remotePath", "wisdomDeploy").trim()
+  };
+}
 function resolveWisdomDeployMode(raw) {
   if (raw === void 0 || raw === null || raw === "") {
     return "default";
@@ -2969,14 +2880,27 @@ function resolveWisdomDeployMode(raw) {
   );
   process.exit(1);
 }
+function posixDirname(p) {
+  const normalized = p.replace(/\\/g, "/");
+  const idx = normalized.lastIndexOf("/");
+  if (idx <= 0) {
+    return normalized.startsWith("/") ? "/" : ".";
+  }
+  return normalized.slice(0, idx);
+}
+function posixBasename(p) {
+  const normalized = p.replace(/\\/g, "/");
+  const idx = normalized.lastIndexOf("/");
+  return idx >= 0 ? normalized.slice(idx + 1) : normalized;
+}
 function resolveWisdomBackendDeployFromApmConfig(cfg) {
   const projectName = reqTopLevelName(cfg);
   const w = cfg.wisdomDeploy ?? {};
   const h = cfg.healthCheck ?? {};
-  const jarPath = reqWb(w.jarPath, "jarPath").trim();
+  const jarPath = req(w.jarPath, "jarPath", "wisdomDeploy").trim();
   const remoteAppDir = posixDirname(jarPath);
-  const healthPort = Number(reqHc(h.port, "port"));
-  const healthTimeout = Number(reqHc(h.timeout, "timeout"));
+  const healthPort = Number(req(h.port, "port", "healthCheck"));
+  const healthTimeout = Number(req(h.timeout, "timeout", "healthCheck"));
   if (!Number.isFinite(healthPort) || !Number.isInteger(healthPort) || healthPort < 1) {
     console.error("apm.config.json \u4E2D healthCheck.port \u987B\u4E3A\u6B63\u6574\u6570");
     process.exit(1);
@@ -2988,11 +2912,11 @@ function resolveWisdomBackendDeployFromApmConfig(cfg) {
   const mavenLocalRepo = resolveMavenLocalRepoWithSource();
   return {
     projectName,
-    host: reqWd(w.host, "host").trim(),
-    port: reqWisdomPositiveInt(w.port, "port"),
-    username: reqWd(w.username, "username").trim(),
-    password: reqWd(w.password, "password").trim(),
-    remoteVueDistDir: reqWd(w.remotePath, "remotePath").trim(),
+    host: req(w.host, "host", "wisdomDeploy").trim(),
+    port: reqPositiveInt(w.port, "port", "wisdomDeploy"),
+    username: req(w.username, "username", "wisdomDeploy").trim(),
+    password: req(w.password, "password", "wisdomDeploy").trim(),
+    remoteVueDistDir: req(w.remotePath, "remotePath", "wisdomDeploy").trim(),
     remoteAppDir,
     remoteLibDir: `${remoteAppDir}/lib`,
     startupJar: posixBasename(jarPath),
@@ -3001,35 +2925,51 @@ function resolveWisdomBackendDeployFromApmConfig(cfg) {
     mavenLocalRepoSource: mavenLocalRepo.source,
     mavenLocalRepoSourceDetail: mavenLocalRepo.sourceDetail,
     healthCheckPort: healthPort,
-    healthCheckContext: reqHc(h.context, "context").trim(),
+    healthCheckContext: req(h.context, "context", "healthCheck").trim(),
     healthCheckTimeout: healthTimeout,
     mode: resolveWisdomDeployMode(w.mode)
   };
 }
-function posixDirname(p) {
-  const normalized = p.replace(/\\/g, "/");
-  const idx = normalized.lastIndexOf("/");
-  if (idx <= 0) {
-    return normalized.startsWith("/") ? "/" : ".";
+
+// src/commands/deploy/internal/apm-config.ts
+function loadApmConfig(options) {
+  const p = resolve4(
+    process.cwd(),
+    options?.configPath ?? resolve4(workspaceApmDir(), "apm.config.json")
+  );
+  if (!existsSync12(p)) {
+    console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
+    process.exit(1);
+  }
+  try {
+    const raw = readFileSync11(p, "utf8");
+    return JSON.parse(raw);
+  } catch (e) {
+    console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
+    process.exit(1);
   }
-  return normalized.slice(0, idx);
-}
-function posixBasename(p) {
-  const normalized = p.replace(/\\/g, "/");
-  const idx = normalized.lastIndexOf("/");
-  return idx >= 0 ? normalized.slice(idx + 1) : normalized;
 }
 
 // src/commands/deploy/internal/deploy-hints.ts
+function isProductionDeployEnv(env) {
+  const normalized = env.trim().toLowerCase();
+  return normalized === "online" || normalized === "production" || normalized === "prod";
+}
 function formatMissingWisdomDeployLines() {
   return [
     "[apm] \u65E0\u6CD5\u6267\u884C apm deploy\uFF1A\u8BF7\u5728 apm.config.json \u4E2D\u914D\u7F6E wisdomDeploy\uFF08host\u3001remotePath\uFF09"
   ];
 }
 function formatWisdomFrontendBuildNotConfiguredLines(env, packageJsonPath) {
+  if (isProductionDeployEnv(env)) {
+    return [
+      `[apm] \u65E0\u6CD5\u6267\u884C\u524D\u7AEF\u90E8\u7F72\uFF1A${packageJsonPath} \u4E2D\u672A\u627E\u5230 build:${env} \u6216 build \u811A\u672C`,
+      "[apm] \u8BF7\u914D\u7F6E npm run build:online \u6216 npm run build \u540E\u518D\u8BD5"
+    ];
+  }
   return [
     `[apm] \u65E0\u6CD5\u6267\u884C\u524D\u7AEF\u90E8\u7F72\uFF1A${packageJsonPath} \u4E2D\u672A\u627E\u5230 build:${env} \u811A\u672C`,
-    "[apm] \u8BF7\u914D\u7F6E npm run build:test / build:online \u540E\u518D\u8BD5"
+    "[apm] \u8BF7\u914D\u7F6E npm run build:test \u540E\u518D\u8BD5"
   ];
 }
 
@@ -3047,7 +2987,7 @@ var DeployExecutionError = class extends Error {
 
 // src/commands/deploy/deploy-debug-log.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync15 } from "node:fs";
 import { dirname as dirname5, join as join16 } from "node:path";
 
 // src/commands/deploy/internal/deploy-artifact-minio.ts
@@ -3153,14 +3093,14 @@ var MinioClient = class {
   async deleteObjectsByPrefix(bucket, prefix) {
     const objectsStream = this.inner.listObjectsV2(bucket, prefix, true);
     const keys = [];
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       objectsStream.on("data", (obj) => {
         if (obj.name) {
           keys.push(obj.name);
         }
       });
       objectsStream.on("error", reject);
-      objectsStream.on("end", resolve5);
+      objectsStream.on("end", resolve6);
     });
     const chunkSize = 500;
     for (let i = 0; i < keys.length; i += chunkSize) {
@@ -3306,15 +3246,15 @@ import { dirname as dirname4 } from "node:path";
 
 // src/commands/daemon.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { setTimeout as delay2 } from "node:timers/promises";
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
+import { setTimeout as delay } from "node:timers/promises";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
 import { join as join15 } from "path";
 
 // src/commands/connect-lock.ts
 import {
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   unlinkSync,
   writeFileSync as writeFileSync10
 } from "fs";
@@ -3346,9 +3286,9 @@ function waitForPm2LockHandoff(timeoutMs = 5e3) {
   }
 }
 function readConnectLock() {
-  if (!existsSync12(CONNECT_LOCK_PATH)) return null;
+  if (!existsSync13(CONNECT_LOCK_PATH)) return null;
   try {
-    const raw = readFileSync11(CONNECT_LOCK_PATH, "utf8");
+    const raw = readFileSync12(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;
@@ -3405,7 +3345,7 @@ function releaseConnectLock() {
 }
 function forceReleaseConnectLock() {
   try {
-    if (existsSync12(CONNECT_LOCK_PATH)) {
+    if (existsSync13(CONNECT_LOCK_PATH)) {
       unlinkSync(CONNECT_LOCK_PATH);
     }
   } catch {
@@ -3555,14 +3495,14 @@ function resolvePm2FromNpmRoot() {
   if (!root) return null;
   for (const rel of ["pm2/bin/pm2", "pm2/bin/pm2.js"]) {
     const candidate = join15(root, ...rel.split("/"));
-    if (existsSync13(candidate)) {
+    if (existsSync14(candidate)) {
       return candidate;
     }
   }
   return null;
 }
-function isPm2NodeScript(path13) {
-  return path13.endsWith(".js") || /[\\/]pm2[\\/]bin[\\/]pm2$/.test(path13);
+function isPm2NodeScript(path19) {
+  return path19.endsWith(".js") || /[\\/]pm2[\\/]bin[\\/]pm2$/.test(path19);
 }
 function buildPm2SpawnTarget(binPath) {
   if (isPm2NodeScript(binPath)) {
@@ -3592,7 +3532,7 @@ function spawnPm2At(binPath, args, options = {}) {
   return spawnPm2Target(buildPm2SpawnTarget(binPath), args, options);
 }
 function verifyPm2Bin(pm2Bin) {
-  if (!pm2Bin.trim() || !existsSync13(pm2Bin)) {
+  if (!pm2Bin.trim() || !existsSync14(pm2Bin)) {
     return false;
   }
   const result = spawnPm2At(pm2Bin, ["--version"], {
@@ -3731,7 +3671,7 @@ function ensureGlobalPm2(options) {
 }
 function resolveApmEntryPath(entryArg = process.argv[1]) {
   const fromArgv = entryArg?.trim();
-  if (fromArgv && existsSync13(fromArgv)) {
+  if (fromArgv && existsSync14(fromArgv)) {
     return fromArgv;
   }
   const npmResult = spawnSync2(useNpmShell2 ? "npm.cmd" : "npm", ["root", "-g"], {
@@ -3743,7 +3683,7 @@ function resolveApmEntryPath(entryArg = process.argv[1]) {
     const globalRoot = npmResult.stdout?.toString().trim();
     if (globalRoot) {
       const candidate = join15(globalRoot, CLI_PACKAGE_NAME, "dist", "index.js");
-      if (existsSync13(candidate)) {
+      if (existsSync14(candidate)) {
         return candidate;
       }
     }
@@ -3934,7 +3874,7 @@ function writeEcosystemFile(options) {
     formatConnectPm2EcosystemFile(ecosystem),
     "utf8"
   );
-  if (existsSync13(LEGACY_PM2_ECOSYSTEM_PATH)) {
+  if (existsSync14(LEGACY_PM2_ECOSYSTEM_PATH)) {
     try {
       unlinkSync2(LEGACY_PM2_ECOSYSTEM_PATH);
     } catch {
@@ -3963,7 +3903,7 @@ async function runDaemonStart(options) {
   const cfg = await prepareEcosystem(options.server);
   removePm2ConnectProcesses();
   runPm2(["start", PM2_ECOSYSTEM_PATH, "--update-env"], { inherit: true });
-  await delay2(1e3);
+  await delay(1e3);
   if (!isPm2ConnectOnline()) {
     console.error(
       `[apm] ${PM2_APP_NAME} \u542F\u52A8\u540E\u672A\u5904\u4E8E online \u72B6\u6001\uFF0C\u8BF7\u6267\u884C: apm daemon logs -n 200`
@@ -3996,7 +3936,7 @@ async function runDaemonStop() {
   });
   for (let i = 0; i < 10; i += 1) {
     if (!isPm2ConnectOnline()) break;
-    await delay2(500);
+    await delay(500);
   }
   if (isPm2ConnectOnline()) {
     console.log(`[apm] \u4F18\u96C5\u505C\u6B62\u8D85\u65F6\uFF0C\u5F3A\u5236\u79FB\u9664 ${PM2_APP_NAME}\u2026`);
@@ -4231,12 +4171,12 @@ function logExecuteDeployContext(input) {
     `cwdMatchProcess=${input.cwd === input.processCwd ? "yes" : "no"} (connect \u901A\u5E38\u4E3A no)`
   );
   logLine(
-    `apm.config=${input.apmConfigPath} exists=${existsSync14(
+    `apm.config=${input.apmConfigPath} exists=${existsSync15(
       input.apmConfigPath
     )}`
   );
   logLine(
-    `package.json=${packageJsonPath} exists=${existsSync14(packageJsonPath)}`
+    `package.json=${packageJsonPath} exists=${existsSync15(packageJsonPath)}`
   );
   logLine(
     `flags captureOutput=${input.captureOutput} packOnly=${Boolean(
@@ -4292,18 +4232,64 @@ function logWisdomFrontendDeployContext(input) {
   logLine(
     `buildKey=build:${input.env} buildCmd=${input.buildCmd ?? "(missing)"}`
   );
-  logLine(`distDir=${input.distDir} exists=${existsSync14(input.distDir)}`);
+  logLine(`distDir=${input.distDir} exists=${existsSync15(input.distDir)}`);
   logLine(
     `packOnly=${input.packOnly} archiveDeployArtifact=${input.archiveDeployArtifact}`
   );
 }
 
 // src/commands/deploy/internal/wisdom-deploy.ts
-import { existsSync as existsSync16, readFileSync as readFileSync13, statSync as statSync7 } from "node:fs";
-import path4 from "node:path";
+import { existsSync as existsSync19, readFileSync as readFileSync15, statSync as statSync9 } from "node:fs";
+import path10 from "node:path";
 
 // src/commands/deploy/deploy-shell-run.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
+
+// src/commands/deploy/deploy-log-utils.ts
+import { setTimeout as delay2 } from "node:timers/promises";
+var DEPLOY_SPAWN_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
+var DEPLOY_LOG_SYNC_MAX_CHUNK_BYTES = 4 * 1024 * 1024;
+var DEPLOY_LOG_SYNC_MAX_ATTEMPTS = 3;
+async function retryDeployLogSync(fn, attempts = DEPLOY_LOG_SYNC_MAX_ATTEMPTS) {
+  let lastError;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < attempts) {
+        await delay2(1e3 * attempt);
+      }
+    }
+  }
+  throw lastError;
+}
+var retryDeployStatusComplete = retryDeployLogSync;
+function splitUtf8StringByMaxBytes(value, maxBytes) {
+  if (maxBytes <= 0) {
+    throw new Error("maxBytes must be positive");
+  }
+  const bytes = Buffer.from(value, "utf8");
+  if (bytes.length <= maxBytes) {
+    return [value];
+  }
+  const chunks = [];
+  let offset = 0;
+  while (offset < bytes.length) {
+    let end = Math.min(offset + maxBytes, bytes.length);
+    while (end > offset && (bytes[end] & 192) === 128) {
+      end -= 1;
+    }
+    if (end <= offset) {
+      end = Math.min(offset + maxBytes, bytes.length);
+    }
+    chunks.push(bytes.subarray(offset, end).toString("utf8"));
+    offset = end;
+  }
+  return chunks;
+}
+
+// src/commands/deploy/deploy-shell-run.ts
 function runDeployShellCommand(command, cwd, captureOutput) {
   logRunDeployShellContext({ command, cwd, captureOutput });
   const shellEnv = buildDeployShellEnv();
@@ -4346,43 +4332,93 @@ function runDeployShellCommand(command, cwd, captureOutput) {
   return output;
 }
 
-// src/commands/deploy/internal/wisdom-backend-deploy.ts
+// src/commands/deploy/internal/wisdom-backend/index.ts
+import path9 from "node:path";
+
+// src/commands/deploy/internal/wisdom-backend/jar-incremental.ts
 import {
-  existsSync as existsSync15,
-  mkdirSync as mkdirSync7,
+  mkdirSync as mkdirSync8,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync12,
-  statSync as statSync6,
-  writeFileSync as writeFileSync12
+  readFileSync as readFileSync14,
+  statSync as statSync7,
+  writeFileSync as writeFileSync13
 } from "node:fs";
-import { spawnSync as spawnSync6 } from "node:child_process";
-import path3 from "node:path";
-import { Client as Client2 } from "ssh2";
+import path6 from "node:path";
 import JSZip2 from "jszip";
-import SftpClient2 from "ssh2-sftp-client";
 
-// src/commands/deploy/internal/wisdom-sftp.ts
-import { readdir as readdir2, readFile as readFile3, unlink, writeFile } from "node:fs/promises";
+// src/commands/deploy/internal/wisdom-backend/manifest.ts
+import {
+  existsSync as existsSync16,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync13,
+  statSync as statSync6,
+  writeFileSync as writeFileSync12
+} from "node:fs";
 import path2 from "node:path";
-import JSZip from "jszip";
-import SftpClient from "ssh2-sftp-client";
-async function addDirToZip(dir, zipFolder) {
-  const entries = await readdir2(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path2.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      const folder = zipFolder.folder(entry.name);
-      if (folder) {
-        await addDirToZip(fullPath, folder);
-      }
-    } else {
-      const content = await readFile3(fullPath);
-      zipFolder.file(entry.name, content);
-    }
+function deployCacheDir() {
+  return path2.join(workspaceApmDir(), "deploy", ".deploy_cache");
+}
+function manifestFilePath() {
+  return path2.join(deployCacheDir(), "manifest.json");
+}
+function relativeKey(projectRoot, filePath) {
+  return path2.relative(projectRoot, filePath).split(path2.sep).join("/");
+}
+function fileSignature(filePath) {
+  const stat2 = statSync6(filePath);
+  return { size: stat2.size, mtime: stat2.mtimeMs / 1e3 };
+}
+function loadManifest3() {
+  const manifestPath2 = manifestFilePath();
+  if (!existsSync16(manifestPath2)) {
+    return {};
   }
+  return JSON.parse(readFileSync13(manifestPath2, "utf8"));
 }
-async function zipDirectory(distDir, zipPath) {
-  console.error(`\u538B\u7F29\u76EE\u5F55: ${distDir}`);
+function saveManifest3(manifest) {
+  const dir = deployCacheDir();
+  mkdirSync7(dir, { recursive: true });
+  writeFileSync12(manifestFilePath(), JSON.stringify(manifest, null, 2), "utf8");
+}
+function updateManifestEntries(manifest, entries, projectRoot) {
+  for (const entry of entries) {
+    manifest[relativeKey(projectRoot, entry.path)] = fileSignature(entry.path);
+  }
+  return manifest;
+}
+function deployCacheDirectory() {
+  return deployCacheDir();
+}
+
+// src/commands/deploy/internal/wisdom-backend/internal-utils.ts
+import path5 from "node:path";
+
+// src/commands/deploy/internal/wisdom-sftp.ts
+import { unlink as unlink2 } from "node:fs/promises";
+import path4 from "node:path";
+import SftpClient from "ssh2-sftp-client";
+
+// src/commands/deploy/internal/artifact-packaging.ts
+import { readdir as readdir2, readFile as readFile3, unlink, writeFile } from "node:fs/promises";
+import path3 from "node:path";
+import JSZip from "jszip";
+async function addDirToZip(dir, zipFolder) {
+  const entries = await readdir2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const folder = zipFolder.folder(entry.name);
+      if (folder) {
+        await addDirToZip(fullPath, folder);
+      }
+    } else {
+      const content = await readFile3(fullPath);
+      zipFolder.file(entry.name, content);
+    }
+  }
+}
+async function zipDirectory(distDir, zipPath) {
+  console.error(`\u538B\u7F29\u76EE\u5F55: ${distDir}`);
   const zip = new JSZip();
   await addDirToZip(distDir, zip);
   const content = await zip.generateAsync({
@@ -4395,6 +4431,65 @@ async function zipDirectory(distDir, zipPath) {
   console.error(`\u5DF2\u751F\u6210: ${zipPath} (${sizeMb} MB)`);
   return content.length;
 }
+function resolveProjectNameForDeploy(cfg, cwd, options) {
+  const name = (cfg.name ?? "").trim();
+  if (options?.requireName && !name) {
+    throw new DeployExecutionError(
+      "\u8BF7\u5728 .apm/apm.config.json \u9876\u5C42\u914D\u7F6E name\uFF08\u4F5C\u4E3A\u90E8\u7F72\u4EA7\u7269\u9879\u76EE\u540D\uFF09",
+      1
+    );
+  }
+  if (name) {
+    return name;
+  }
+  return path3.basename(cwd);
+}
+function resolveArtifactNamePrefix(cfg) {
+  const nameRaw = resolveProjectNameForDeploy(cfg, process.cwd(), {
+    requireName: true
+  });
+  if (nameRaw.includes(":")) {
+    throw new DeployExecutionError("apm.config.json \u7684 name \u4E0D\u80FD\u5305\u542B ':'", 1);
+  }
+  try {
+    return sanitizeRelativePath(nameRaw.replace(/\\/g, "/"));
+  } catch {
+    throw new DeployExecutionError(
+      "apm.config.json \u7684 name \u975E\u6CD5\uFF08\u8DEF\u5F84\u7247\u6BB5\u4E0D\u80FD\u4E3A . \u6216 ..\uFF09",
+      1
+    );
+  }
+}
+async function packDirectoryWithMinioArchive(input) {
+  const resolvedZipPath = path3.resolve(input.zipPath);
+  let zipSizeBytes = 0;
+  let artifactUploaded = false;
+  try {
+    zipSizeBytes = await zipDirectory(input.localDir, resolvedZipPath);
+    if (input.skipMessage) {
+      console.error(input.skipMessage);
+    }
+    const artifact = await uploadDeployArtifactZip({
+      zipPath: resolvedZipPath,
+      projectName: input.projectName,
+      kind: input.kind,
+      uploadWithoutRunId: input.uploadWithoutRunId
+    });
+    artifactUploaded = artifact !== null;
+    if (artifactUploaded && input.successMessage) {
+      console.error(input.successMessage);
+    }
+    return { zipSizeBytes, artifactUploaded };
+  } finally {
+    try {
+      await unlink(resolvedZipPath);
+      console.error(`\u5DF2\u6E05\u7406\u672C\u5730\u4E34\u65F6\u6587\u4EF6: ${resolvedZipPath}`);
+    } catch {
+    }
+  }
+}
+
+// src/commands/deploy/internal/wisdom-sftp.ts
 var SFTP_UPLOAD_MAX_ATTEMPTS = 3;
 var SFTP_FAST_PUT_OPTIONS = {
   chunkSize: 64 * 1024,
@@ -4413,7 +4508,7 @@ function buildSftpConnectOptions(settings) {
   };
 }
 async function sleep(ms) {
-  await new Promise((resolve5) => setTimeout(resolve5, ms));
+  await new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 async function uploadZipWithRetry(settings, localZip, remoteZipPath) {
   let lastError;
@@ -4457,7 +4552,7 @@ async function ensureRemoteDir(sftp, dir) {
   }
 }
 function execCommand(client, command) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     client.exec(command, (err, stream) => {
       if (err) return reject(err);
       let stdout = "";
@@ -4467,7 +4562,7 @@ function execCommand(client, command) {
           reject(new Error(`\u8FDC\u7A0B\u547D\u4EE4\u5931\u8D25 (${code}): ${stderr || stdout}`));
           return;
         }
-        resolve5(stdout);
+        resolve6(stdout);
       }).on("data", (data) => {
         stdout += data.toString();
       });
@@ -4534,8 +4629,8 @@ function resolveDeployArtifactUpload(input) {
   return { upload: false, uploadWithoutRunId: false };
 }
 async function runWisdomSftpDeploy(params) {
-  const zipPath = path2.join(params.localDir, "..", ".deploy-sftp-dist.zip");
-  const resolvedZipPath = path2.resolve(zipPath);
+  const zipPath = path4.join(params.localDir, "..", ".deploy-sftp-dist.zip");
+  const resolvedZipPath = path4.resolve(zipPath);
   const packOnly = Boolean(params.packOnly);
   const archiveDeployArtifact = Boolean(params.archiveDeployArtifact);
   const deploymentRunId = resolveDeploymentRunIdFromEnv();
@@ -4546,38 +4641,44 @@ async function runWisdomSftpDeploy(params) {
   });
   let zipSizeBytes = 0;
   let artifactUploaded = false;
-  try {
-    zipSizeBytes = await zipDirectory(params.localDir, resolvedZipPath);
-    if (!packOnly) {
+  if (packOnly && artifactUpload.upload) {
+    const packed = await packDirectoryWithMinioArchive({
+      localDir: params.localDir,
+      zipPath: resolvedZipPath,
+      projectName: params.projectName,
+      kind: "frontend",
+      uploadWithoutRunId: artifactUpload.uploadWithoutRunId,
+      skipMessage: "[apm] \u4EC5\u6253\u5305\u6A21\u5F0F\uFF1A\u8DF3\u8FC7 SFTP \u8FDC\u7A0B\u4E0A\u4F20",
+      successMessage: "\u6253\u5305\u5E76\u4E0A\u4F20 MinIO \u5B8C\u6210\uFF08\u672A\u4E0A\u4F20\u8FDC\u7A0B\u670D\u52A1\u5668\uFF09"
+    });
+    zipSizeBytes = packed.zipSizeBytes;
+    artifactUploaded = packed.artifactUploaded;
+  } else {
+    try {
+      zipSizeBytes = await zipDirectory(params.localDir, resolvedZipPath);
       await uploadAndMaybeExtract(
         params.settings,
         resolvedZipPath,
         params.extract
       );
-    } else {
-      console.error("[apm] \u4EC5\u6253\u5305\u6A21\u5F0F\uFF1A\u8DF3\u8FC7 SFTP \u8FDC\u7A0B\u4E0A\u4F20");
-    }
-    if (artifactUpload.upload) {
-      const artifact = await uploadDeployArtifactZip({
-        zipPath: resolvedZipPath,
-        projectName: params.projectName,
-        kind: "frontend",
-        uploadWithoutRunId: artifactUpload.uploadWithoutRunId
-      });
-      artifactUploaded = artifact !== null;
-    }
-    if (artifactUploaded) {
-      if (packOnly) {
-        console.error("\u6253\u5305\u5E76\u4E0A\u4F20 MinIO \u5B8C\u6210\uFF08\u672A\u4E0A\u4F20\u8FDC\u7A0B\u670D\u52A1\u5668\uFF09");
-      } else {
+      if (artifactUpload.upload) {
+        const artifact = await uploadDeployArtifactZip({
+          zipPath: resolvedZipPath,
+          projectName: params.projectName,
+          kind: "frontend",
+          uploadWithoutRunId: artifactUpload.uploadWithoutRunId
+        });
+        artifactUploaded = artifact !== null;
+      }
+      if (artifactUploaded) {
         console.error("[apm] SFTP \u90E8\u7F72\u5B8C\u6210\uFF0C\u90E8\u7F72\u4EA7\u7269\u5DF2\u5F52\u6863 MinIO");
       }
-    }
-  } finally {
-    try {
-      await unlink(resolvedZipPath);
-      console.error(`\u5DF2\u6E05\u7406\u672C\u5730\u4E34\u65F6\u6587\u4EF6: ${resolvedZipPath}`);
-    } catch {
+    } finally {
+      try {
+        await unlink2(resolvedZipPath);
+        console.error(`\u5DF2\u6E05\u7406\u672C\u5730\u4E34\u65F6\u6587\u4EF6: ${resolvedZipPath}`);
+      } catch {
+      }
     }
   }
   return {
@@ -4592,7 +4693,7 @@ async function runWisdomSftpDeploy(params) {
   };
 }
 
-// src/commands/deploy/internal/wisdom-backend-deploy.ts
+// src/commands/deploy/internal/wisdom-backend/internal-utils.ts
 var SPRINGBOOT_JAVA_OPTS = "-XX:+UseG1GC -XX:+HeapDumpOnOutOfMemoryError -Xms512M -Xmx1G";
 var MAVEN_MODULE = "jeecg-module-system/jeecg-system-start";
 var MAVEN_PROFILE = "dev";
@@ -4605,11 +4706,11 @@ function log(message) {
 }
 function fail(message) {
   log(`ERROR: ${message}`);
-  process.exit(1);
+  throw new DeployExecutionError(message, 1);
 }
 function expandPath(pathStr) {
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return path3.resolve(pathStr.replace(/^~(?=\/|\\|$)/, home));
+  return path5.resolve(pathStr.replace(/^~(?=\/|\\|$)/, home));
 }
 function quoteForShell(value) {
   if (process.platform === "win32") {
@@ -4623,34 +4724,14 @@ function formatMavenLocalRepoArg(repoPath) {
   }
   return `-Dmaven.repo.local=${repoPath}`;
 }
-function deployCacheDir() {
-  return path3.join(workspaceApmDir(), "deploy", ".deploy_cache");
-}
-function manifestFilePath() {
-  return path3.join(deployCacheDir(), "manifest.json");
-}
 function getTargetDir(projectRoot) {
-  return path3.join(projectRoot, MAVEN_MODULE, "target");
-}
-function relativeKey(projectRoot, filePath) {
-  return path3.relative(projectRoot, filePath).split(path3.sep).join("/");
-}
-function fileSignature(filePath) {
-  const stat2 = statSync6(filePath);
-  return { size: stat2.size, mtime: stat2.mtimeMs / 1e3 };
-}
-function loadManifest3() {
-  const manifestPath2 = manifestFilePath();
-  if (!existsSync15(manifestPath2)) {
-    return {};
-  }
-  return JSON.parse(readFileSync12(manifestPath2, "utf8"));
+  return path5.join(projectRoot, MAVEN_MODULE, "target");
 }
-function saveManifest3(manifest) {
-  const dir = deployCacheDir();
-  mkdirSync7(dir, { recursive: true });
-  writeFileSync12(manifestFilePath(), JSON.stringify(manifest, null, 2), "utf8");
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "");
 }
+
+// src/commands/deploy/internal/wisdom-backend/jar-incremental.ts
 function isProjectLibJar(jarName) {
   return jarName.startsWith("jeecg-");
 }
@@ -4658,12 +4739,12 @@ function shouldUploadLibFile(localPath, remoteAttr, manifest, projectRoot) {
   if (!remoteAttr) {
     return [false, "\u8FDC\u7A0B\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7"];
   }
-  const localSize = statSync6(localPath).size;
+  const localSize = statSync7(localPath).size;
   const remoteSize = remoteAttr.size;
   if (localSize !== remoteSize) {
     return [true, `\u5927\u5C0F\u53D8\u5316 ${remoteSize} -> ${localSize}`];
   }
-  if (isProjectLibJar(path3.basename(localPath)) && manifest) {
+  if (isProjectLibJar(path6.basename(localPath)) && manifest) {
     const key = relativeKey(projectRoot, localPath);
     const current = fileSignature(localPath);
     const previous = manifest[key];
@@ -4683,7 +4764,7 @@ function listLibFilesToUpload(localLibDir, remoteStats, projectRoot, manifest =
   const entries = [];
   const jarFiles = readdirSync5(localLibDir).filter((name) => name.endsWith(".jar")).sort();
   for (const jarName of jarFiles) {
-    const jarPath = path3.join(localLibDir, jarName);
+    const jarPath = path6.join(localLibDir, jarName);
     const remoteAttr = remoteStats.get(jarName);
     const [shouldUpload, reason] = shouldUploadLibFile(
       jarPath,
@@ -4697,20 +4778,14 @@ function listLibFilesToUpload(localLibDir, remoteStats, projectRoot, manifest =
   }
   return entries;
 }
-function updateManifestEntries(manifest, entries, projectRoot) {
-  for (const entry of entries) {
-    manifest[relativeKey(projectRoot, entry.path)] = fileSignature(entry.path);
-  }
-  return manifest;
-}
 async function createUpdatePackage(entries, packageName) {
-  const dir = deployCacheDir();
-  mkdirSync7(dir, { recursive: true });
-  const zipPath = path3.join(dir, packageName);
-  log(`\u521B\u5EFA\u66F4\u65B0\u5305: ${path3.basename(zipPath)}\uFF08${entries.length} \u4E2A\u6587\u4EF6\uFF09`);
+  const dir = deployCacheDirectory();
+  mkdirSync8(dir, { recursive: true });
+  const zipPath = path6.join(dir, packageName);
+  log(`\u521B\u5EFA\u66F4\u65B0\u5305: ${path6.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 = readFileSync14(entry.path);
     zip.file(entry.arcname, content);
     log(`  \u6253\u5305: ${entry.arcname} (${entry.reason})`);
   }
@@ -4719,9 +4794,21 @@ async function createUpdatePackage(entries, packageName) {
     compression: "DEFLATE",
     compressionOptions: { level: 6 }
   });
-  writeFileSync12(zipPath, buffer);
+  writeFileSync13(zipPath, buffer);
   return zipPath;
 }
+function listAllLibFilesForArchive(libDir) {
+  return readdirSync5(libDir).filter((name) => name.endsWith(".jar")).sort().map((jarName) => ({
+    path: path6.join(libDir, jarName),
+    arcname: jarName,
+    reason: "\u4EC5\u6253\u5305\u5F52\u6863"
+  }));
+}
+
+// src/commands/deploy/internal/wisdom-backend/maven-build.ts
+import { existsSync as existsSync18, readdirSync as readdirSync6, statSync as statSync8 } from "node:fs";
+import path7 from "node:path";
+import { spawnSync as spawnSync6 } from "node:child_process";
 function getMvnExecutable() {
   const isWin = process.platform === "win32";
   const candidates = isWin ? ["mvn.cmd", "mvn.bat", "mvn"] : ["mvn"];
@@ -4768,14 +4855,14 @@ function runMavenBuild(projectRoot, mavenLocalRepo, repoSource) {
 }
 function locateLibDir(projectRoot) {
   const targetDir = getTargetDir(projectRoot);
-  if (!existsSync15(targetDir)) {
+  if (!existsSync18(targetDir)) {
     fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
   }
-  const libDir = path3.join(targetDir, "lib");
-  if (!existsSync15(libDir) || !statSync6(libDir).isDirectory()) {
+  const libDir = path7.join(targetDir, "lib");
+  if (!existsSync18(libDir) || !statSync8(libDir).isDirectory()) {
     fail(`lib \u76EE\u5F55\u4E0D\u5B58\u5728: ${libDir}`);
   }
-  const libJars = readdirSync5(libDir).filter((name) => name.endsWith(".jar"));
+  const libJars = readdirSync6(libDir).filter((name) => name.endsWith(".jar"));
   if (libJars.length === 0) {
     fail(`lib \u76EE\u5F55\u4E0B\u6CA1\u6709\u4F9D\u8D56 JAR: ${libDir}`);
   }
@@ -4784,124 +4871,24 @@ function locateLibDir(projectRoot) {
 }
 function locateMainJar(projectRoot) {
   const targetDir = getTargetDir(projectRoot);
-  if (!existsSync15(targetDir)) {
+  if (!existsSync18(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) => path3.join(targetDir, name)).sort((a, b) => statSync6(b).mtimeMs - statSync6(a).mtimeMs);
+  const jarFiles = readdirSync6(targetDir).filter((name) => name.endsWith(".jar") && !name.endsWith(".jar.original")).map((name) => path7.join(targetDir, name)).sort((a, b) => statSync8(b).mtimeMs - statSync8(a).mtimeMs);
   if (jarFiles.length === 0) {
     fail(`target \u76EE\u5F55\u4E0B\u6CA1\u6709\u4E3B JAR: ${targetDir}`);
   }
   const mainJar = jarFiles[0];
-  log(`\u5B9A\u4F4D\u4E3B JAR \u4EA7\u7269: ${path3.basename(mainJar)}`);
+  log(`\u5B9A\u4F4D\u4E3B JAR \u4EA7\u7269: ${path7.basename(mainJar)}`);
   return mainJar;
 }
-async function connectSsh(config) {
-  const client = new Client2();
-  log(`\u8FDE\u63A5\u670D\u52A1\u5668 ${config.username}@${config.host}:${config.port}`);
-  await new Promise((resolve5, reject) => {
-    client.on("ready", () => resolve5()).on("error", (err) => reject(err)).connect({
-      host: config.host,
-      port: config.port,
-      username: config.username,
-      password: config.password,
-      readyTimeout: 3e4,
-      tryKeyboard: true
-    });
-  });
-  const sftp = new SftpClient2();
-  await sftp.connect({
-    host: config.host,
-    port: config.port,
-    username: config.username,
-    password: config.password,
-    readyTimeout: 3e4,
-    tryKeyboard: true
-  });
-  return { client, sftp };
-}
-async function closeSsh(conn) {
-  try {
-    await conn.sftp.end();
-  } catch {
-  }
-  conn.client.end();
-}
-async function getRemoteFileStats(sftp, remoteDir) {
-  const stats = /* @__PURE__ */ new Map();
-  try {
-    const listing = await sftp.list(remoteDir);
-    for (const item of listing) {
-      if (item.name.endsWith(".jar")) {
-        stats.set(item.name, { filename: item.name, size: item.size });
-      }
-    }
-  } catch {
-  }
-  return stats;
-}
-async function uploadUpdatePackage(sftp, zipPath, config) {
-  const remoteDir = config.remoteVueDistDir.replace(/\/$/, "");
-  const remotePath = `${remoteDir}/${path3.basename(zipPath)}`;
-  log(`\u4E0A\u4F20\u66F4\u65B0\u5305 -> ${remotePath}`);
-  try {
-    await sftp.fastPut(zipPath, remotePath);
-    log("\u66F4\u65B0\u5305\u4E0A\u4F20\u6210\u529F");
-  } catch (err) {
-    fail(`\u66F4\u65B0\u5305\u4E0A\u4F20\u5931\u8D25: ${err instanceof Error ? err.message : err}`);
-  }
-  return remotePath;
-}
-async function uploadFullJar(sftp, localJarPath, config) {
-  const remoteDir = config.remoteAppDir.replace(/\/$/, "");
-  const remotePath = `${remoteDir}/${config.startupJar}`;
-  log(`\u4E0A\u4F20\u5168\u91CF JAR (${path3.basename(localJarPath)}) -> ${remotePath}`);
-  try {
-    await sftp.mkdir(remoteDir, true);
-    await sftp.fastPut(localJarPath, remotePath);
-    log("\u5168\u91CF JAR \u4E0A\u4F20\u6210\u529F");
-  } catch (err) {
-    fail(`\u5168\u91CF JAR \u4E0A\u4F20\u5931\u8D25: ${err instanceof Error ? err.message : err}`);
-  }
-}
-async function runRemoteCommand(client, command, options) {
-  const check = options?.check ?? true;
-  const stream = options?.stream ?? false;
-  const label = options?.label ?? "\u8FDC\u7A0B\u547D\u4EE4";
-  return new Promise((resolve5, reject) => {
-    client.exec(command, (err, execStream) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      let out = "";
-      let errText = "";
-      execStream.on("data", (data) => {
-        const text = data.toString();
-        out += text;
-        if (stream) {
-          process.stdout.write(text);
-        }
-      });
-      execStream.stderr.on("data", (data) => {
-        errText += data.toString();
-      });
-      execStream.on("close", (code) => {
-        if (stream && out && !out.endsWith("\n")) {
-          process.stdout.write("\n");
-        }
-        if (check && code !== 0) {
-          const combined = `${out}
-${errText}`.trim();
-          fail(
-            `${label}\u5931\u8D25 (exit ${code})` + (combined ? `
-\u8F93\u51FA: ${combined}` : "")
-          );
-        }
-        resolve5({ exitCode: code, out: out.trim(), err: errText.trim() });
-      });
-    });
-  });
-}
+
+// src/commands/deploy/internal/wisdom-backend/remote-deploy.ts
+import path8 from "node:path";
+import { Client as Client2 } from "ssh2";
+import SftpClient2 from "ssh2-sftp-client";
+
+// src/commands/deploy/internal/wisdom-backend/remote-scripts.ts
 function buildExtractUpdatePackageScript(remoteZipPath, remoteLibDir) {
   const quotedZip = shellSingleQuote(remoteZipPath);
   const quotedLib = shellSingleQuote(remoteLibDir);
@@ -4925,39 +4912,6 @@ done < <(find "$TMP" -name '*.jar' -type f -print0)
 echo "UPDATED_COUNT=$updated"
 `.trim();
 }
-async function extractUpdatePackageOnRemote(client, config, remoteZipPath) {
-  const script = buildExtractUpdatePackageScript(
-    remoteZipPath,
-    config.remoteLibDir
-  );
-  const { out } = await runRemoteCommand(client, script, {
-    label: "\u8FDC\u7A0B\u89E3\u538B"
-  });
-  const match = out.match(/UPDATED_COUNT=(\d+)/);
-  if (!match) {
-    fail(`\u8FDC\u7A0B\u89E3\u538B\u5931\u8D25\uFF0C\u672A\u83B7\u53D6\u66F4\u65B0\u6570\u91CF
-\u8F93\u51FA: ${out || "(\u7A7A)"}`);
-  }
-  const updated = Number.parseInt(match[1], 10);
-  log(`lib \u89E3\u538B\u5B8C\u6210: \u8986\u76D6 ${updated} \u4E2A`);
-  return updated;
-}
-function springbootOutputIndicatesSuccess(action, combined) {
-  const lower = combined.toLowerCase();
-  if (action === "health") {
-    return combined.includes("\u5065\u5EB7\u68C0\u67E5\u901A\u8FC7");
-  }
-  if (action === "start" || action === "restart") {
-    return combined.includes("is starting") || lower.includes("is running");
-  }
-  if (action === "stop") {
-    return combined.includes("is stopping") || lower.includes("not running") || lower.includes("please check it");
-  }
-  if (action === "status") {
-    return lower.includes("running") || lower.includes("not running");
-  }
-  return true;
-}
 function buildRemoteStatusScript(remoteAppDir, appName) {
   const dir = shellSingleQuote(remoteAppDir);
   const jar = shellSingleQuote(appName);
@@ -5056,6 +5010,150 @@ echo -e "\\033[31m\u5065\u5EB7\u68C0\u67E5\u8D85\u65F6 (\${timeout}s): \${check_
 exit 1
 `.trim();
 }
+function springbootOutputIndicatesSuccess(action, combined) {
+  const lower = combined.toLowerCase();
+  if (action === "health") {
+    return combined.includes("\u5065\u5EB7\u68C0\u67E5\u901A\u8FC7");
+  }
+  if (action === "start" || action === "restart") {
+    return combined.includes("is starting") || lower.includes("is running");
+  }
+  if (action === "stop") {
+    return combined.includes("is stopping") || lower.includes("not running") || lower.includes("please check it");
+  }
+  if (action === "status") {
+    return lower.includes("running") || lower.includes("not running");
+  }
+  return true;
+}
+
+// src/commands/deploy/internal/wisdom-backend/remote-deploy.ts
+async function connectSsh(config) {
+  const client = new Client2();
+  log(`\u8FDE\u63A5\u670D\u52A1\u5668 ${config.username}@${config.host}:${config.port}`);
+  await new Promise((resolve6, reject) => {
+    client.on("ready", () => resolve6()).on("error", (err) => reject(err)).connect({
+      host: config.host,
+      port: config.port,
+      username: config.username,
+      password: config.password,
+      readyTimeout: 3e4,
+      tryKeyboard: true
+    });
+  });
+  const sftp = new SftpClient2();
+  await sftp.connect({
+    host: config.host,
+    port: config.port,
+    username: config.username,
+    password: config.password,
+    readyTimeout: 3e4,
+    tryKeyboard: true
+  });
+  return { client, sftp };
+}
+async function closeSsh(conn) {
+  try {
+    await conn.sftp.end();
+  } catch {
+  }
+  conn.client.end();
+}
+async function getRemoteFileStats(sftp, remoteDir) {
+  const stats = /* @__PURE__ */ new Map();
+  try {
+    const listing = await sftp.list(remoteDir);
+    for (const item of listing) {
+      if (item.name.endsWith(".jar")) {
+        stats.set(item.name, { filename: item.name, size: item.size });
+      }
+    }
+  } catch {
+  }
+  return stats;
+}
+async function uploadUpdatePackage(sftp, zipPath, config) {
+  const remoteDir = config.remoteVueDistDir.replace(/\/$/, "");
+  const remotePath = `${remoteDir}/${path8.basename(zipPath)}`;
+  log(`\u4E0A\u4F20\u66F4\u65B0\u5305 -> ${remotePath}`);
+  try {
+    await sftp.fastPut(zipPath, remotePath);
+    log("\u66F4\u65B0\u5305\u4E0A\u4F20\u6210\u529F");
+  } catch (err) {
+    fail(`\u66F4\u65B0\u5305\u4E0A\u4F20\u5931\u8D25: ${err instanceof Error ? err.message : err}`);
+  }
+  return remotePath;
+}
+async function uploadFullJar(sftp, localJarPath, config) {
+  const remoteDir = config.remoteAppDir.replace(/\/$/, "");
+  const remotePath = `${remoteDir}/${config.startupJar}`;
+  log(`\u4E0A\u4F20\u5168\u91CF JAR (${path8.basename(localJarPath)}) -> ${remotePath}`);
+  try {
+    await sftp.mkdir(remoteDir, true);
+    await sftp.fastPut(localJarPath, remotePath);
+    log("\u5168\u91CF JAR \u4E0A\u4F20\u6210\u529F");
+  } catch (err) {
+    fail(`\u5168\u91CF JAR \u4E0A\u4F20\u5931\u8D25: ${err instanceof Error ? err.message : err}`);
+  }
+}
+async function runRemoteCommand(client, command, options) {
+  const check = options?.check ?? true;
+  const stream = options?.stream ?? false;
+  const label = options?.label ?? "\u8FDC\u7A0B\u547D\u4EE4";
+  return new Promise((resolve6, reject) => {
+    client.exec(command, (err, execStream) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      let out = "";
+      let errText = "";
+      execStream.on("data", (data) => {
+        const text = data.toString();
+        out += text;
+        if (stream) {
+          process.stdout.write(text);
+        }
+      });
+      execStream.stderr.on("data", (data) => {
+        errText += data.toString();
+      });
+      execStream.on("close", (code) => {
+        if (stream && out && !out.endsWith("\n")) {
+          process.stdout.write("\n");
+        }
+        if (check && code !== 0) {
+          const combined = `${out}
+${errText}`.trim();
+          fail(
+            `${label}\u5931\u8D25 (exit ${code})` + (combined ? `
+\u8F93\u51FA: ${combined}` : "")
+          );
+        }
+        resolve6({ exitCode: code, out: out.trim(), err: errText.trim() });
+      });
+    });
+  });
+}
+async function extractUpdatePackageOnRemote(client, config, remoteZipPath) {
+  const script = buildExtractUpdatePackageScript(
+    remoteZipPath,
+    config.remoteLibDir
+  );
+  const { out } = await runRemoteCommand(client, script, {
+    label: "\u8FDC\u7A0B\u89E3\u538B"
+  });
+  const match = out.match(/UPDATED_COUNT=(\d+)/);
+  if (!match) {
+    fail(`\u8FDC\u7A0B\u89E3\u538B\u5931\u8D25\uFF0C\u672A\u83B7\u53D6\u66F4\u65B0\u6570\u91CF
+\u8F93\u51FA: ${out || "(\u7A7A)"}`);
+  }
+  const updated = Number.parseInt(match[1], 10);
+  log(`lib \u89E3\u538B\u5B8C\u6210: \u8986\u76D6 ${updated} \u4E2A`);
+  return updated;
+}
+
+// src/commands/deploy/internal/wisdom-backend/health-check.ts
 async function runRemoteServiceScript(client, script, action) {
   const { exitCode, out, err } = await runRemoteCommand(client, script, {
     check: false,
@@ -5081,9 +5179,6 @@ ${combined}`);
   }
   return combined;
 }
-function stripAnsi(text) {
-  return text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "");
-}
 async function getRunningJar(client, config) {
   const script = buildRemoteStatusScript(
     config.remoteAppDir,
@@ -5112,19 +5207,14 @@ async function restartRemoteService(client, config) {
   const script = buildRemoteRestartScript(config.remoteAppDir);
   await runRemoteServiceScript(client, script, "restart");
 }
-function listAllLibFilesForArchive(libDir) {
-  return readdirSync5(libDir).filter((name) => name.endsWith(".jar")).sort().map((jarName) => ({
-    path: path3.join(libDir, jarName),
-    arcname: jarName,
-    reason: "\u4EC5\u6253\u5305\u5F52\u6863"
-  }));
-}
+
+// src/commands/deploy/internal/wisdom-backend/index.ts
 async function runWisdomBackendDeploy(options) {
-  const projectRoot = path3.resolve(options.projectRoot ?? process.cwd());
+  const projectRoot = path9.resolve(options.projectRoot ?? process.cwd());
   const config = options.config;
   const packOnly = Boolean(options.packOnly);
   log(`=== \u81EA\u52A8\u90E8\u7F72: ${config.projectName} ===`);
-  log(`\u914D\u7F6E\u6587\u4EF6: ${path3.join(workspaceApmDir(), "apm.config.json")}`);
+  log(`\u914D\u7F6E\u6587\u4EF6: ${path9.join(workspaceApmDir(), "apm.config.json")}`);
   log(`\u9879\u76EE\u6839\u76EE\u5F55: ${projectRoot}`);
   log(
     `\u90E8\u7F72\u6A21\u5F0F: ${config.mode}${config.mode === "full" ? "\uFF08\u5168\u91CF JAR\uFF0C\u8DF3\u8FC7 lib \u68C0\u67E5\uFF09" : "\uFF08\u589E\u91CF lib \u66F4\u65B0\uFF09"}${packOnly ? "\uFF1B\u4EC5\u6253\u5305\uFF08\u4E0D\u4E0A\u4F20\u8FDC\u7A0B\uFF09" : ""}`
@@ -5141,7 +5231,7 @@ async function runWisdomBackendDeploy(options) {
         [
           {
             path: mainJar,
-            arcname: path3.basename(mainJar),
+            arcname: path9.basename(mainJar),
             reason: "\u5168\u91CF JAR \u5F52\u6863"
           }
         ],
@@ -5179,7 +5269,7 @@ async function runWisdomBackendDeploy(options) {
         [
           {
             path: mainJar,
-            arcname: path3.basename(mainJar),
+            arcname: path9.basename(mainJar),
             reason: "\u5168\u91CF JAR \u5F52\u6863"
           }
         ],
@@ -5263,15 +5353,15 @@ function isWisdomDeployConfigured(cfg) {
   return Boolean(w?.host?.trim() && w?.remotePath?.trim());
 }
 function detectWisdomProjectType(cwd) {
-  return existsSync16(path4.join(cwd, "package.json")) ? "frontend" : "backend";
+  return existsSync19(path10.join(cwd, "package.json")) ? "frontend" : "backend";
 }
 function readPackageScripts(cwd) {
-  const pkgPath = path4.join(cwd, "package.json");
-  if (!existsSync16(pkgPath)) {
+  const pkgPath = path10.join(cwd, "package.json");
+  if (!existsSync19(pkgPath)) {
     return {};
   }
   try {
-    const raw = readFileSync13(pkgPath, "utf8");
+    const raw = readFileSync15(pkgPath, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.scripts ?? {};
   } catch {
@@ -5284,20 +5374,23 @@ function resolveFrontendBuildCommand(env, cwd) {
   if (scripts[buildKey]?.trim()) {
     return `npm run build:${env}`;
   }
+  if (isProductionDeployEnv(env) && scripts.build?.trim()) {
+    return "npm run build";
+  }
   return null;
 }
 function resolveFrontendDistDir(cwd) {
   const candidates = ["dist", "apps/web/dist"];
   for (const rel of candidates) {
-    const full = path4.join(cwd, rel);
+    const full = path10.join(cwd, rel);
     try {
-      if (existsSync16(full) && statSync7(full).isDirectory()) {
+      if (existsSync19(full) && statSync9(full).isDirectory()) {
         return full;
       }
     } catch {
     }
   }
-  return path4.join(cwd, "dist");
+  return path10.join(cwd, "dist");
 }
 async function executeWisdomFrontendDeploy(options) {
   const { cwd, cfg, captureOutput, packOnly, archiveDeployArtifact } = options;
@@ -5314,7 +5407,7 @@ async function executeWisdomFrontendDeploy(options) {
   if (!buildCmd) {
     const lines = formatWisdomFrontendBuildNotConfiguredLines(
       options.env,
-      path4.join(cwd, "package.json")
+      path10.join(cwd, "package.json")
     );
     throw new DeployExecutionError(lines.join("\n"), 1, lines.join("\n"));
   }
@@ -5322,16 +5415,9 @@ async function executeWisdomFrontendDeploy(options) {
     `[apm] Vue\uFF1A${buildCmd}` + (packOnly ? "\uFF08\u4EC5\u6253\u5305\uFF0C\u8DF3\u8FC7 SFTP\uFF09" : " \u2192 SFTP \u4E0A\u4F20\u5E76\u8FDC\u7A0B\u89E3\u538B" + (archiveDeployArtifact ? " \u2192 \u5E73\u53F0\u90E8\u7F72\u4EA7\u7269\u5F52\u6863" : ""))
   );
   runDeployShellCommand(buildCmd, cwd, captureOutput);
-  let projectName = (cfg.name ?? "").trim();
-  if ((packOnly || archiveDeployArtifact) && !projectName) {
-    throw new DeployExecutionError(
-      "\u8BF7\u5728 .apm/apm.config.json \u9876\u5C42\u914D\u7F6E name\uFF08\u4F5C\u4E3A\u90E8\u7F72\u4EA7\u7269\u9879\u76EE\u540D\uFF09",
-      1
-    );
-  }
-  if (!projectName) {
-    projectName = path4.basename(cwd);
-  }
+  const projectName = resolveProjectNameForDeploy(cfg, cwd, {
+    requireName: packOnly || archiveDeployArtifact
+  });
   const settings = resolveWisdomDeployFromApmConfig(cfg);
   await runWisdomSftpDeploy({
     localDir: distDir,
@@ -5359,12 +5445,12 @@ async function executeWisdomBackendDeployFlow(options) {
   });
 }
 async function executeWisdomDeploy(options) {
-  const cwd = path4.resolve(options.cwd);
+  const cwd = path10.resolve(options.cwd);
   const captureOutput = options.captureOutput ?? false;
   const packOnly = Boolean(options.packOnly);
   const archiveDeployArtifact = Boolean(options.archiveDeployArtifact);
   const projectType = detectWisdomProjectType(cwd);
-  const configPath = options.configPath ?? path4.join(workspaceApmDir(cwd), "apm.config.json");
+  const configPath = options.configPath ?? path10.join(workspaceApmDir(cwd), "apm.config.json");
   const cfg = loadApmConfig({ configPath });
   console.error(
     `[apm] ${projectType === "frontend" ? "Vue \u524D\u7AEF" : "Java \u540E\u7AEF"}${packOnly ? "\uFF08\u4EC5\u6253\u5305\uFF09" : ""}`
@@ -5527,7 +5613,7 @@ async function executeDeploy(options) {
     throw new DeployExecutionError("[apm] executeDeploy \u7F3A\u5C11\u5DE5\u4F5C\u76EE\u5F55 cwd", 1);
   }
   const cwd = resolveWorkdirPath(cwdInput);
-  const apmConfigPath = options.configPath ?? path5.join(workspaceApmDir(cwd), "apm.config.json");
+  const apmConfigPath = options.configPath ?? path11.join(workspaceApmDir(cwd), "apm.config.json");
   const captureOutput = options.captureOutput ?? false;
   const outputParts = [];
   logExecuteDeployContext({
@@ -5596,11 +5682,36 @@ function printDeployExecutionError(error) {
   console.error(error.message);
 }
 
-// src/commands/connect/deploy-run.ts
-var DEPLOY_LOG_SYNC_INTERVAL_MS = 3e4;
-function resolveDeployCommand(environment, packOnly) {
-  return packOnly ? `apm deploy ${environment} --pack-only` : `apm deploy ${environment}`;
+// src/commands/deploy/platform/deploy-console-capture.ts
+function captureDeployConsole(logSyncer) {
+  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);
+  };
+  return {
+    appendLog,
+    restore: () => {
+      console.log = originalLog;
+      console.error = originalError;
+    },
+    getLog: () => chunks.join("\n")
+  };
 }
+
+// src/commands/deploy/platform/deploy-log-syncer.ts
+var DEPLOY_LOG_SYNC_INTERVAL_MS = 1e4;
 function logDeploySyncFailure(error) {
   console.error(
     "[apm] deploy log sync failed:",
@@ -5610,7 +5721,9 @@ function logDeploySyncFailure(error) {
 function createDeployLogSyncer(api, deploymentRunId) {
   let lastSyncedLog = "";
   let latestLog = "";
-  let timer = null;
+  let lastRunAt = 0;
+  let timer;
+  let syncChain = Promise.resolve();
   const syncDelta = async (delta, append) => {
     const chunks = splitUtf8StringByMaxBytes(
       delta,
@@ -5635,29 +5748,58 @@ function createDeployLogSyncer(api, deploymentRunId) {
     if (!delta) {
       return;
     }
-    await syncDelta(delta, lastSyncedLog.length > 0);
-    lastSyncedLog = latestLog;
+    await syncDelta(delta, lastSyncedLog.length > 0);
+    lastSyncedLog = latestLog;
+  };
+  const enqueueSync = () => {
+    syncChain = syncChain.then(async () => {
+      try {
+        await syncIfChanged();
+        lastRunAt = Date.now();
+      } catch (error) {
+        logDeploySyncFailure(error);
+      }
+    });
+  };
+  const schedule = () => {
+    const now = Date.now();
+    const elapsed = now - lastRunAt;
+    if (elapsed >= DEPLOY_LOG_SYNC_INTERVAL_MS) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      enqueueSync();
+      return;
+    }
+    if (timer) {
+      return;
+    }
+    timer = setTimeout(() => {
+      timer = void 0;
+      enqueueSync();
+    }, DEPLOY_LOG_SYNC_INTERVAL_MS - elapsed);
+  };
+  const stopTimer = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
   };
-  timer = setInterval(() => {
-    void syncIfChanged().catch(logDeploySyncFailure);
-  }, DEPLOY_LOG_SYNC_INTERVAL_MS);
   return {
     updateLog(log2) {
       latestLog = log2;
+      schedule();
     },
     async flush() {
-      if (timer) {
-        clearInterval(timer);
-        timer = null;
-      }
+      stopTimer();
+      await syncChain;
       await syncIfChanged();
     },
     async flushSafe() {
-      if (timer) {
-        clearInterval(timer);
-        timer = null;
-      }
+      stopTimer();
       try {
+        await syncChain;
         await syncIfChanged();
         return true;
       } catch (error) {
@@ -5666,15 +5808,12 @@ function createDeployLogSyncer(api, deploymentRunId) {
       }
     },
     dispose() {
-      if (timer) {
-        clearInterval(timer);
-        timer = null;
-      }
+      stopTimer();
     }
   };
 }
 async function finalizeTaskDeployment(api, deploymentRunId, logSyncer, input) {
-  const synced = await logSyncer.flushSafe();
+  await logSyncer.flushSafe();
   const payload = {
     id: deploymentRunId,
     status: input.status
@@ -5682,76 +5821,48 @@ async function finalizeTaskDeployment(api, deploymentRunId, logSyncer, input) {
   if (input.error) {
     payload.error = input.error;
   }
-  if (!synced) {
-    payload.log = truncateDeployLogForComplete(input.fullLog).log;
-  }
-  await retryDeployLogSync(() => api.cli.completeTaskDeployment(payload));
+  await retryDeployStatusComplete(
+    () => api.cli.completeTaskDeployment(payload)
+  );
 }
-function captureDeployConsole(logSyncer) {
-  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);
-  };
-  return {
-    appendLog,
-    restore: () => {
-      console.log = originalLog;
-      console.error = originalError;
-    },
-    getLog: () => chunks.join("\n")
-  };
+async function ensureDeploymentStatusSynced(api, deploymentRunId, logSyncer, outcome) {
+  await finalizeTaskDeployment(api, deploymentRunId, logSyncer, outcome);
 }
-async function handleInboundDeploy(cfg, msg, signal) {
-  const api = createApmApiClient(cfg);
-  const deploymentRunId = msg.deploymentRunId;
-  if (signal.aborted) return;
-  await api.cli.updateTaskDeploymentStatus({
-    id: deploymentRunId,
-    status: "DEPLOYING"
-  });
-  const workdir = requireRemoteWorkdir(msg.workdir);
-  const displayCommand = resolveDeployCommand(msg.environment, msg.packOnly);
-  console.log(
-    `[apm] deploy start id=${deploymentRunId} env=${msg.environment} cwd=${workdir}`
+
+// src/commands/deploy/platform/deploy-run-coordinator.ts
+function logDeployStatusSyncFailure(error) {
+  console.error(
+    "[apm] deploy status sync failed:",
+    error instanceof Error ? error.message : String(error)
   );
-  console.log(`[apm] deploy command: ${displayCommand}`);
+}
+async function runTrackedDeploy(input) {
+  const { api, deploymentRunId, run } = input;
+  let deploymentStarted = true;
+  let outcome = null;
+  let statusSynced = false;
+  let deployError;
   const logSyncer = createDeployLogSyncer(api, deploymentRunId);
   const previousDeploymentRunId = process.env[APM_DEPLOYMENT_RUN_ID_ENV];
   process.env[APM_DEPLOYMENT_RUN_ID_ENV] = deploymentRunId;
   const capture = captureDeployConsole(logSyncer);
-  const deployOptions = {
-    env: msg.environment,
-    cwd: workdir,
-    packOnly: msg.packOnly,
-    captureOutput: true,
-    archiveDeployArtifact: true,
-    deployTrigger: "connect"
+  const ensureStatusSynced = async () => {
+    if (statusSynced || !outcome) {
+      return;
+    }
+    logSyncer.updateLog(capture.getLog());
+    await ensureDeploymentStatusSynced(
+      api,
+      deploymentRunId,
+      logSyncer,
+      outcome
+    );
+    statusSynced = true;
   };
   try {
-    if (signal.aborted) return;
-    const output = await executeDeploy(deployOptions);
-    if (output.trim()) {
-      capture.appendLog(output);
-    }
-    await finalizeTaskDeployment(api, deploymentRunId, logSyncer, {
-      status: "SUCCESS",
-      fullLog: capture.getLog()
-    });
-    console.log(`[apm] deploy success id=${deploymentRunId}`);
+    outcome = await run(capture.appendLog);
   } catch (error) {
-    const deployError = error instanceof DeployExecutionError ? error : new DeployExecutionError(
+    deployError = error instanceof DeployExecutionError ? error : new DeployExecutionError(
       error instanceof Error ? error.message : String(error),
       1
     );
@@ -5760,22 +5871,18 @@ async function handleInboundDeploy(cfg, msg, signal) {
     } else {
       capture.appendLog(deployError.message);
     }
-    try {
-      await finalizeTaskDeployment(api, deploymentRunId, logSyncer, {
-        status: "FAILED",
-        fullLog: capture.getLog(),
-        error: deployError.message
-      });
-    } catch (finalizeError) {
-      console.error(
-        `[apm] deploy finalize failed id=${deploymentRunId}:`,
-        finalizeError instanceof Error ? finalizeError.message : String(finalizeError)
-      );
-    }
-    console.error(
-      `[apm] deploy failed id=${deploymentRunId}: ${deployError.message}`
-    );
+    outcome = { status: "FAILED", error: deployError.message };
   } finally {
+    if (deploymentStarted && !statusSynced) {
+      if (!outcome) {
+        outcome = { status: "FAILED", error: "\u90E8\u7F72\u672A\u5B8C\u6210" };
+      }
+      try {
+        await ensureStatusSynced();
+      } catch (error) {
+        logDeployStatusSyncFailure(error);
+      }
+    }
     capture.restore();
     if (previousDeploymentRunId === void 0) {
       delete process.env[APM_DEPLOYMENT_RUN_ID_ENV];
@@ -5784,6 +5891,58 @@ async function handleInboundDeploy(cfg, msg, signal) {
     }
     logSyncer.dispose();
   }
+  return { outcome, error: deployError };
+}
+
+// src/commands/connect/deploy-run.ts
+function resolveDeployCommand(environment, packOnly) {
+  return packOnly ? `apm deploy ${environment} --pack-only` : `apm deploy ${environment}`;
+}
+async function handleInboundDeploy(cfg, msg, signal) {
+  if (signal.aborted) return;
+  const api = createApmApiClient(cfg);
+  const deploymentRunId = msg.deploymentRunId;
+  await api.cli.updateTaskDeploymentStatus({
+    id: deploymentRunId,
+    status: "DEPLOYING"
+  });
+  const { error: deployError } = await runTrackedDeploy({
+    api,
+    deploymentRunId,
+    run: async (appendLog) => {
+      const workdir = requireRemoteWorkdir(msg.workdir);
+      const displayCommand = resolveDeployCommand(
+        msg.environment,
+        msg.packOnly
+      );
+      console.log(
+        `[apm] deploy start id=${deploymentRunId} env=${msg.environment} cwd=${workdir}`
+      );
+      console.log(`[apm] deploy command: ${displayCommand}`);
+      if (signal.aborted) {
+        return { status: "FAILED", error: "\u90E8\u7F72\u5DF2\u53D6\u6D88" };
+      }
+      const deployOptions = {
+        env: msg.environment,
+        cwd: workdir,
+        packOnly: msg.packOnly,
+        captureOutput: true,
+        archiveDeployArtifact: true,
+        deployTrigger: "connect"
+      };
+      const output = await executeDeploy(deployOptions);
+      if (output.trim()) {
+        appendLog(output);
+      }
+      console.log(`[apm] deploy success id=${deploymentRunId}`);
+      return { status: "SUCCESS" };
+    }
+  });
+  if (deployError) {
+    console.error(
+      `[apm] deploy failed id=${deploymentRunId}: ${deployError.message}`
+    );
+  }
 }
 
 // src/commands/connect/abort-signal-debug.ts
@@ -6053,17 +6212,17 @@ ${JSON.stringify(event, null, 2)}
 }
 
 // src/commands/connect/agent-session-registry.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname6, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync9, readFileSync as readFileSync16, writeFileSync as writeFileSync14 } from "node:fs";
+import { dirname as dirname6, resolve as resolve5 } from "node:path";
 function registryPath(workdir, sessionId) {
-  return resolve4(workdir, ".apm", "sessions", sessionId, "cursor-agents.json");
+  return resolve5(workdir, ".apm", "sessions", sessionId, "cursor-agents.json");
 }
-function readRegistry(path13) {
-  if (!existsSync17(path13)) {
+function readRegistry(path19) {
+  if (!existsSync20(path19)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync14(path13, "utf8"));
+    const parsed = JSON.parse(readFileSync16(path19, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const result = {};
       for (const [key, value] of Object.entries(
@@ -6079,9 +6238,9 @@ function readRegistry(path13) {
   }
   return {};
 }
-function writeRegistry(path13, registry) {
-  mkdirSync8(dirname6(path13), { recursive: true });
-  writeFileSync13(path13, `${JSON.stringify(registry, null, 2)}
+function writeRegistry(path19, registry) {
+  mkdirSync9(dirname6(path19), { recursive: true });
+  writeFileSync14(path19, `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 function loadSessionAgentId(workdir, sessionId, user) {
@@ -6089,19 +6248,19 @@ function loadSessionAgentId(workdir, sessionId, user) {
   return registry[user];
 }
 function saveSessionAgentId(workdir, sessionId, user, agentId) {
-  const path13 = registryPath(workdir, sessionId);
-  const registry = readRegistry(path13);
+  const path19 = registryPath(workdir, sessionId);
+  const registry = readRegistry(path19);
   registry[user] = agentId;
-  writeRegistry(path13, registry);
+  writeRegistry(path19, registry);
 }
 function clearSessionAgentId(workdir, sessionId, user) {
-  const path13 = registryPath(workdir, sessionId);
-  const registry = readRegistry(path13);
+  const path19 = registryPath(workdir, sessionId);
+  const registry = readRegistry(path19);
   if (!(user in registry)) {
     return;
   }
   delete registry[user];
-  writeRegistry(path13, registry);
+  writeRegistry(path19, registry);
 }
 
 // src/commands/connect/cursor-message-log.ts
@@ -6531,20 +6690,20 @@ async function ensureMessageHasReply(cfg, sessionId, messageId, fallback) {
 }
 
 // src/commands/connect/cli-version-sync.ts
-import { existsSync as existsSync18, readFileSync as readFileSync15, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync17, writeFileSync as writeFileSync15 } from "fs";
 import { join as join17 } from "path";
 var CLI_VERSION_FILE = ".cli-version.json";
 function manifestPath(apmDir) {
   return join17(apmDir, CLI_VERSION_FILE);
 }
 function loadManifest4(apmDir) {
-  const path13 = toFsPath(manifestPath(apmDir));
-  if (!existsSync18(path13)) {
+  const path19 = toFsPath(manifestPath(apmDir));
+  if (!existsSync21(path19)) {
     return null;
   }
   try {
     const parsed = JSON.parse(
-      readFileSync15(path13, "utf8")
+      readFileSync17(path19, "utf8")
     );
     if (parsed?.version === 1 && typeof parsed.cliVersion === "string" && parsed.cliVersion.trim()) {
       return parsed;
@@ -6555,7 +6714,7 @@ function loadManifest4(apmDir) {
 }
 function saveManifest4(apmDir, cliVersion) {
   const manifest = { version: 1, cliVersion };
-  writeFileSync14(
+  writeFileSync15(
     toFsPath(manifestPath(apmDir)),
     `${JSON.stringify(manifest, null, 2)}
 `,
@@ -6634,7 +6793,7 @@ function createRunSlotPool(maxConcurrent = DEFAULT_MAX_CONCURRENT, options = {})
       );
     }
     const queuedAt = Date.now();
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       waiters.push(() => {
         active += 1;
         const waitedMs = Date.now() - queuedAt;
@@ -6645,7 +6804,7 @@ function createRunSlotPool(maxConcurrent = DEFAULT_MAX_CONCURRENT, options = {})
             )}s\uFF0C\u5F53\u524D\u5360\u7528 ${active}/${maxConcurrent}`
           );
         }
-        resolve5();
+        resolve6();
       });
     });
   };
@@ -6820,11 +6979,11 @@ 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);
+  return new Promise((resolve6) => {
+    const timer = setTimeout(resolve6, ms);
     const onAbort = () => {
       clearTimeout(timer);
-      resolve5();
+      resolve6();
     };
     signal.addEventListener("abort", onAbort, { once: true });
   });
@@ -6964,7 +7123,7 @@ function attachWsHandlers(ws, ctx, onOpen) {
   });
 }
 function connectOnce(url, ctx, connectionAbort, onConnected) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const ws = new WebSocket(url);
     let stopHeartbeat;
     let settled = false;
@@ -6993,7 +7152,7 @@ function connectOnce(url, ctx, connectionAbort, onConnected) {
         finish(() => reject(new Error("shutdown")));
         return;
       }
-      finish(resolve5);
+      finish(resolve6);
     });
     ws.on("error", (err) => {
       console.error("[apm] WebSocket \u9519\u8BEF:", err.message);
@@ -7273,14 +7432,6 @@ function normalizeDeployEnvironment(env) {
   if (normalized === "online") return "ONLINE";
   return null;
 }
-async function completeTrackedDeploy(api, deploymentRunId, logSyncer, input) {
-  logSyncer.updateLog(input.log);
-  await finalizeTaskDeployment(api, deploymentRunId, logSyncer, {
-    status: input.status,
-    fullLog: input.log,
-    error: input.error
-  });
-}
 async function runDeployWithBackendTracking(options) {
   const cfg = await tryReadApmConfig();
   if (!cfg || !resolveApiKey(cfg)) {
@@ -7318,67 +7469,25 @@ async function runDeployWithBackendTracking(options) {
     id: deploymentRunId,
     status: "DEPLOYING"
   });
-  const logSyncer = createDeployLogSyncer(api, deploymentRunId);
-  const previousDeploymentRunId = process.env[APM_DEPLOYMENT_RUN_ID_ENV];
-  process.env[APM_DEPLOYMENT_RUN_ID_ENV] = 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,
-      archiveDeployArtifact: 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 { error: deployError } = await runTrackedDeploy({
+    api,
+    deploymentRunId,
+    run: async (appendLog) => {
+      const output = await executeDeploy({
+        ...options,
+        captureOutput: true,
+        archiveDeployArtifact: true
+      });
+      if (output.trim()) {
+        appendLog(output);
+      }
+      console.log(`[apm] deploy success id=${deploymentRunId}`);
+      return { status: "SUCCESS" };
     }
-    const log2 = chunks.join("\n");
-    await completeTrackedDeploy(api, deploymentRunId, logSyncer, {
-      status: "FAILED",
-      log: log2,
-      error: deployError.message
-    });
+  });
+  if (deployError) {
     printDeployExecutionError(deployError);
     process.exit(deployError.exitCode);
-  } finally {
-    if (previousDeploymentRunId === void 0) {
-      delete process.env[APM_DEPLOYMENT_RUN_ID_ENV];
-    } else {
-      process.env[APM_DEPLOYMENT_RUN_ID_ENV] = previousDeploymentRunId;
-    }
-    console.log = originalLog;
-    console.error = originalError;
-    logSyncer.dispose();
   }
 }
 
@@ -7431,29 +7540,29 @@ function registerDeployMainCommand(program) {
 }
 
 // src/commands/deploy/backend.ts
-import path10 from "node:path";
+import path16 from "node:path";
 
 // src/commands/deploy/internal/backend-deploy/backend-deploy-workflow.ts
-import path9 from "node:path";
+import path15 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 existsSync19, readFileSync as readFileSync16 } from "node:fs";
-import path6 from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync18 } from "node:fs";
+import path12 from "node:path";
 function asOptionalTlsBuffer(value) {
   if (typeof value !== "string") {
     console.log("tls filepath not exist");
     return void 0;
   }
-  console.log("tls filepath", path6.join(process.cwd(), value));
+  console.log("tls filepath", path12.join(process.cwd(), value));
   const normalized = value.trim();
   if (normalized === "") {
     return void 0;
   }
-  if (existsSync19(normalized)) {
-    return readFileSync16(normalized);
+  if (existsSync22(normalized)) {
+    return readFileSync18(normalized);
   }
   const looksLikePath = /[\\/]/.test(normalized) || normalized.endsWith(".pem");
   if (looksLikePath) {
@@ -7578,17 +7687,17 @@ var DockerodeClient = class {
     await this.client.getImage(image).remove({ force: true });
   }
   async pullImage(image, auth) {
-    const stream = await new Promise((resolve5, reject) => {
+    const stream = await new Promise((resolve6, reject) => {
       const pullOptions = auth ? { authconfig: auth } : void 0;
       this.client.pull(image, pullOptions, (err, output) => {
         if (err || !output) {
           reject(err ?? new Error("docker pull \u8FD4\u56DE\u7A7A\u8F93\u51FA"));
           return;
         }
-        resolve5(output);
+        resolve6(output);
       });
     });
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       this.client.modem.followProgress(
         stream,
         (err) => {
@@ -7596,7 +7705,7 @@ var DockerodeClient = class {
             reject(err);
             return;
           }
-          resolve5();
+          resolve6();
         },
         () => void 0
       );
@@ -7663,8 +7772,8 @@ var DockerodeClient = class {
 var createDockerodeClient = (config) => new DockerodeClient(config);
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/env.ts
-import { existsSync as existsSync20, readFileSync as readFileSync17, statSync as statSync8 } from "node:fs";
-import path7 from "node:path";
+import { existsSync as existsSync23, readFileSync as readFileSync19, statSync as statSync10 } from "node:fs";
+import path13 from "node:path";
 function stripSurroundingQuotes(value) {
   const t = value.trim();
   if (t.length >= 2) {
@@ -7679,11 +7788,11 @@ function loadEnvFromFile(envFilePath) {
   if (!envFilePath) {
     return {};
   }
-  const targetPath = path7.resolve(envFilePath);
-  if (!existsSync20(targetPath) || !statSync8(targetPath).isFile()) {
+  const targetPath = path13.resolve(envFilePath);
+  if (!existsSync23(targetPath) || !statSync10(targetPath).isFile()) {
     return {};
   }
-  const raw = readFileSync17(targetPath, "utf-8");
+  const raw = readFileSync19(targetPath, "utf-8");
   const result = {};
   for (const line of raw.split(/\r?\n/)) {
     const normalized = line.trim();
@@ -7854,12 +7963,12 @@ function dockerPushImage(params, cwd) {
 }
 
 // src/commands/deploy/internal/backend-deploy/resolve-dockerfile.ts
-import { existsSync as existsSync21 } from "node:fs";
-import path8 from "node:path";
+import { existsSync as existsSync24 } from "node:fs";
+import path14 from "node:path";
 function resolveDockerBuildPaths(cwd) {
-  const dockerfilePath = path8.join(cwd, "Dockerfile");
+  const dockerfilePath = path14.join(cwd, "Dockerfile");
   Logger.info(`\u67E5\u627EDockerfile\u6587\u4EF6\uFF0C\u8DEF\u5F84: ${dockerfilePath}`);
-  if (!existsSync21(dockerfilePath)) {
+  if (!existsSync24(dockerfilePath)) {
     throw new Error(`Dockerfile \u4E0D\u5B58\u5728\uFF1A${dockerfilePath}`);
   }
   Logger.info("\u2713 Dockerfile \u5B58\u5728");
@@ -7914,7 +8023,7 @@ var BackendDeployWorkflow = class {
       serveraddress
     });
     Logger.success("\u8FDC\u7A0B\u62C9\u53D6\u955C\u50CF\u5B8C\u6210");
-    const envFilePath = path9.resolve(cwd, this.params.envFilePath || ".env");
+    const envFilePath = path15.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()}`);
@@ -7954,7 +8063,7 @@ function registerDeployBackendCommands(program) {
       assertDeployImageTag(tag);
       const cfg = loadApmConfig({ configPath: opts.config });
       const fromApm = resolveBackendDeployFromApmConfig(cfg);
-      const dirAbs = path10.resolve(process.cwd(), opts.dir || "servers/api");
+      const dirAbs = path16.resolve(process.cwd(), opts.dir || "servers/api");
       const params = {
         image: fromApm.name,
         tag,
@@ -7984,34 +8093,15 @@ function registerDeployBackendCommands(program) {
 }
 
 // src/commands/deploy/frontend.ts
-import { copyFile, readdir as readdir3, stat, unlink as unlink2 } from "node:fs/promises";
-import path11 from "node:path";
-function resolveArtifactNamePrefix(cfg) {
-  const nameRaw = (cfg.name ?? "").trim();
-  if (!nameRaw) {
-    console.error(
-      "\u8BF7\u5728 .apm/apm.config.json \u9876\u5C42\u914D\u7F6E name\uFF08\u4F5C\u4E3A MinIO \u5BF9\u8C61\u952E\u524D\u7F00\uFF09"
-    );
-    process.exit(1);
-  }
-  if (nameRaw.includes(":")) {
-    console.error("apm.config.json \u7684 name \u4E0D\u80FD\u5305\u542B ':'");
-    process.exit(1);
-  }
-  try {
-    return sanitizeRelativePath(nameRaw.replace(/\\/g, "/"));
-  } catch {
-    console.error("apm.config.json \u7684 name \u975E\u6CD5\uFF08\u8DEF\u5F84\u7247\u6BB5\u4E0D\u80FD\u4E3A . \u6216 ..\uFF09");
-    process.exit(1);
-  }
-}
+import { copyFile, readdir as readdir3, stat } from "node:fs/promises";
+import path17 from "node:path";
 function artifactObjectKey(namePrefix, branchSegment, relativePath) {
   const base = sanitizeRelativePath(namePrefix);
   const rel = sanitizeRelativePath(relativePath);
   return `${base}/${branchSegment}/dist/${rel}`;
 }
 async function ensureArtifactRootIndexHtml(root) {
-  const indexHtmlPath = path11.join(root, "index.html");
+  const indexHtmlPath = path17.join(root, "index.html");
   try {
     const st = await stat(indexHtmlPath);
     if (st.isFile()) {
@@ -8023,12 +8113,11 @@ async function ensureArtifactRootIndexHtml(root) {
   try {
     entries = await readdir3(root, { withFileTypes: true });
   } catch (e) {
-    console.error(`\u65E0\u6CD5\u8BFB\u53D6\u4EA7\u7269\u76EE\u5F55\uFF1A${root}`, e);
-    process.exit(1);
+    throw new DeployExecutionError(`\u65E0\u6CD5\u8BFB\u53D6\u4EA7\u7269\u76EE\u5F55\uFF1A${root}`, 1, String(e));
   }
   const dirNames = entries.filter((e) => e.isDirectory()).map((e) => String(e.name)).sort();
   for (const name of dirNames) {
-    const candidate = path11.join(root, name, "index.html");
+    const candidate = path17.join(root, name, "index.html");
     try {
       const st = await stat(candidate);
       if (!st.isFile()) {
@@ -8039,52 +8128,39 @@ async function ensureArtifactRootIndexHtml(root) {
     }
     await copyFile(candidate, indexHtmlPath);
     console.error(
-      `\u4EA7\u7269\u534F\u8BAE\uFF1A\u5DF2\u5C06 ${path11.join(name, "index.html")} \u590D\u5236\u4E3A\u6839\u76EE\u5F55 index.html`
+      `\u4EA7\u7269\u534F\u8BAE\uFF1A\u5DF2\u5C06 ${path17.join(name, "index.html")} \u590D\u5236\u4E3A\u6839\u76EE\u5F55 index.html`
     );
     return;
   }
-  console.error(
-    `\u4EA7\u7269\u534F\u8BAE\uFF1A\u9700\u5728\u4EA7\u7269\u6839\u76EE\u5F55\u5B58\u5728 index.html\uFF0C\u6216\u5728\u5176\u4E00\u7EA7\u5B50\u76EE\u5F55\u4E2D\u5B58\u5728\u53EF\u590D\u5236\u7684 index.html\uFF08\u672A\u5728 ${root} \u4E0B\u627E\u5230\uFF09`
+  throw new DeployExecutionError(
+    `\u4EA7\u7269\u534F\u8BAE\uFF1A\u9700\u5728\u4EA7\u7269\u6839\u76EE\u5F55\u5B58\u5728 index.html\uFF0C\u6216\u5728\u5176\u4E00\u7EA7\u5B50\u76EE\u5F55\u4E2D\u5B58\u5728\u53EF\u590D\u5236\u7684 index.html\uFF08\u672A\u5728 ${root} \u4E0B\u627E\u5230\uFF09`,
+    1
   );
-  process.exit(1);
 }
 async function runFrontendPackOnlyDeploy(root, namePrefix) {
-  const zipPath = path11.resolve(root, "..", ".deploy-frontend-dist.zip");
-  let zipSizeBytes = 0;
-  let artifactUploaded = false;
-  try {
-    zipSizeBytes = await zipDirectory(root, zipPath);
-    console.error("[apm] \u4EC5\u6253\u5305\u6A21\u5F0F\uFF1A\u8DF3\u8FC7\u524D\u7AEF\u8BBF\u95EE\u6876\u4E0A\u4F20");
-    const artifact = await uploadDeployArtifactZip({
-      zipPath,
-      projectName: namePrefix,
-      kind: "frontend",
-      uploadWithoutRunId: true
-    });
-    artifactUploaded = artifact !== null;
-    if (artifactUploaded) {
-      console.error("\u6253\u5305\u5E76\u4E0A\u4F20 MinIO \u5F52\u6863\u5B8C\u6210\uFF08\u672A\u4E0A\u4F20\u81F3\u524D\u7AEF\u8BBF\u95EE\u6876\uFF09");
-    }
-    console.log(
-      JSON.stringify(
-        {
-          ok: true,
-          packOnly: true,
-          namePrefix,
-          zipSizeBytes,
-          artifactUploaded
-        },
-        null,
-        2
-      )
-    );
-  } finally {
-    try {
-      await unlink2(zipPath);
-      console.error(`\u5DF2\u6E05\u7406\u672C\u5730\u4E34\u65F6\u6587\u4EF6: ${zipPath}`);
-    } catch {
-    }
-  }
+  const zipPath = path17.resolve(root, "..", ".deploy-frontend-dist.zip");
+  const { zipSizeBytes, artifactUploaded } = await packDirectoryWithMinioArchive({
+    localDir: root,
+    zipPath,
+    projectName: namePrefix,
+    kind: "frontend",
+    uploadWithoutRunId: true,
+    skipMessage: "[apm] \u4EC5\u6253\u5305\u6A21\u5F0F\uFF1A\u8DF3\u8FC7\u524D\u7AEF\u8BBF\u95EE\u6876\u4E0A\u4F20",
+    successMessage: "\u6253\u5305\u5E76\u4E0A\u4F20 MinIO \u5F52\u6863\u5B8C\u6210\uFF08\u672A\u4E0A\u4F20\u81F3\u524D\u7AEF\u8BBF\u95EE\u6876\uFF09"
+  });
+  console.log(
+    JSON.stringify(
+      {
+        ok: true,
+        packOnly: true,
+        namePrefix,
+        zipSizeBytes,
+        artifactUploaded
+      },
+      null,
+      2
+    )
+  );
 }
 function registerDeployFrontendCommands(program) {
   program.command("deploy-frontend").description(
@@ -8105,91 +8181,97 @@ function registerDeployFrontendCommands(program) {
     "\u4EC5\u6253\u5305\u5E76\u4E0A\u4F20 MinIO \u5F52\u6863\uFF0C\u4E0D\u4E0A\u4F20\u81F3\u524D\u7AEF\u8BBF\u95EE\u6876\uFF08\u9ED8\u8BA4\u5173\u95ED\uFF09"
   ).action(
     async (name, opts) => {
-      const cfg = loadApmConfig({ configPath: opts.config });
-      const namePrefix = resolveArtifactNamePrefix(cfg);
-      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);
-      }
-      await ensureArtifactRootIndexHtml(root);
-      if (opts.packOnly) {
-        await runFrontendPackOnlyDeploy(root, namePrefix);
-        return;
-      }
-      const settings = resolveFrontendDeployFromApmConfig(cfg);
-      const minio = new MinioClient({
-        endPoint: settings.endpoint,
-        port: settings.port,
-        useSSL: settings.useSsl,
-        accessKey: settings.accessKey,
-        secretKey: settings.secretKey
-      });
-      const bucket = settings.bucket;
-      const maxBytes = Math.max(
-        1,
-        Number.isFinite(opts.maxFileSizeMb) ? Math.floor(
-          (opts.maxFileSizeMb ?? DEFAULT_MAX_FILE_SIZE_MB) * 1024 * 1024
-        ) : DEFAULT_MAX_FILE_SIZE_MB * 1024 * 1024
-      );
-      const files = await collectFiles(root);
-      if (files.length === 0) {
-        console.error(`\u76EE\u5F55\u4E3A\u7A7A\uFF1A${root}`);
-        process.exit(1);
-      }
-      let uploaded = 0;
-      let totalBytes = 0;
-      console.error(`\u5F00\u59CB\u76F4\u8FDE MinIO \u4E0A\u4F20\uFF0C\u5171 ${files.length} \u4E2A\u6587\u4EF6\u2026`);
-      await minio.ensureBucket(bucket);
-      await minio.deleteObjectsByPrefix(
-        bucket,
-        `${namePrefix}/${name}/dist/`
-      );
-      for (const f of files) {
-        if (f.size > maxBytes) {
+      try {
+        const cfg = loadApmConfig({ configPath: opts.config });
+        const namePrefix = resolveArtifactNamePrefix(cfg);
+        const root = path17.resolve(process.cwd(), opts.dir || "apps/web/dist");
+        if (!await isDirectoryPath(root)) {
+          throw new DeployExecutionError(`\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${root}`, 1);
+        }
+        await ensureArtifactRootIndexHtml(root);
+        if (opts.packOnly) {
+          await runFrontendPackOnlyDeploy(root, namePrefix);
+          return;
+        }
+        const settings = resolveFrontendDeployFromApmConfig(cfg);
+        const minio = new MinioClient({
+          endPoint: settings.endpoint,
+          port: settings.port,
+          useSSL: settings.useSsl,
+          accessKey: settings.accessKey,
+          secretKey: settings.secretKey
+        });
+        const bucket = settings.bucket;
+        const maxBytes = Math.max(
+          1,
+          Number.isFinite(opts.maxFileSizeMb) ? Math.floor(
+            (opts.maxFileSizeMb ?? DEFAULT_MAX_FILE_SIZE_MB) * 1024 * 1024
+          ) : DEFAULT_MAX_FILE_SIZE_MB * 1024 * 1024
+        );
+        const files = await collectFiles(root);
+        if (files.length === 0) {
+          throw new DeployExecutionError(`\u76EE\u5F55\u4E3A\u7A7A\uFF1A${root}`, 1);
+        }
+        let uploaded = 0;
+        let totalBytes = 0;
+        console.error(`\u5F00\u59CB\u76F4\u8FDE MinIO \u4E0A\u4F20\uFF0C\u5171 ${files.length} \u4E2A\u6587\u4EF6\u2026`);
+        await minio.ensureBucket(bucket);
+        await minio.deleteObjectsByPrefix(
+          bucket,
+          `${namePrefix}/${name}/dist/`
+        );
+        for (const f of files) {
+          if (f.size > maxBytes) {
+            throw new DeployExecutionError(
+              `\u6587\u4EF6\u8FC7\u5927\uFF0C\u5DF2\u62D2\u7EDD\uFF1A${f.relativePath}\uFF08${toMB(
+                f.size
+              )}MB > ${toMB(maxBytes)}MB\uFF09`,
+              1
+            );
+          }
+          const buf = await readArtifactFile(f.absPath);
+          const cleanRel = sanitizeRelativePath(f.relativePath);
+          const objectKey = artifactObjectKey(namePrefix, name, cleanRel);
+          const mimeType = detectMimeType(f.relativePath).trim().toLowerCase() || "application/octet-stream";
+          await minio.putObject(bucket, objectKey, buf, {
+            "Content-Type": mimeType
+          });
+          uploaded += 1;
+          totalBytes += buf.length;
           console.error(
-            `\u6587\u4EF6\u8FC7\u5927\uFF0C\u5DF2\u62D2\u7EDD\uFF1A${f.relativePath}\uFF08${toMB(f.size)}MB > ${toMB(
-              maxBytes
-            )}MB\uFF09`
+            `[${uploaded}/${files.length}] ${f.relativePath} -> ${objectKey}`
           );
-          process.exit(1);
         }
-        const buf = await readArtifactFile(f.absPath);
-        const cleanRel = sanitizeRelativePath(f.relativePath);
-        const objectKey = artifactObjectKey(namePrefix, name, cleanRel);
-        const mimeType = detectMimeType(f.relativePath).trim().toLowerCase() || "application/octet-stream";
-        await minio.putObject(bucket, objectKey, buf, {
-          "Content-Type": mimeType
-        });
-        uploaded += 1;
-        totalBytes += buf.length;
-        console.error(
-          `[${uploaded}/${files.length}] ${f.relativePath} -> ${objectKey}`
+        console.error("\u6B63\u5728\u8BBE\u7F6E\u6876\u7B56\u7565\uFF08\u533F\u540D\u53EF\u8BFB\u5BF9\u8C61\uFF0C\u4FBF\u4E8E HTTP \u76F4\u94FE\uFF09\u2026");
+        await minio.setBucketPublicRead(bucket);
+        console.log(
+          JSON.stringify(
+            {
+              ok: true,
+              namePrefix,
+              envName: name,
+              bucket,
+              fileCount: uploaded,
+              totalBytes,
+              bucketPublicRead: true
+            },
+            null,
+            2
+          )
         );
+      } catch (error) {
+        if (error instanceof DeployExecutionError) {
+          printDeployExecutionError(error);
+          process.exit(error.exitCode);
+        }
+        throw error;
       }
-      console.error("\u6B63\u5728\u8BBE\u7F6E\u6876\u7B56\u7565\uFF08\u533F\u540D\u53EF\u8BFB\u5BF9\u8C61\uFF0C\u4FBF\u4E8E HTTP \u76F4\u94FE\uFF09\u2026");
-      await minio.setBucketPublicRead(bucket);
-      console.log(
-        JSON.stringify(
-          {
-            ok: true,
-            namePrefix,
-            envName: name,
-            bucket,
-            fileCount: uploaded,
-            totalBytes,
-            bucketPublicRead: true
-          },
-          null,
-          2
-        )
-      );
     }
   );
 }
 
 // src/commands/deploy/sftp.ts
-import path12 from "node:path";
+import path18 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"
@@ -8205,25 +8287,22 @@ function registerDeploySftpCommands(program) {
     "\u4EC5\u6253\u5305\u5E76\u4E0A\u4F20 MinIO \u5F52\u6863\uFF0C\u4E0D\u4E0A\u4F20\u8FDC\u7A0B\u670D\u52A1\u5668\uFF08\u4E0E --extract \u4E92\u65A5\uFF09"
   ).action(
     async (opts) => {
-      const cfg = loadApmConfig({ configPath: opts.config });
-      const settings = resolveWisdomDeployFromApmConfig(cfg);
-      const projectName = (cfg.name ?? "").trim();
-      if (!projectName) {
-        console.error(
-          "\u8BF7\u5728 .apm/apm.config.json \u9876\u5C42\u914D\u7F6E name\uFF08\u4F5C\u4E3A\u90E8\u7F72\u4EA7\u7269\u9879\u76EE\u540D\uFF09"
-        );
-        process.exit(1);
-      }
-      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);
-      }
       try {
+        const cfg = loadApmConfig({ configPath: opts.config });
+        const settings = resolveWisdomDeployFromApmConfig(cfg);
+        const projectName = resolveProjectNameForDeploy(cfg, process.cwd(), {
+          requireName: true
+        });
+        const root = path18.resolve(process.cwd(), opts.dir || "apps/web/dist");
+        if (!await isDirectoryPath(root)) {
+          throw new DeployExecutionError(`\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${root}`, 1);
+        }
         const packOnly = Boolean(opts.packOnly);
         if (packOnly && opts.extract) {
-          console.error("--pack-only \u4E0E --extract \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528");
-          process.exit(1);
+          throw new DeployExecutionError(
+            "--pack-only \u4E0E --extract \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528",
+            1
+          );
         }
         const result = await runWisdomSftpDeploy({
           localDir: root,
@@ -8233,8 +8312,12 @@ function registerDeploySftpCommands(program) {
           packOnly
         });
         console.log(JSON.stringify(result, null, 2));
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
+      } catch (error) {
+        if (error instanceof DeployExecutionError) {
+          printDeployExecutionError(error);
+          process.exit(error.exitCode);
+        }
+        const message = error instanceof Error ? error.message : String(error);
         const action = opts.packOnly ? "\u6253\u5305" : opts.extract ? "\u90E8\u7F72" : "\u4E0A\u4F20";
         console.error(`${action}\u5931\u8D25:`, message);
         process.exit(1);
@@ -8251,11 +8334,19 @@ function registerDeployWisdomBackendCommands(program) {
     "--config <path>",
     "apm.config.json \u8DEF\u5F84\uFF08\u9ED8\u8BA4 .apm/apm.config.json\uFF09"
   ).action(async (opts) => {
-    const cfg = loadApmConfig({ configPath: opts.config });
-    const settings = resolveWisdomBackendDeployFromApmConfig(cfg);
-    await runWisdomBackendDeploy({
-      config: settings
-    });
+    try {
+      const cfg = loadApmConfig({ configPath: opts.config });
+      const settings = resolveWisdomBackendDeployFromApmConfig(cfg);
+      await runWisdomBackendDeploy({
+        config: settings
+      });
+    } catch (error) {
+      if (error instanceof DeployExecutionError) {
+        printDeployExecutionError(error);
+        process.exit(error.exitCode);
+      }
+      throw error;
+    }
   });
 }