ai-project-manage-cli 6.0.103 → 6.0.104

package/dist/index.js

@@ -2878,33 +2878,17 @@ function posixBasename(p) {
 }
 
 // src/commands/deploy/internal/deploy-hints.ts
-function formatDeployNotConfiguredLines(env, deployCommands) {
-  const configuredEnvs = Object.keys(deployCommands).filter(
-    (key) => deployCommands[key]?.trim()
-  );
-  if (configuredEnvs.length > 0) {
-    return [
-      `[apm] \u65E0\u6CD5\u6267\u884C\u90E8\u7F72\uFF1Aapm.config.json \u4E2D\u672A\u914D\u7F6E deploy.${env}`,
-      `[apm] \u5F53\u524D\u5DF2\u914D\u7F6E\u7684\u73AF\u5883: ${configuredEnvs.join(", ")}`
-    ];
-  }
+function formatMissingWisdomDeployLines() {
   return [
-    "[apm] \u65E0\u6CD5\u6267\u884C\u90E8\u7F72\uFF1A\u5F53\u524D\u9879\u76EE\u672A\u914D\u7F6E\u81EA\u52A8\u5316\u90E8\u7F72\uFF08apm.config.json \u4E2D\u65E0 deploy \u6BB5\uFF09",
-    "[apm] \u90E8\u5206\u9879\u76EE\u4E0D\u652F\u6301\u6216\u672A\u542F\u7528\u81EA\u52A8\u5316\u90E8\u7F72\uFF0C\u5C5E\u6B63\u5E38\u60C5\u51B5\uFF0C\u53EF\u8DF3\u8FC7\u90E8\u7F72"
+    "[apm] \u65E0\u6CD5\u6267\u884C apm deploy\uFF1A\u8BF7\u5728 apm.config.json \u4E2D\u914D\u7F6E wisdomDeploy\uFF08host\u3001remotePath\uFF09"
   ];
 }
 function formatWisdomFrontendBuildNotConfiguredLines(env, packageJsonPath) {
   return [
-    `[apm] \u65E0\u6CD5\u6267\u884C\u4EC5\u6253\u5305\uFF1A${packageJsonPath} \u4E2D\u672A\u627E\u5230 build:${env} \u811A\u672C`,
+    `[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"
   ];
 }
-function formatWisdomFrontendDeployNotConfiguredLines(env, packageJsonPath) {
-  return [
-    `[apm] \u65E0\u6CD5\u6267\u884C\u90E8\u7F72\uFF1A${packageJsonPath} \u4E2D\u672A\u627E\u5230 deploy:${env} \u811A\u672C`,
-    "[apm] \u82E5\u672C\u9879\u76EE\u4E0D\u652F\u6301\u81EA\u52A8\u5316\u90E8\u7F72\uFF0C\u5C5E\u6B63\u5E38\u60C5\u51B5\uFF0C\u53EF\u8DF3\u8FC7\u90E8\u7F72"
-  ];
-}
 
 // src/commands/deploy/deploy-errors.ts
 var DeployExecutionError = class extends Error {
@@ -2918,8 +2902,260 @@ var DeployExecutionError = class extends Error {
   }
 };
 
-// src/commands/deploy/deploy-shell-run.ts
+// src/commands/deploy/deploy-debug-log.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
+import { existsSync as existsSync14 } from "node:fs";
+import { dirname as dirname5, join as join16 } from "node:path";
+
+// src/commands/deploy/internal/deploy-artifact-minio.ts
+import { readFile as readFile2 } from "node:fs/promises";
+
+// src/commands/deploy/internal/minio.ts
+import { statSync as statSync5 } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import * as Minio from "minio";
+var DEFAULT_MAX_FILE_SIZE_MB = 50;
+async function isDirectoryPath(dir) {
+  try {
+    const st = statSync5(dir);
+    return st.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function sanitizeRelativePath(rel) {
+  const norm = rel.replace(/\\/g, "/").replace(/^\/+/, "");
+  const segments = norm.split("/").filter(Boolean);
+  for (const s of segments) {
+    if (s === "." || s === "..") {
+      throw new Error(`\u975E\u6CD5\u76F8\u5BF9\u8DEF\u5F84\u7247\u6BB5\uFF1A${s}`);
+    }
+  }
+  return segments.join("/");
+}
+async function collectFiles(root) {
+  const out = [];
+  async function walk(dir, prefix) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const name = e.name;
+      if (name === "." || name === "..") {
+        continue;
+      }
+      const abs = path.join(dir, name);
+      const rel = prefix ? `${prefix}/${name}` : name;
+      if (e.isDirectory()) {
+        await walk(abs, rel);
+      } else if (e.isFile()) {
+        const st = statSync5(abs);
+        out.push({
+          absPath: abs,
+          relativePath: rel.replace(/\\/g, "/"),
+          size: st.size
+        });
+      }
+    }
+  }
+  await walk(root, "");
+  out.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  return out;
+}
+async function readArtifactFile(absPath) {
+  return readFile(absPath);
+}
+function toMB(bytes) {
+  return Math.round(bytes / (1024 * 1024) * 1e3) / 1e3;
+}
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".ico": "image/x-icon",
+  ".txt": "text/plain; charset=utf-8",
+  ".map": "application/json"
+};
+function detectMimeType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return MIME[ext] ?? "";
+}
+var MinioClient = class {
+  inner;
+  constructor(opts) {
+    const endPoint = opts.endPoint.replace(/^https?:\/\//i, "").split("/")[0] ?? opts.endPoint;
+    this.inner = new Minio.Client({
+      endPoint,
+      port: opts.port,
+      useSSL: opts.useSSL,
+      accessKey: opts.accessKey,
+      secretKey: opts.secretKey
+    });
+  }
+  async ensureBucket(bucket) {
+    const exists = await this.inner.bucketExists(bucket);
+    if (!exists) {
+      await this.inner.makeBucket(bucket);
+    }
+  }
+  async deleteObjectsByPrefix(bucket, prefix) {
+    const objectsStream = this.inner.listObjectsV2(bucket, prefix, true);
+    const keys = [];
+    await new Promise((resolve5, reject) => {
+      objectsStream.on("data", (obj) => {
+        if (obj.name) {
+          keys.push(obj.name);
+        }
+      });
+      objectsStream.on("error", reject);
+      objectsStream.on("end", resolve5);
+    });
+    const chunkSize = 500;
+    for (let i = 0; i < keys.length; i += chunkSize) {
+      const chunk = keys.slice(i, i + chunkSize);
+      await this.inner.removeObjects(
+        bucket,
+        chunk.map((name) => name)
+      );
+    }
+  }
+  async putObject(bucket, objectKey, body, meta) {
+    await this.inner.putObject(bucket, objectKey, body, body.length, meta);
+  }
+  /** 匿名可读当前桶全部对象（便于静态站点直链） */
+  async setBucketPublicRead(bucket) {
+    const policy = {
+      Version: "2012-10-17",
+      Statement: [
+        {
+          Effect: "Allow",
+          Principal: { AWS: ["*"] },
+          Action: ["s3:GetObject"],
+          Resource: [`arn:aws:s3:::${bucket}/*`]
+        }
+      ]
+    };
+    await this.inner.setBucketPolicy(bucket, JSON.stringify(policy));
+  }
+};
+
+// src/commands/deploy/internal/deploy-artifact-minio.ts
+var APM_DEPLOYMENT_RUN_ID_ENV = "APM_DEPLOYMENT_RUN_ID";
+function formatDeployArtifactTimestamp(date = /* @__PURE__ */ new Date()) {
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
+}
+function sanitizeDeployProjectName(name) {
+  const trimmed = name.trim().replace(/\\/g, "/");
+  const base = trimmed.split("/").filter(Boolean).pop() ?? trimmed;
+  try {
+    return sanitizeRelativePath(base.replace(/[/\\:*?"<>|]/g, "_"));
+  } catch {
+    return "project";
+  }
+}
+function buildDeployArtifactFileName(kind, projectName, timestamp = formatDeployArtifactTimestamp()) {
+  const safeName = sanitizeDeployProjectName(projectName);
+  const suffix = kind === "frontend" ? "dist.zip" : "jar.zip";
+  return `${timestamp}-${safeName}.${suffix}`;
+}
+function buildDeployArtifactObjectKey(projectName, fileName) {
+  const safeProject = sanitizeDeployProjectName(projectName);
+  return `deploy/${safeProject}/${fileName}`;
+}
+function resolveDeploymentRunIdFromEnv() {
+  const raw = process.env[APM_DEPLOYMENT_RUN_ID_ENV]?.trim();
+  return raw || null;
+}
+async function fetchDeployArtifactStorage(api) {
+  return api.cli.getDeployArtifactStorage(void 0);
+}
+async function uploadDeployArtifactZip(options) {
+  const deploymentRunId = options.deploymentRunId ?? resolveDeploymentRunIdFromEnv();
+  if (!deploymentRunId && !options.uploadWithoutRunId) {
+    return null;
+  }
+  const cfg = await tryReadApmConfig();
+  if (!cfg || !resolveApiKey(cfg)) {
+    console.warn("[apm] \u672A\u767B\u5F55\uFF0C\u8DF3\u8FC7 MinIO \u90E8\u7F72\u4EA7\u7269\u5F52\u6863");
+    return null;
+  }
+  const api = options.api ?? createApmApiClient(cfg);
+  let storage;
+  try {
+    storage = await fetchDeployArtifactStorage(api);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    console.warn(`[apm] \u83B7\u53D6 MinIO \u914D\u7F6E\u5931\u8D25\uFF0C\u8DF3\u8FC7\u90E8\u7F72\u4EA7\u7269\u5F52\u6863: ${detail}`);
+    return null;
+  }
+  const fileName = buildDeployArtifactFileName(
+    options.kind,
+    options.projectName,
+    options.timestamp
+  );
+  const objectKey = buildDeployArtifactObjectKey(options.projectName, fileName);
+  let body;
+  try {
+    body = await readFile2(options.zipPath);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    console.warn(`[apm] \u8BFB\u53D6\u90E8\u7F72\u4EA7\u7269 zip \u5931\u8D25\uFF0C\u8DF3\u8FC7 MinIO \u5F52\u6863: ${detail}`);
+    return null;
+  }
+  try {
+    const client = new MinioClient({
+      endPoint: storage.endpoint,
+      port: storage.port,
+      useSSL: storage.useSsl,
+      accessKey: storage.accessKey,
+      secretKey: storage.secretKey
+    });
+    await client.ensureBucket(storage.bucket);
+    await client.putObject(storage.bucket, objectKey, body, {
+      "Content-Type": "application/zip"
+    });
+    console.error(
+      `[apm] \u672C\u5730\u76F4\u4F20 MinIO\uFF08\u4E0D\u7ECF\u5E73\u53F0\u670D\u52A1\u5668\uFF09: ${storage.endpoint}:${storage.port}/${storage.bucket}/${objectKey} (${(body.length / 1024 / 1024).toFixed(
+        2
+      )} MB)`
+    );
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    console.warn(`[apm] MinIO \u90E8\u7F72\u4EA7\u7269\u5F52\u6863\u5931\u8D25: ${detail}`);
+    return null;
+  }
+  if (deploymentRunId) {
+    try {
+      await api.cli.attachTaskDeploymentArtifact({
+        id: deploymentRunId,
+        artifactObjectKey: objectKey,
+        artifactFileName: fileName
+      });
+      console.error(
+        `[apm] \u5DF2\u7ED1\u5B9A\u90E8\u7F72\u4EA7\u7269\u5230\u8BB0\u5F55 id=${deploymentRunId} file=${fileName}`
+      );
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      console.warn(`[apm] \u7ED1\u5B9A\u90E8\u7F72\u4EA7\u7269\u5230\u8BB0\u5F55\u5931\u8D25: ${detail}`);
+      return null;
+    }
+  }
+  return {
+    objectKey,
+    fileName,
+    bucket: storage.bucket
+  };
+}
 
 // src/commands/deploy/internal/deploy-shell-env.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
@@ -3741,316 +3977,252 @@ function buildDeployShellEnv(extra) {
   return env;
 }
 
-// src/commands/deploy/deploy-shell-run.ts
-function runDeployShellCommand(command, cwd, captureOutput) {
-  const result = spawnSync4(command, {
-    cwd,
-    shell: true,
-    env: buildDeployShellEnv(),
-    encoding: "utf8",
-    maxBuffer: DEPLOY_SPAWN_MAX_BUFFER_BYTES,
-    stdio: captureOutput ? ["inherit", "pipe", "pipe"] : "inherit"
-  });
-  const stdout = captureOutput ? String(result.stdout ?? "") : "";
-  const stderr = captureOutput ? String(result.stderr ?? "") : "";
-  const output = [stdout, stderr].filter(Boolean).join("\n");
-  if (captureOutput) {
-    if (stdout) process.stdout.write(stdout);
-    if (stderr) process.stderr.write(stderr);
-  }
-  if (result.error) {
-    throw new DeployExecutionError(
-      `\u90E8\u7F72\u547D\u4EE4\u6267\u884C\u5931\u8D25: ${result.error.message}`,
-      1,
-      output
-    );
-  }
-  if (result.status !== 0) {
-    throw new DeployExecutionError(
-      `\u90E8\u7F72\u547D\u4EE4\u9000\u51FA\u7801 ${result.status ?? "unknown"}: ${command}`,
-      result.status ?? 1,
-      output
-    );
-  }
-  return output;
-}
-
-// src/commands/deploy/internal/wisdom-auto-deploy.ts
-import { existsSync as existsSync15, readFileSync as readFileSync13, statSync as statSync7 } from "node:fs";
-import path4 from "node:path";
-
-// src/commands/deploy/internal/wisdom-backend-deploy.ts
-import {
-  existsSync as existsSync14,
-  mkdirSync as mkdirSync7,
-  readdirSync as readdirSync5,
-  readFileSync as readFileSync12,
-  statSync as statSync6,
-  writeFileSync as writeFileSync12
-} from "node:fs";
-import { spawnSync as spawnSync5 } from "node:child_process";
-import path3 from "node:path";
-import { Client as Client2 } from "ssh2";
-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";
-import path2 from "node:path";
-import JSZip from "jszip";
-import SftpClient from "ssh2-sftp-client";
-
-// src/commands/deploy/internal/deploy-artifact-minio.ts
-import { readFile as readFile2 } from "node:fs/promises";
-
-// src/commands/deploy/internal/minio.ts
-import { statSync as statSync5 } from "node:fs";
-import { readdir, readFile } from "node:fs/promises";
-import path from "node:path";
-import * as Minio from "minio";
-var DEFAULT_MAX_FILE_SIZE_MB = 50;
-async function isDirectoryPath(dir) {
-  try {
-    const st = statSync5(dir);
-    return st.isDirectory();
-  } catch {
-    return false;
-  }
-}
-function sanitizeRelativePath(rel) {
-  const norm = rel.replace(/\\/g, "/").replace(/^\/+/, "");
-  const segments = norm.split("/").filter(Boolean);
-  for (const s of segments) {
-    if (s === "." || s === "..") {
-      throw new Error(`\u975E\u6CD5\u76F8\u5BF9\u8DEF\u5F84\u7247\u6BB5\uFF1A${s}`);
-    }
-  }
-  return segments.join("/");
-}
-async function collectFiles(root) {
-  const out = [];
-  async function walk(dir, prefix) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const e of entries) {
-      const name = e.name;
-      if (name === "." || name === "..") {
-        continue;
-      }
-      const abs = path.join(dir, name);
-      const rel = prefix ? `${prefix}/${name}` : name;
-      if (e.isDirectory()) {
-        await walk(abs, rel);
-      } else if (e.isFile()) {
-        const st = statSync5(abs);
-        out.push({
-          absPath: abs,
-          relativePath: rel.replace(/\\/g, "/"),
-          size: st.size
-        });
-      }
+// src/commands/deploy/deploy-debug-log.ts
+var LOG_PREFIX = "[apm:deploy-debug]";
+var SENSITIVE_ENV_KEY = /(password|secret|token|api[_-]?key|authorization|credential|private|passwd)/i;
+var PATH_SEP2 = process.platform === "win32" ? ";" : ":";
+function logLine(message) {
+  console.error(`${LOG_PREFIX} ${message}`);
+}
+function pathEntries(value) {
+  if (!value?.trim()) return [];
+  return value.split(PATH_SEP2).filter(Boolean);
+}
+function summarizePath(value, maxEntries = 12) {
+  const entries = pathEntries(value);
+  if (entries.length === 0) return "(empty)";
+  const head = entries.slice(0, maxEntries).join(PATH_SEP2);
+  if (entries.length <= maxEntries) return head;
+  return `${head}${PATH_SEP2}\u2026 (+${entries.length - maxEntries} more)`;
+}
+function pickEnvKeys(env, keys) {
+  const out = {};
+  for (const key of keys) {
+    const value = env[key];
+    if (value !== void 0 && value !== "") {
+      out[key] = value;
     }
   }
-  await walk(root, "");
-  out.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
   return out;
 }
-async function readArtifactFile(absPath) {
-  return readFile(absPath);
-}
-function toMB(bytes) {
-  return Math.round(bytes / (1024 * 1024) * 1e3) / 1e3;
-}
-var MIME = {
-  ".html": "text/html; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".js": "application/javascript; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".ico": "image/x-icon",
-  ".txt": "text/plain; charset=utf-8",
-  ".map": "application/json"
-};
-function detectMimeType(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
-  return MIME[ext] ?? "";
-}
-var MinioClient = class {
-  inner;
-  constructor(opts) {
-    const endPoint = opts.endPoint.replace(/^https?:\/\//i, "").split("/")[0] ?? opts.endPoint;
-    this.inner = new Minio.Client({
-      endPoint,
-      port: opts.port,
-      useSSL: opts.useSSL,
-      accessKey: opts.accessKey,
-      secretKey: opts.secretKey
-    });
-  }
-  async ensureBucket(bucket) {
-    const exists = await this.inner.bucketExists(bucket);
-    if (!exists) {
-      await this.inner.makeBucket(bucket);
+function collectInterestingEnv(env) {
+  const keys = /* @__PURE__ */ new Set([
+    "PATH",
+    "HOME",
+    "USER",
+    "LOGNAME",
+    "SHELL",
+    "LANG",
+    "LC_ALL",
+    "NODE_ENV",
+    "npm_config_registry",
+    "NPM_CONFIG_REGISTRY",
+    "npm_config_prefix",
+    "NPM_CONFIG_PREFIX",
+    APM_DEPLOYMENT_RUN_ID_ENV
+  ]);
+  for (const key of Object.keys(env)) {
+    if (/^npm_config_/i.test(key) || /^NPM_CONFIG_/i.test(key)) {
+      keys.add(key);
     }
-  }
-  async deleteObjectsByPrefix(bucket, prefix) {
-    const objectsStream = this.inner.listObjectsV2(bucket, prefix, true);
-    const keys = [];
-    await new Promise((resolve5, reject) => {
-      objectsStream.on("data", (obj) => {
-        if (obj.name) {
-          keys.push(obj.name);
-        }
-      });
-      objectsStream.on("error", reject);
-      objectsStream.on("end", resolve5);
-    });
-    const chunkSize = 500;
-    for (let i = 0; i < keys.length; i += chunkSize) {
-      const chunk = keys.slice(i, i + chunkSize);
-      await this.inner.removeObjects(
-        bucket,
-        chunk.map((name) => name)
-      );
+    if (/^APM_/i.test(key) && !SENSITIVE_ENV_KEY.test(key)) {
+      keys.add(key);
     }
   }
-  async putObject(bucket, objectKey, body, meta) {
-    await this.inner.putObject(bucket, objectKey, body, body.length, meta);
-  }
-  /** 匿名可读当前桶全部对象（便于静态站点直链） */
-  async setBucketPublicRead(bucket) {
-    const policy = {
-      Version: "2012-10-17",
-      Statement: [
-        {
-          Effect: "Allow",
-          Principal: { AWS: ["*"] },
-          Action: ["s3:GetObject"],
-          Resource: [`arn:aws:s3:::${bucket}/*`]
-        }
-      ]
-    };
-    await this.inner.setBucketPolicy(bucket, JSON.stringify(policy));
-  }
-};
-
-// src/commands/deploy/internal/deploy-artifact-minio.ts
-var APM_DEPLOYMENT_RUN_ID_ENV = "APM_DEPLOYMENT_RUN_ID";
-function formatDeployArtifactTimestamp(date = /* @__PURE__ */ new Date()) {
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
-}
-function sanitizeDeployProjectName(name) {
-  const trimmed = name.trim().replace(/\\/g, "/");
-  const base = trimmed.split("/").filter(Boolean).pop() ?? trimmed;
-  try {
-    return sanitizeRelativePath(base.replace(/[/\\:*?"<>|]/g, "_"));
-  } catch {
-    return "project";
-  }
+  const picked = {};
+  for (const key of [...keys].sort()) {
+    const value = env[key];
+    if (value === void 0 || value === "") continue;
+    picked[key] = SENSITIVE_ENV_KEY.test(key) ? "***" : value;
+  }
+  return picked;
 }
-function buildDeployArtifactFileName(kind, projectName, timestamp = formatDeployArtifactTimestamp()) {
-  const safeName = sanitizeDeployProjectName(projectName);
-  const suffix = kind === "frontend" ? "dist.zip" : "jar.zip";
-  return `${timestamp}-${safeName}.${suffix}`;
+function describePathDelta(before, after) {
+  const beforeSet = new Set(pathEntries(before));
+  const added = pathEntries(after).filter((entry) => !beforeSet.has(entry));
+  if (added.length === 0) return "buildDeployShellEnv \u672A prepend \u65B0 PATH \u6BB5";
+  return `prepend: ${added.join(PATH_SEP2)}`;
 }
-function buildDeployArtifactObjectKey(projectName, fileName) {
-  const safeProject = sanitizeDeployProjectName(projectName);
-  return `deploy/${safeProject}/${fileName}`;
+function probeCommand(label, command, cwd, env) {
+  const result = spawnSync4(command, {
+    cwd,
+    shell: true,
+    env,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const stdout = String(result.stdout ?? "").trim();
+  const stderr = String(result.stderr ?? "").trim();
+  const detail = stdout || stderr || "(no output)";
+  logLine(
+    `probe ${label}: exit=${result.status ?? "null"} output=${detail.slice(
+      0,
+      500
+    )}`
+  );
 }
-function resolveDeploymentRunIdFromEnv() {
-  const raw = process.env[APM_DEPLOYMENT_RUN_ID_ENV]?.trim();
-  return raw || null;
+function probeShellTooling(cwd, env) {
+  logLine("--- shell \u5DE5\u5177\u63A2\u6D4B\uFF08\u4E0E runDeployShellCommand \u76F8\u540C env/cwd\uFF09---");
+  probeCommand("node -v", "node -v", cwd, env);
+  probeCommand("npm -v", "npm -v", cwd, env);
+  if (process.platform === "win32") {
+    probeCommand("where node", "where node", cwd, env);
+    probeCommand("where npm", "where npm", cwd, env);
+  } else {
+    probeCommand("which node", "which node", cwd, env);
+    probeCommand("which npm", "which npm", cwd, env);
+  }
+}
+function logExecuteDeployContext(input) {
+  const trigger = input.trigger ?? "cli";
+  const deploymentRunId = process.env[APM_DEPLOYMENT_RUN_ID_ENV]?.trim() || null;
+  const shellEnv = buildDeployShellEnv();
+  const npmGlobalBin = resolveNpmGlobalBin2();
+  const packageJsonPath = join16(input.cwd, "package.json");
+  logLine("========== executeDeploy \u4E0A\u4E0B\u6587 ==========");
+  logLine(`trigger=${trigger} deployEnv=${input.env}`);
+  logLine(`cwd(input)=${input.cwdInput}`);
+  logLine(`cwd(resolved)=${input.cwd}`);
+  logLine(`process.cwd()=${input.processCwd}`);
+  logLine(
+    `cwdMatchProcess=${input.cwd === input.processCwd ? "yes" : "no"} (connect \u901A\u5E38\u4E3A no)`
+  );
+  logLine(
+    `apm.config=${input.apmConfigPath} exists=${existsSync14(
+      input.apmConfigPath
+    )}`
+  );
+  logLine(
+    `package.json=${packageJsonPath} exists=${existsSync14(packageJsonPath)}`
+  );
+  logLine(
+    `flags captureOutput=${input.captureOutput} packOnly=${Boolean(
+      input.packOnly
+    )} archiveDeployArtifact=${Boolean(input.archiveDeployArtifact)}`
+  );
+  logLine(`configPathOption=${input.configPathOption ?? "(default)"}`);
+  logLine(`${APM_DEPLOYMENT_RUN_ID_ENV}=${deploymentRunId ?? "(unset)"}`);
+  logLine(
+    `process execPath=${process.execPath} pid=${process.pid} platform=${process.platform} arch=${process.arch}`
+  );
+  logLine(`process argv=${process.argv.join(" ")}`);
+  logLine(`npmGlobalBin=${npmGlobalBin ?? "(resolve failed)"}`);
+  logLine(`nodeDir=${dirname5(process.execPath)}`);
+  logLine("--- process.env\uFF08\u8282\u9009\uFF09---");
+  for (const [key, value] of Object.entries(
+    collectInterestingEnv(process.env)
+  )) {
+    logLine(`  ${key}=${value}`);
+  }
+  logLine(`process.env.PATH=${summarizePath(process.env.PATH)}`);
+  logLine("--- buildDeployShellEnv()\uFF08\u5B50\u8FDB\u7A0B\u5B9E\u9645 env\uFF09---");
+  logLine(describePathDelta(process.env.PATH, shellEnv.PATH));
+  logLine(`shellEnv.PATH=${summarizePath(shellEnv.PATH)}`);
+  for (const [key, value] of Object.entries(
+    pickEnvKeys(shellEnv, [APM_DEPLOYMENT_RUN_ID_ENV, "NODE_ENV"])
+  )) {
+    logLine(`  shellEnv.${key}=${value}`);
+  }
+  probeShellTooling(input.cwd, shellEnv);
+  logLine("==========================================");
+}
+function logRunDeployShellContext(input) {
+  const shellEnv = buildDeployShellEnv();
+  logLine("---------- runDeployShellCommand ----------");
+  logLine(`command=${input.command}`);
+  logLine(`cwd=${input.cwd}`);
+  logLine(`captureOutput=${input.captureOutput}`);
+  logLine(
+    `stdio=${input.captureOutput ? "stdin=inherit stdout=pipe stderr=pipe" : "inherit"}`
+  );
+  logLine(`shell=true maxBuffer=${50 * 1024 * 1024}`);
+  logLine(`shellEnv.PATH(head)=${summarizePath(shellEnv.PATH, 8)}`);
+  logLine("--------------------------------------------");
 }
-async function fetchDeployArtifactStorage(api) {
-  return api.cli.getDeployArtifactStorage(void 0);
+function logRunDeployShellResult(input) {
+  logLine(
+    `runDeployShellCommand done command=${input.command} exit=${input.exitCode ?? "null"} signal=${input.signal ?? "null"} capturedBytes=${input.outputBytes}${input.errorMessage ? ` error=${input.errorMessage}` : ""}`
+  );
 }
-async function uploadDeployArtifactZip(options) {
-  const deploymentRunId = options.deploymentRunId ?? resolveDeploymentRunIdFromEnv();
-  if (!deploymentRunId && !options.uploadWithoutRunId) {
-    return null;
-  }
-  const cfg = await tryReadApmConfig();
-  if (!cfg || !resolveApiKey(cfg)) {
-    console.warn("[apm] \u672A\u767B\u5F55\uFF0C\u8DF3\u8FC7 MinIO \u90E8\u7F72\u4EA7\u7269\u5F52\u6863");
-    return null;
-  }
-  const api = options.api ?? createApmApiClient(cfg);
-  let storage;
-  try {
-    storage = await fetchDeployArtifactStorage(api);
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    console.warn(`[apm] \u83B7\u53D6 MinIO \u914D\u7F6E\u5931\u8D25\uFF0C\u8DF3\u8FC7\u90E8\u7F72\u4EA7\u7269\u5F52\u6863: ${detail}`);
-    return null;
-  }
-  const fileName = buildDeployArtifactFileName(
-    options.kind,
-    options.projectName,
-    options.timestamp
+function logWisdomFrontendDeployContext(input) {
+  logLine("--- wisdom Vue \u524D\u7AEF ---");
+  logLine(
+    `buildKey=build:${input.env} buildCmd=${input.buildCmd ?? "(missing)"}`
   );
-  const objectKey = buildDeployArtifactObjectKey(options.projectName, fileName);
-  let body;
-  try {
-    body = await readFile2(options.zipPath);
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    console.warn(`[apm] \u8BFB\u53D6\u90E8\u7F72\u4EA7\u7269 zip \u5931\u8D25\uFF0C\u8DF3\u8FC7 MinIO \u5F52\u6863: ${detail}`);
-    return null;
+  logLine(`distDir=${input.distDir} exists=${existsSync14(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";
+
+// src/commands/deploy/deploy-shell-run.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
+function runDeployShellCommand(command, cwd, captureOutput) {
+  logRunDeployShellContext({ command, cwd, captureOutput });
+  const shellEnv = buildDeployShellEnv();
+  const result = spawnSync5(command, {
+    cwd,
+    shell: true,
+    env: shellEnv,
+    encoding: "utf8",
+    maxBuffer: DEPLOY_SPAWN_MAX_BUFFER_BYTES,
+    stdio: captureOutput ? ["inherit", "pipe", "pipe"] : "inherit"
+  });
+  const stdout = captureOutput ? String(result.stdout ?? "") : "";
+  const stderr = captureOutput ? String(result.stderr ?? "") : "";
+  const output = [stdout, stderr].filter(Boolean).join("\n");
+  logRunDeployShellResult({
+    command,
+    exitCode: result.status,
+    signal: result.signal,
+    errorMessage: result.error?.message,
+    outputBytes: Buffer.byteLength(output, "utf8")
+  });
+  if (captureOutput) {
+    if (stdout) process.stdout.write(stdout);
+    if (stderr) process.stderr.write(stderr);
   }
-  try {
-    const client = new MinioClient({
-      endPoint: storage.endpoint,
-      port: storage.port,
-      useSSL: storage.useSsl,
-      accessKey: storage.accessKey,
-      secretKey: storage.secretKey
-    });
-    await client.ensureBucket(storage.bucket);
-    await client.putObject(storage.bucket, objectKey, body, {
-      "Content-Type": "application/zip"
-    });
-    console.error(
-      `[apm] \u672C\u5730\u76F4\u4F20 MinIO\uFF08\u4E0D\u7ECF\u5E73\u53F0\u670D\u52A1\u5668\uFF09: ${storage.endpoint}:${storage.port}/${storage.bucket}/${objectKey} (${(body.length / 1024 / 1024).toFixed(
-        2
-      )} MB)`
+  if (result.error) {
+    throw new DeployExecutionError(
+      `\u90E8\u7F72\u547D\u4EE4\u6267\u884C\u5931\u8D25: ${result.error.message}`,
+      1,
+      output
     );
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    console.warn(`[apm] MinIO \u90E8\u7F72\u4EA7\u7269\u5F52\u6863\u5931\u8D25: ${detail}`);
-    return null;
   }
-  if (deploymentRunId) {
-    try {
-      await api.cli.attachTaskDeploymentArtifact({
-        id: deploymentRunId,
-        artifactObjectKey: objectKey,
-        artifactFileName: fileName
-      });
-      console.error(
-        `[apm] \u5DF2\u7ED1\u5B9A\u90E8\u7F72\u4EA7\u7269\u5230\u8BB0\u5F55 id=${deploymentRunId} file=${fileName}`
-      );
-    } catch (error) {
-      const detail = error instanceof Error ? error.message : String(error);
-      console.warn(`[apm] \u7ED1\u5B9A\u90E8\u7F72\u4EA7\u7269\u5230\u8BB0\u5F55\u5931\u8D25: ${detail}`);
-      return null;
-    }
+  if (result.status !== 0) {
+    throw new DeployExecutionError(
+      `\u90E8\u7F72\u547D\u4EE4\u9000\u51FA\u7801 ${result.status ?? "unknown"}: ${command}`,
+      result.status ?? 1,
+      output
+    );
   }
-  return {
-    objectKey,
-    fileName,
-    bucket: storage.bucket
-  };
+  return output;
 }
 
+// src/commands/deploy/internal/wisdom-backend-deploy.ts
+import {
+  existsSync as existsSync15,
+  mkdirSync as mkdirSync7,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync12,
+  statSync as statSync6,
+  writeFileSync as writeFileSync12
+} from "node:fs";
+import { spawnSync as spawnSync6 } from "node:child_process";
+import path3 from "node:path";
+import { Client as Client2 } from "ssh2";
+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";
+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) {
@@ -4208,10 +4380,27 @@ async function uploadAndMaybeExtract(settings, localZip, extract) {
     await sftp.end();
   }
 }
+function resolveDeployArtifactUpload(input) {
+  const { packOnly, archiveDeployArtifact, deploymentRunId } = input;
+  if (deploymentRunId) {
+    return { upload: true, uploadWithoutRunId: false };
+  }
+  if (archiveDeployArtifact || packOnly) {
+    return { upload: true, uploadWithoutRunId: true };
+  }
+  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 packOnly = Boolean(params.packOnly);
+  const archiveDeployArtifact = Boolean(params.archiveDeployArtifact);
+  const deploymentRunId = resolveDeploymentRunIdFromEnv();
+  const artifactUpload = resolveDeployArtifactUpload({
+    packOnly,
+    archiveDeployArtifact,
+    deploymentRunId
+  });
   let zipSizeBytes = 0;
   let artifactUploaded = false;
   try {
@@ -4225,15 +4414,21 @@ async function runWisdomSftpDeploy(params) {
     } else {
       console.error("[apm] \u4EC5\u6253\u5305\u6A21\u5F0F\uFF1A\u8DF3\u8FC7 SFTP \u8FDC\u7A0B\u4E0A\u4F20");
     }
-    const artifact = await uploadDeployArtifactZip({
-      zipPath: resolvedZipPath,
-      projectName: params.projectName,
-      kind: "frontend",
-      uploadWithoutRunId: packOnly && !resolveDeploymentRunIdFromEnv()
-    });
-    artifactUploaded = artifact !== null;
-    if (packOnly && artifactUploaded) {
-      console.error("\u6253\u5305\u5E76\u4E0A\u4F20 MinIO \u5B8C\u6210\uFF08\u672A\u4E0A\u4F20\u8FDC\u7A0B\u670D\u52A1\u5668\uFF09");
+    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 {
+        console.error("[apm] SFTP \u90E8\u7F72\u5B8C\u6210\uFF0C\u90E8\u7F72\u4EA7\u7269\u5DF2\u5F52\u6863 MinIO");
+      }
     }
   } finally {
     try {
@@ -4303,7 +4498,7 @@ function fileSignature(filePath) {
 }
 function loadManifest3() {
   const manifestPath2 = manifestFilePath();
-  if (!existsSync14(manifestPath2)) {
+  if (!existsSync15(manifestPath2)) {
     return {};
   }
   return JSON.parse(readFileSync12(manifestPath2, "utf8"));
@@ -4388,7 +4583,7 @@ function getMvnExecutable() {
   const isWin = process.platform === "win32";
   const candidates = isWin ? ["mvn.cmd", "mvn.bat", "mvn"] : ["mvn"];
   for (const name of candidates) {
-    const result = spawnSync5(isWin ? `where ${name}` : `which ${name}`, {
+    const result = spawnSync6(isWin ? `where ${name}` : `which ${name}`, {
       encoding: "utf8",
       shell: true
     });
@@ -4418,7 +4613,7 @@ function runMavenBuild(projectRoot, mavenLocalRepo, repoSource) {
     log(`Maven \u672C\u5730\u4ED3\u5E93: ${mavenRepo}`);
   }
   log(`\u6784\u5EFA\u76EE\u5F55: ${projectRoot}`);
-  const result = spawnSync5(command, {
+  const result = spawnSync6(command, {
     cwd: projectRoot,
     stdio: "inherit",
     shell: true,
@@ -4430,11 +4625,11 @@ function runMavenBuild(projectRoot, mavenLocalRepo, repoSource) {
 }
 function locateLibDir(projectRoot) {
   const targetDir = getTargetDir(projectRoot);
-  if (!existsSync14(targetDir)) {
+  if (!existsSync15(targetDir)) {
     fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
   }
   const libDir = path3.join(targetDir, "lib");
-  if (!existsSync14(libDir) || !statSync6(libDir).isDirectory()) {
+  if (!existsSync15(libDir) || !statSync6(libDir).isDirectory()) {
     fail(`lib \u76EE\u5F55\u4E0D\u5B58\u5728: ${libDir}`);
   }
   const libJars = readdirSync5(libDir).filter((name) => name.endsWith(".jar"));
@@ -4446,7 +4641,7 @@ function locateLibDir(projectRoot) {
 }
 function locateMainJar(projectRoot) {
   const targetDir = getTargetDir(projectRoot);
-  if (!existsSync14(targetDir)) {
+  if (!existsSync15(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);
@@ -4919,22 +5114,17 @@ async function runWisdomBackendDeploy(options) {
   log("\u90E8\u7F72\u5B8C\u6210");
 }
 
-// src/commands/deploy/internal/wisdom-auto-deploy.ts
-function isWisdomLegacyDeploy(cfg) {
+// src/commands/deploy/internal/wisdom-deploy.ts
+function isWisdomDeployConfigured(cfg) {
   const w = cfg.wisdomDeploy;
-  if (!w?.host?.trim() || !w.remotePath?.trim()) {
-    return false;
-  }
-  const hasNewFrontend = Boolean(cfg.frontendDeploy?.endpoint?.trim());
-  const hasNewBackend = Boolean(cfg.backendDeploy?.registryHost?.trim());
-  return !hasNewFrontend && !hasNewBackend;
+  return Boolean(w?.host?.trim() && w?.remotePath?.trim());
 }
 function detectWisdomProjectType(cwd) {
-  return existsSync15(path4.join(cwd, "package.json")) ? "frontend" : "backend";
+  return existsSync16(path4.join(cwd, "package.json")) ? "frontend" : "backend";
 }
 function readPackageScripts(cwd) {
   const pkgPath = path4.join(cwd, "package.json");
-  if (!existsSync15(pkgPath)) {
+  if (!existsSync16(pkgPath)) {
     return {};
   }
   try {
@@ -4945,14 +5135,6 @@ function readPackageScripts(cwd) {
     return {};
   }
 }
-function resolveFrontendDeployCommand(env, cwd) {
-  const scripts = readPackageScripts(cwd);
-  const deployKey = `deploy:${env}`;
-  if (scripts[deployKey]?.trim()) {
-    return `npm run deploy:${env}`;
-  }
-  return null;
-}
 function resolveFrontendBuildCommand(env, cwd) {
   const scripts = readPackageScripts(cwd);
   const buildKey = `build:${env}`;
@@ -4966,7 +5148,7 @@ function resolveFrontendDistDir(cwd) {
   for (const rel of candidates) {
     const full = path4.join(cwd, rel);
     try {
-      if (existsSync15(full) && statSync7(full).isDirectory()) {
+      if (existsSync16(full) && statSync7(full).isDirectory()) {
         return full;
       }
     } catch {
@@ -4974,62 +5156,57 @@ function resolveFrontendDistDir(cwd) {
   }
   return path4.join(cwd, "dist");
 }
-async function runWisdomAutoDeploy(options) {
-  const cwd = path4.resolve(options.cwd ?? process.cwd());
-  const captureOutput = options.captureOutput ?? false;
-  const packOnly = Boolean(options.packOnly);
-  const projectType = detectWisdomProjectType(cwd);
-  const configPath = options.configPath ?? path4.join(workspaceApmDir(cwd), "apm.config.json");
-  const cfg = loadApmConfig({ configPath });
+async function executeWisdomFrontendDeploy(options) {
+  const { cwd, cfg, captureOutput, packOnly, archiveDeployArtifact } = options;
+  const buildCmd = resolveFrontendBuildCommand(options.env, cwd);
+  const distDir = resolveFrontendDistDir(cwd);
+  logWisdomFrontendDeployContext({
+    env: options.env,
+    cwd,
+    buildCmd,
+    distDir,
+    packOnly,
+    archiveDeployArtifact
+  });
+  if (!buildCmd) {
+    const lines = formatWisdomFrontendBuildNotConfiguredLines(
+      options.env,
+      path4.join(cwd, "package.json")
+    );
+    throw new DeployExecutionError(lines.join("\n"), 1, lines.join("\n"));
+  }
   console.error(
-    `[apm] \u533B\u52A1\u5B58\u91CF\u9879\u76EE\u81EA\u52A8\u8BC6\u522B: ${projectType === "frontend" ? "\u524D\u7AEF Vue" : "\u540E\u7AEF Java"}${packOnly ? "\uFF08\u4EC5\u6253\u5305\u6A21\u5F0F\uFF09" : ""}`
+    `[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" : ""))
   );
-  if (projectType === "frontend") {
-    if (packOnly) {
-      const buildCmd = resolveFrontendBuildCommand(options.env, cwd);
-      if (!buildCmd) {
-        const lines = formatWisdomFrontendBuildNotConfiguredLines(
-          options.env,
-          path4.join(cwd, "package.json")
-        );
-        throw new DeployExecutionError(lines.join("\n"), 1, lines.join("\n"));
-      }
-      console.error(`[apm] \u524D\u7AEF\u4EC5\u6253\u5305\u6A21\u5F0F\uFF1A\u6267\u884C ${buildCmd}`);
-      runDeployShellCommand(buildCmd, cwd, captureOutput);
-      const projectName = (cfg.name ?? "").trim();
-      if (!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
-        );
-      }
-      const settings2 = resolveWisdomDeployFromApmConfig(cfg);
-      await runWisdomSftpDeploy({
-        localDir: resolveFrontendDistDir(cwd),
-        settings: settings2,
-        extract: false,
-        projectName,
-        packOnly: true
-      });
-      return { projectType };
-    }
-    const deployCmd = resolveFrontendDeployCommand(options.env, cwd);
-    if (!deployCmd) {
-      const lines = formatWisdomFrontendDeployNotConfiguredLines(
-        options.env,
-        path4.join(cwd, "package.json")
-      );
-      throw new DeployExecutionError(lines.join("\n"), 1, lines.join("\n"));
-    }
-    runDeployShellCommand(deployCmd, cwd, captureOutput);
-    return { projectType };
+  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 settings = resolveWisdomDeployFromApmConfig(cfg);
+  await runWisdomSftpDeploy({
+    localDir: distDir,
+    settings,
+    extract: !packOnly,
+    projectName,
+    packOnly,
+    archiveDeployArtifact
+  });
+}
+async function executeWisdomBackendDeployFlow(options) {
+  const { cwd, cfg, packOnly } = options;
   const settings = resolveWisdomBackendDeployFromApmConfig(cfg);
   if (packOnly) {
-    console.error(`[apm] \u540E\u7AEF\u4EC5\u6253\u5305\u6A21\u5F0F\uFF0C\u5FFD\u7565\u73AF\u5883\u53C2\u6570: ${options.env}`);
+    console.error(`[apm] Java\uFF1AMaven \u6784\u5EFA\uFF08\u4EC5\u6253\u5305\uFF0C\u5FFD\u7565\u73AF\u5883 ${options.env}\uFF09`);
   } else {
     console.error(
-      `[apm] \u540E\u7AEF\u90E8\u7F72\u4E0D\u533A\u5206 test/online\uFF0C\u5FFD\u7565\u73AF\u5883\u53C2\u6570: ${options.env}`
+      `[apm] Java\uFF1AMaven \u6784\u5EFA\u5E76\u90E8\u7F72\uFF08\u4E0D\u533A\u5206 test/online\uFF0C\u5FFD\u7565\u73AF\u5883 ${options.env}\uFF09`
     );
   }
   await runWisdomBackendDeploy({
@@ -5037,11 +5214,40 @@ async function runWisdomAutoDeploy(options) {
     projectRoot: cwd,
     packOnly
   });
+}
+async function executeWisdomDeploy(options) {
+  const cwd = path4.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 cfg = loadApmConfig({ configPath });
+  console.error(
+    `[apm] ${projectType === "frontend" ? "Vue \u524D\u7AEF" : "Java \u540E\u7AEF"}${packOnly ? "\uFF08\u4EC5\u6253\u5305\uFF09" : ""}`
+  );
+  if (projectType === "frontend") {
+    await executeWisdomFrontendDeploy({
+      ...options,
+      cwd,
+      cfg,
+      captureOutput,
+      packOnly,
+      archiveDeployArtifact
+    });
+    return { projectType };
+  }
+  await executeWisdomBackendDeployFlow({
+    ...options,
+    cwd,
+    cfg,
+    packOnly
+  });
   return { projectType };
 }
 
 // src/commands/deploy/internal/deploy-baseline-sync.ts
-var LOG_PREFIX = "[apm] \u90E8\u7F72\u524D\u57FA\u7EBF\u540C\u6B65:";
+var LOG_PREFIX2 = "[apm] \u90E8\u7F72\u524D\u57FA\u7EBF\u540C\u6B65:";
 function formatGitError(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -5077,20 +5283,20 @@ async function restoreWorkingTree(cwd) {
 }
 async function mergeBaselineBranch(cwd, baselineBranch, currentBranch, note) {
   const mergeTarget = `origin/${baselineBranch}`;
-  note(`${LOG_PREFIX} \u5F00\u59CB\u5408\u5E76 ${mergeTarget} \u5230\u5F53\u524D\u5206\u652F ${currentBranch}`);
+  note(`${LOG_PREFIX2} \u5F00\u59CB\u5408\u5E76 ${mergeTarget} \u5230\u5F53\u524D\u5206\u652F ${currentBranch}`);
   try {
     if (currentBranch === baselineBranch) {
       await execGit(cwd, ["merge", "--ff-only", mergeTarget]);
     } else {
       await execGit(cwd, ["merge", mergeTarget, "--no-edit"]);
     }
-    note(`${LOG_PREFIX} \u5DF2\u5408\u5E76 ${mergeTarget} \u6700\u65B0\u4EE3\u7801`);
+    note(`${LOG_PREFIX2} \u5DF2\u5408\u5E76 ${mergeTarget} \u6700\u65B0\u4EE3\u7801`);
     return { merged: true, conflictRollback: false };
   } catch (error) {
     await abortMergeIfNeeded(cwd);
-    note(`${LOG_PREFIX} \u5408\u5E76 ${mergeTarget} \u5931\u8D25: ${formatGitError(error)}`);
-    note(`${LOG_PREFIX} \u5DF2\u6267\u884C git merge --abort \u56DE\u9000\u5230\u5408\u5E76\u524D\u72B6\u6001`);
-    note(`${LOG_PREFIX} \u5C06\u4F7F\u7528\u56DE\u9000\u540E\u7684\u4EE3\u7801\u7EE7\u7EED\u90E8\u7F72`);
+    note(`${LOG_PREFIX2} \u5408\u5E76 ${mergeTarget} \u5931\u8D25: ${formatGitError(error)}`);
+    note(`${LOG_PREFIX2} \u5DF2\u6267\u884C git merge --abort \u56DE\u9000\u5230\u5408\u5E76\u524D\u72B6\u6001`);
+    note(`${LOG_PREFIX2} \u5C06\u4F7F\u7528\u56DE\u9000\u540E\u7684\u4EE3\u7801\u7EE7\u7EED\u90E8\u7F72`);
     return { merged: false, conflictRollback: true };
   }
 }
@@ -5098,17 +5304,17 @@ async function restoreStashIfNeeded(cwd, stashed, note) {
   if (!stashed) {
     return false;
   }
-  note(`${LOG_PREFIX} \u6B63\u5728\u6062\u590D stash \u4E2D\u7684\u672A\u63D0\u4EA4\u6539\u52A8`);
+  note(`${LOG_PREFIX2} \u6B63\u5728\u6062\u590D stash \u4E2D\u7684\u672A\u63D0\u4EA4\u6539\u52A8`);
   try {
     await execGit(cwd, ["stash", "pop"], true);
-    note(`${LOG_PREFIX} \u5DF2\u6062\u590D stash \u4E2D\u7684\u672A\u63D0\u4EA4\u6539\u52A8`);
+    note(`${LOG_PREFIX2} \u5DF2\u6062\u590D stash \u4E2D\u7684\u672A\u63D0\u4EA4\u6539\u52A8`);
     return false;
   } catch (error) {
     await abortMergeIfNeeded(cwd);
     await restoreWorkingTree(cwd);
-    note(`${LOG_PREFIX} \u6062\u590D stash \u5931\u8D25: ${formatGitError(error)}`);
-    note(`${LOG_PREFIX} \u5DF2\u56DE\u9000\u5DE5\u4F5C\u533A\uFF08git reset --hard HEAD\uFF09\uFF0Cstash \u4ECD\u4FDD\u7559`);
-    note(`${LOG_PREFIX} \u5C06\u4F7F\u7528\u56DE\u9000\u540E\u7684\u4EE3\u7801\u7EE7\u7EED\u90E8\u7F72`);
+    note(`${LOG_PREFIX2} \u6062\u590D stash \u5931\u8D25: ${formatGitError(error)}`);
+    note(`${LOG_PREFIX2} \u5DF2\u56DE\u9000\u5DE5\u4F5C\u533A\uFF08git reset --hard HEAD\uFF09\uFF0Cstash \u4ECD\u4FDD\u7559`);
+    note(`${LOG_PREFIX2} \u5C06\u4F7F\u7528\u56DE\u9000\u540E\u7684\u4EE3\u7801\u7EE7\u7EED\u90E8\u7F72`);
     return true;
   }
 }
@@ -5127,30 +5333,30 @@ async function syncDeployBaselineBeforeDeploy(cwd) {
     ...partial
   });
   if (!await isGitRepo(cwd)) {
-    note(`${LOG_PREFIX} \u5F53\u524D\u76EE\u5F55\u4E0D\u662F git \u4ED3\u5E93\uFF0C\u8DF3\u8FC7`);
+    note(`${LOG_PREFIX2} \u5F53\u524D\u76EE\u5F55\u4E0D\u662F git \u4ED3\u5E93\uFF0C\u8DF3\u8FC7`);
     return emptyResult();
   }
   const cfg = await tryReadApmConfig();
   if (!cfg || !resolveApiKey(cfg)) {
-    note(`${LOG_PREFIX} \u672A\u767B\u5F55\uFF0C\u8DF3\u8FC7`);
+    note(`${LOG_PREFIX2} \u672A\u767B\u5F55\uFF0C\u8DF3\u8FC7`);
     return emptyResult();
   }
   await ensureGitRepo(cwd);
   const api = createApmApiClient(cfg);
   const baselineBranch = await resolveBaselineBranch2(cwd, api);
-  note(`${LOG_PREFIX} \u57FA\u7EBF\u5206\u652F ${baselineBranch}`);
-  note(`${LOG_PREFIX} \u6B63\u5728 fetch origin ${baselineBranch}`);
+  note(`${LOG_PREFIX2} \u57FA\u7EBF\u5206\u652F ${baselineBranch}`);
+  note(`${LOG_PREFIX2} \u6B63\u5728 fetch origin ${baselineBranch}`);
   await execGit(cwd, ["fetch", "origin", baselineBranch], true);
   if (!await remoteBranchExists(cwd, baselineBranch)) {
     throw new Error(
       `\u8FDC\u7A0B\u4E0D\u5B58\u5728\u57FA\u7EBF\u5206\u652F origin/${baselineBranch}\uFF0C\u8BF7\u786E\u8BA4\u4ED3\u5E93\u9ED8\u8BA4\u5206\u652F\u5DF2\u63A8\u9001\u5230 origin`
     );
   }
-  note(`${LOG_PREFIX} fetch \u5B8C\u6210`);
+  note(`${LOG_PREFIX2} fetch \u5B8C\u6210`);
   const currentBranch = await getCurrentBranch(cwd);
   let stashed = false;
   if (await isWorkingTreeDirty(cwd)) {
-    note(`${LOG_PREFIX} \u68C0\u6D4B\u5230\u672A\u63D0\u4EA4\u6539\u52A8\uFF0C\u5148 stash`);
+    note(`${LOG_PREFIX2} \u68C0\u6D4B\u5230\u672A\u63D0\u4EA4\u6539\u52A8\uFF0C\u5148 stash`);
     await execGit(cwd, [
       "stash",
       "push",
@@ -5159,7 +5365,7 @@ async function syncDeployBaselineBeforeDeploy(cwd) {
       "apm: deploy baseline sync"
     ]);
     stashed = true;
-    note(`${LOG_PREFIX} \u5DF2 stash \u672A\u63D0\u4EA4\u6539\u52A8`);
+    note(`${LOG_PREFIX2} \u5DF2 stash \u672A\u63D0\u4EA4\u6539\u52A8`);
   }
   const { merged, conflictRollback } = await mergeBaselineBranch(
     cwd,
@@ -5169,10 +5375,10 @@ async function syncDeployBaselineBeforeDeploy(cwd) {
   );
   const stashConflict = await restoreStashIfNeeded(cwd, stashed, note);
   if (conflictRollback || stashConflict) {
-    note(`${LOG_PREFIX} \u57FA\u7EBF\u540C\u6B65\u672A\u5B8C\u6210\uFF08\u5B58\u5728\u51B2\u7A81\u5E76\u5DF2\u56DE\u9000\uFF09\uFF0C\u7EE7\u7EED\u6267\u884C\u90E8\u7F72`);
+    note(`${LOG_PREFIX2} \u57FA\u7EBF\u540C\u6B65\u672A\u5B8C\u6210\uFF08\u5B58\u5728\u51B2\u7A81\u5E76\u5DF2\u56DE\u9000\uFF09\uFF0C\u7EE7\u7EED\u6267\u884C\u90E8\u7F72`);
   } else if (merged) {
     note(
-      `${LOG_PREFIX} \u5B8C\u6210\uFF08\u5F53\u524D\u5206\u652F ${currentBranch} \u5DF2\u5305\u542B ${baselineBranch} \u6700\u65B0\u4EE3\u7801\uFF09`
+      `${LOG_PREFIX2} \u5B8C\u6210\uFF08\u5F53\u524D\u5206\u652F ${currentBranch} \u5DF2\u5305\u542B ${baselineBranch} \u6700\u65B0\u4EE3\u7801\uFF09`
     );
   }
   return {
@@ -5186,10 +5392,26 @@ async function syncDeployBaselineBeforeDeploy(cwd) {
 
 // src/commands/deploy/deploy-execute.ts
 async function executeDeploy(options) {
-  const cwd = resolveWorkdirPath(options.cwd ?? process.cwd());
+  const cwdInput = options.cwd.trim();
+  if (!cwdInput) {
+    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 captureOutput = options.captureOutput ?? false;
   const outputParts = [];
+  logExecuteDeployContext({
+    trigger: options.deployTrigger,
+    env: options.env,
+    cwd,
+    cwdInput,
+    processCwd: process.cwd(),
+    apmConfigPath,
+    captureOutput,
+    packOnly: options.packOnly,
+    archiveDeployArtifact: options.archiveDeployArtifact,
+    configPathOption: options.configPath
+  });
   try {
     const configSyncResult = await syncRemoteDeploymentConfig(
       cwd,
@@ -5212,36 +5434,29 @@ async function executeDeploy(options) {
       detail
     );
   }
+  const preDeployLog = outputParts.join("\n");
   const cfg = loadApmConfig({ configPath: apmConfigPath });
-  if (isWisdomLegacyDeploy(cfg)) {
-    try {
-      await runWisdomAutoDeploy({
-        env: options.env,
-        cwd,
-        configPath: apmConfigPath,
-        captureOutput,
-        packOnly: options.packOnly
-      });
-      return outputParts.join("\n");
-    } catch (error) {
-      if (error instanceof DeployExecutionError) {
-        throw error;
-      }
-      const detail = error instanceof Error ? error.message : String(error);
-      throw new DeployExecutionError(detail, 1);
-    }
-  }
-  const deployCommands = cfg.deploy ?? {};
-  const command = deployCommands[options.env]?.trim();
-  if (!command) {
-    const lines = formatDeployNotConfiguredLines(options.env, deployCommands);
+  if (!isWisdomDeployConfigured(cfg)) {
+    const lines = formatMissingWisdomDeployLines();
     throw new DeployExecutionError(lines.join("\n"), 1, lines.join("\n"));
   }
-  const commandOutput = runDeployShellCommand(command, cwd, captureOutput);
-  if (commandOutput.trim()) {
-    outputParts.push(commandOutput);
+  try {
+    await executeWisdomDeploy({
+      env: options.env,
+      cwd,
+      configPath: apmConfigPath,
+      captureOutput,
+      packOnly: options.packOnly,
+      archiveDeployArtifact: options.archiveDeployArtifact
+    });
+    return preDeployLog;
+  } catch (error) {
+    if (error instanceof DeployExecutionError) {
+      throw error;
+    }
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new DeployExecutionError(detail, 1);
   }
-  return outputParts.join("\n");
 }
 function printDeployExecutionError(error) {
   if (error.output.trim()) {
@@ -5390,7 +5605,9 @@ async function handleInboundDeploy(cfg, msg, signal) {
     env: msg.environment,
     cwd: workdir,
     packOnly: msg.packOnly,
-    captureOutput: true
+    captureOutput: true,
+    archiveDeployArtifact: true,
+    deployTrigger: "connect"
   };
   try {
     if (signal.aborted) return;
@@ -5706,13 +5923,13 @@ ${JSON.stringify(event, null, 2)}
 }
 
 // src/commands/connect/agent-session-registry.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname5, resolve as resolve4 } from "node:path";
+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";
 function registryPath(workdir, sessionId) {
   return resolve4(workdir, ".apm", "sessions", sessionId, "cursor-agents.json");
 }
 function readRegistry(path13) {
-  if (!existsSync16(path13)) {
+  if (!existsSync17(path13)) {
     return {};
   }
   try {
@@ -5733,7 +5950,7 @@ function readRegistry(path13) {
   return {};
 }
 function writeRegistry(path13, registry) {
-  mkdirSync8(dirname5(path13), { recursive: true });
+  mkdirSync8(dirname6(path13), { recursive: true });
   writeFileSync13(path13, `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
@@ -6184,15 +6401,15 @@ async function ensureMessageHasReply(cfg, sessionId, messageId, fallback) {
 }
 
 // src/commands/connect/cli-version-sync.ts
-import { existsSync as existsSync17, readFileSync as readFileSync15, writeFileSync as writeFileSync14 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync15, writeFileSync as writeFileSync14 } from "fs";
+import { join as join17 } from "path";
 var CLI_VERSION_FILE = ".cli-version.json";
 function manifestPath(apmDir) {
-  return join16(apmDir, CLI_VERSION_FILE);
+  return join17(apmDir, CLI_VERSION_FILE);
 }
 function loadManifest4(apmDir) {
   const path13 = toFsPath(manifestPath(apmDir));
-  if (!existsSync17(path13)) {
+  if (!existsSync18(path13)) {
     return null;
   }
   try {
@@ -6260,23 +6477,53 @@ function markPullDone(sessionId, workdir) {
 
 // src/commands/connect/run-slot-pool.ts
 var DEFAULT_MAX_CONCURRENT = 5;
-function createRunSlotPool(maxConcurrent = DEFAULT_MAX_CONCURRENT) {
+function createRunSlotPool(maxConcurrent = DEFAULT_MAX_CONCURRENT, options = {}) {
+  const label = options.label ?? "task";
+  const isDeployPool = label === "deploy";
   let active = 0;
   const waiters = [];
-  const acquire = () => {
+  const logDeploy = (message) => {
+    if (isDeployPool) {
+      console.error(`[apm] deploy \u4E32\u884C\u9650\u6D41\uFF1A${message}`);
+    }
+  };
+  const acquire = (meta) => {
     if (active < maxConcurrent) {
       active += 1;
+      if (isDeployPool) {
+        logDeploy(
+          `\u5F00\u59CB\u6267\u884C${meta ? `\uFF08${meta}\uFF09` : ""}\uFF0C\u5F53\u524D\u5360\u7528 ${active}/${maxConcurrent}`
+        );
+      }
       return Promise.resolve();
     }
+    const queueIndex = waiters.length + 1;
+    if (isDeployPool) {
+      logDeploy(
+        `\u5E76\u53D1\u5DF2\u6EE1\uFF08${maxConcurrent}/${maxConcurrent}\uFF09\uFF0C${meta ? `${meta} ` : ""}\u8FDB\u5165\u6392\u961F\uFF0C\u524D\u65B9 ${queueIndex} \u4E2A`
+      );
+    }
+    const queuedAt = Date.now();
     return new Promise((resolve5) => {
       waiters.push(() => {
         active += 1;
+        const waitedMs = Date.now() - queuedAt;
+        if (isDeployPool) {
+          logDeploy(
+            `\u6392\u961F\u7ED3\u675F\uFF0C\u5F00\u59CB\u6267\u884C${meta ? `\uFF08${meta}\uFF09` : ""}\uFF0C\u7B49\u5F85 ${Math.ceil(
+              waitedMs / 1e3
+            )}s\uFF0C\u5F53\u524D\u5360\u7528 ${active}/${maxConcurrent}`
+          );
+        }
         resolve5();
       });
     });
   };
   const release = () => {
     active = Math.max(0, active - 1);
+    if (isDeployPool) {
+      logDeploy(`\u6267\u884C\u69FD\u91CA\u653E\uFF0C\u5F53\u524D\u5360\u7528 ${active}/${maxConcurrent}`);
+    }
     const next = waiters.shift();
     if (next) {
       next();
@@ -6473,6 +6720,7 @@ function attachWsHandlers(ws, ctx, onOpen) {
     clientMachineId,
     shutdownAbort,
     runSlots,
+    deployRunSlots,
     activeTasks,
     activeRuns,
     pendingCancels,
@@ -6511,12 +6759,13 @@ function attachWsHandlers(ws, ctx, onOpen) {
         shutdownAbort.signal,
         perDeployController.signal
       ]);
+      const deploySlotMeta = `deploymentRunId=${msg2.deploymentRunId} env=${msg2.environment} workdir=${msg2.workdir}`;
       const task2 = (async () => {
-        await runSlots.acquire();
+        await deployRunSlots.acquire(deploySlotMeta);
         try {
           await handleInboundDeploy(cfg, msg2, signal2);
         } finally {
-          runSlots.release();
+          deployRunSlots.release();
         }
       })();
       activeTasks.add(task2);
@@ -6674,6 +6923,7 @@ async function runConnect(options) {
   const lifecycleAbort = new AbortController();
   const shutdownAbort = new AbortController();
   const runSlots = createRunSlotPool();
+  const deployRunSlots = createRunSlotPool(1, { label: "deploy" });
   const activeTasks = /* @__PURE__ */ new Set();
   const activeRuns = /* @__PURE__ */ new Map();
   const pendingCancels = /* @__PURE__ */ new Set();
@@ -6683,6 +6933,7 @@ async function runConnect(options) {
     clientMachineId,
     shutdownAbort,
     runSlots,
+    deployRunSlots,
     activeTasks,
     activeRuns,
     pendingCancels,
@@ -6921,7 +7172,7 @@ async function runDeployWithBackendTracking(options) {
     const run = await api.cli.createTaskDeployment({
       sessionId: options.sessionId,
       environment,
-      workdirPath: options.cwd ?? process.cwd()
+      workdirPath: options.cwd
     });
     deploymentRunId = run.id;
     console.log(
@@ -6957,7 +7208,11 @@ async function runDeployWithBackendTracking(options) {
     originalError.apply(console, args);
   };
   try {
-    const output = await executeDeploy({ ...options, captureOutput: true });
+    const output = await executeDeploy({
+      ...options,
+      captureOutput: true,
+      archiveDeployArtifact: true
+    });
     if (output.trim()) {
       appendLog(output);
     }
@@ -7000,8 +7255,8 @@ async function runDeployWithBackendTracking(options) {
 // src/commands/deploy/deploy.ts
 function registerDeployMainCommand(program) {
   program.command("deploy").description(
-    "\u7EDF\u4E00\u90E8\u7F72\uFF08\u6267\u884C\u524D\u81EA\u52A8\u540C\u6B65\u90E8\u7F72\u914D\u7F6E\u5E76\u5408\u5E76\u57FA\u7EBF\u5206\u652F\uFF09\uFF1A\u533B\u52A1\u5B58\u91CF\u81EA\u52A8\u8BC6\u522B\u524D\u540E\u7AEF\uFF1B\u5176\u4ED6\u9879\u76EE\u6309 deploy.<\u73AF\u5883> \u6267\u884C shell \u547D\u4EE4"
-  ).argument("<env>", "\u90E8\u7F72\u73AF\u5883\u540D\uFF08\u5982 test\u3001online\uFF09").option(
+    "\u533B\u52A1\u90E8\u7F72\uFF1AVue build + SFTP / Java Maven + SSH\uFF08\u9700 apm.config.json wisdomDeploy\uFF09"
+  ).argument("<env>", "\u90E8\u7F72\u73AF\u5883\u540D\uFF08\u5982 test\u3001online\uFF1BVue \u5BF9\u5E94 build:<env>\uFF09").option(
     "--config <path>",
     "apm.config.json \u8DEF\u5F84\uFF08\u9ED8\u8BA4 .apm/apm.config.json\uFF09"
   ).option(
@@ -7009,7 +7264,7 @@ function registerDeployMainCommand(program) {
     "\u6C9F\u901A\u7FA4 ID\uFF1B\u4F20\u5165\u65F6\u5728\u5E73\u53F0\u521B\u5EFA\u90E8\u7F72\u8BB0\u5F55\u5E76\u540C\u6B65\u65E5\u5FD7"
   ).option(
     "--pack-only",
-    "\u4EC5\u6784\u5EFA/\u6253\u5305\u5E76\u4E0A\u4F20 MinIO \u5F52\u6863\uFF0C\u4E0D\u4E0A\u4F20\u8FDC\u7A0B\u670D\u52A1\u5668\uFF08\u524D\u7AEF build:<env>\uFF0C\u540E\u7AEF Maven \u6784\u5EFA\uFF09"
+    "\u4EC5\u6784\u5EFA/\u6253\u5305\uFF0C\u4E0D\u4E0A\u4F20\u8FDC\u7A0B SFTP/SSH\uFF1B\u53EF\u5F52\u6863\u5E73\u53F0\u90E8\u7F72\u4EA7\u7269"
   ).action(
     async (env, opts) => {
       const cwd = process.cwd();
@@ -7022,11 +7277,18 @@ function registerDeployMainCommand(program) {
             cwd,
             configPath: opts.config,
             sessionId,
-            packOnly
+            packOnly,
+            deployTrigger: "session"
           });
           return;
         }
-        await executeDeploy({ env, cwd, configPath: opts.config, packOnly });
+        await executeDeploy({
+          env,
+          cwd,
+          configPath: opts.config,
+          packOnly,
+          deployTrigger: "cli"
+        });
       } catch (error) {
         if (error instanceof DeployExecutionError) {
           printDeployExecutionError(error);
@@ -7048,7 +7310,7 @@ import path9 from "node:path";
 import Docker from "dockerode";
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/connection-options.ts
-import { existsSync as existsSync18, readFileSync as readFileSync16 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync16 } from "node:fs";
 import path6 from "node:path";
 function asOptionalTlsBuffer(value) {
   if (typeof value !== "string") {
@@ -7060,7 +7322,7 @@ function asOptionalTlsBuffer(value) {
   if (normalized === "") {
     return void 0;
   }
-  if (existsSync18(normalized)) {
+  if (existsSync19(normalized)) {
     return readFileSync16(normalized);
   }
   const looksLikePath = /[\\/]/.test(normalized) || normalized.endsWith(".pem");
@@ -7271,7 +7533,7 @@ var DockerodeClient = class {
 var createDockerodeClient = (config) => new DockerodeClient(config);
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/env.ts
-import { existsSync as existsSync19, readFileSync as readFileSync17, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync20, readFileSync as readFileSync17, statSync as statSync8 } from "node:fs";
 import path7 from "node:path";
 function stripSurroundingQuotes(value) {
   const t = value.trim();
@@ -7288,7 +7550,7 @@ function loadEnvFromFile(envFilePath) {
     return {};
   }
   const targetPath = path7.resolve(envFilePath);
-  if (!existsSync19(targetPath) || !statSync8(targetPath).isFile()) {
+  if (!existsSync20(targetPath) || !statSync8(targetPath).isFile()) {
     return {};
   }
   const raw = readFileSync17(targetPath, "utf-8");
@@ -7462,12 +7724,12 @@ function dockerPushImage(params, cwd) {
 }
 
 // src/commands/deploy/internal/backend-deploy/resolve-dockerfile.ts
-import { existsSync as existsSync20 } from "node:fs";
+import { existsSync as existsSync21 } from "node:fs";
 import path8 from "node:path";
 function resolveDockerBuildPaths(cwd) {
   const dockerfilePath = path8.join(cwd, "Dockerfile");
   Logger.info(`\u67E5\u627EDockerfile\u6587\u4EF6\uFF0C\u8DEF\u5F84: ${dockerfilePath}`);
-  if (!existsSync20(dockerfilePath)) {
+  if (!existsSync21(dockerfilePath)) {
     throw new Error(`Dockerfile \u4E0D\u5B58\u5728\uFF1A${dockerfilePath}`);
   }
   Logger.info("\u2713 Dockerfile \u5B58\u5728");