ai-project-manage-cli 6.0.84 → 6.0.85

package/dist/index.js

@@ -490,6 +490,16 @@ var requestConfig = {
     completeTaskDeployment: defineEndpoint({
       method: "PUT",
       path: "/cli/task-deployments/complete"
+    }),
+    getDeployArtifactStorage: defineEndpoint(
+      {
+        method: "GET",
+        path: "/cli/deploy-artifact-storage"
+      }
+    ),
+    attachTaskDeploymentArtifact: defineEndpoint({
+      method: "PUT",
+      path: "/cli/task-deployments/artifact"
     })
   }
 };
@@ -835,6 +845,24 @@ async function isGitRepo(cwd) {
     return false;
   }
 }
+async function ensureGitRepo(cwd) {
+  await execGit(cwd, ["rev-parse", "--git-dir"], true);
+}
+async function getCurrentBranch(cwd) {
+  return (await execGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"], true)).trim();
+}
+async function isWorkingTreeDirty(cwd) {
+  const out = await execGit(cwd, ["status", "--porcelain"], true);
+  return out.trim().length > 0;
+}
+async function remoteBranchExists(cwd, branch) {
+  const out = await execGit(
+    cwd,
+    ["ls-remote", "--heads", "origin", branch],
+    true
+  );
+  return out.trim().length > 0;
+}
 async function hasUpstream(cwd) {
   try {
     await execGit(cwd, ["rev-parse", "--abbrev-ref", "@{upstream}"], true);
@@ -1023,14 +1051,14 @@ async function execGit2(cwd, args, quiet) {
     );
   }
 }
-async function ensureGitRepo(cwd) {
+async function ensureGitRepo2(cwd) {
   await execGit2(cwd, ["rev-parse", "--git-dir"], true);
 }
-async function getCurrentBranch(cwd) {
+async function getCurrentBranch2(cwd) {
   const name = (await execGit2(cwd, ["rev-parse", "--abbrev-ref", "HEAD"], true)).trim();
   return name;
 }
-async function isWorkingTreeDirty(cwd) {
+async function isWorkingTreeDirty2(cwd) {
   const out = await execGit2(cwd, ["status", "--porcelain"], true);
   return out.trim().length > 0;
 }
@@ -1055,11 +1083,11 @@ async function localBranchExists(cwd, branch) {
   }
 }
 async function commitWorkingTreeIfDirty(cwd, message) {
-  await ensureGitRepo(cwd);
-  if (!await isWorkingTreeDirty(cwd)) {
+  await ensureGitRepo2(cwd);
+  if (!await isWorkingTreeDirty2(cwd)) {
     return false;
   }
-  const commitMessage = message?.trim() || `chore(apm): \u540C\u6B65\u5DE5\u4F5C\u533A (${await getCurrentBranch(cwd)})`;
+  const commitMessage = message?.trim() || `chore(apm): \u540C\u6B65\u5DE5\u4F5C\u533A (${await getCurrentBranch2(cwd)})`;
   await execGit2(cwd, ["add", "-A"]);
   await execGit2(cwd, ["commit", "-m", commitMessage]);
   console.log(`[apm] \u5DF2\u63D0\u4EA4\u5DE5\u4F5C\u533A\u53D8\u66F4: ${commitMessage}`);
@@ -1068,14 +1096,14 @@ async function commitWorkingTreeIfDirty(cwd, message) {
 async function ensureFeatureBranch(branch, baselineBranch, options) {
   const cwd = options.cwd ?? process.cwd();
   const commitMessage = options.message?.trim() || `chore(apm): \u540C\u6B65\u5DE5\u4F5C\u533A (${branch})`;
-  await ensureGitRepo(cwd);
+  await ensureGitRepo2(cwd);
   if (!await remoteHeadBranchExists(cwd, baselineBranch)) {
     throw new Error(
       `[apm] \u8FDC\u7A0B\u4E0D\u5B58\u5728\u57FA\u7EBF\u5206\u652F ${baselineBranch}\uFF0C\u8BF7\u786E\u8BA4\u4ED3\u5E93\u9ED8\u8BA4\u5206\u652F\u5DF2\u63A8\u9001\u5230 origin`
     );
   }
-  const current = await getCurrentBranch(cwd);
-  const dirty = await isWorkingTreeDirty(cwd);
+  const current = await getCurrentBranch2(cwd);
+  const dirty = await isWorkingTreeDirty2(cwd);
   if (dirty) {
     if (current === branch) {
       await commitWorkingTreeIfDirty(cwd, commitMessage);
@@ -1089,7 +1117,7 @@ async function ensureFeatureBranch(branch, baselineBranch, options) {
       ]);
     }
   }
-  const onTargetBranch = await getCurrentBranch(cwd) === branch;
+  const onTargetBranch = await getCurrentBranch2(cwd) === branch;
   if (onTargetBranch) {
     await execGit2(cwd, ["fetch", "origin", baselineBranch]);
     await execGit2(cwd, ["merge", `origin/${baselineBranch}`, "--no-edit"]);
@@ -1099,7 +1127,7 @@ async function ensureFeatureBranch(branch, baselineBranch, options) {
       await execGit2(cwd, ["fetch", "origin", branch]);
       await execGit2(cwd, ["checkout", "-B", branch, `origin/${branch}`]);
     } else if (await localBranchExists(cwd, branch)) {
-      if (await getCurrentBranch(cwd) !== branch) {
+      if (await getCurrentBranch2(cwd) !== branch) {
         await execGit2(cwd, ["checkout", branch]);
       }
       console.log(`[apm] \u5206\u652F ${branch} \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u521B\u5EFA`);
@@ -1115,7 +1143,7 @@ async function ensureFeatureBranch(branch, baselineBranch, options) {
         await execGit2(cwd, ["push", "-u", "origin", branch]);
       } catch (err) {
         if (await localBranchExists(cwd, branch)) {
-          if (await getCurrentBranch(cwd) !== branch) {
+          if (await getCurrentBranch2(cwd) !== branch) {
             await execGit2(cwd, ["checkout", branch]);
           }
           console.log(`[apm] \u5206\u652F ${branch} \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u521B\u5EFA`);
@@ -1178,10 +1206,10 @@ async function execGit3(cwd, args, quiet) {
     );
   }
 }
-async function ensureGitRepo2(cwd) {
+async function ensureGitRepo3(cwd) {
   await execGit3(cwd, ["rev-parse", "--git-dir"], true);
 }
-async function getCurrentBranch2(cwd) {
+async function getCurrentBranch3(cwd) {
   return (await execGit3(cwd, ["rev-parse", "--abbrev-ref", "HEAD"], true)).trim();
 }
 async function resolveBaselineBranch(cwd, api) {
@@ -1197,7 +1225,7 @@ async function resolveBaselineBranch(cwd, api) {
     throw new Error("[apm] \u5E73\u53F0\u8FD4\u56DE\u7684\u57FA\u7EBF\u5206\u652F\u540D\u4E3A\u7A7A");
   }
   await execGit3(cwd, ["fetch", "origin", baselineBranch], true);
-  if (!await remoteBranchExists(cwd, baselineBranch)) {
+  if (!await remoteBranchExists2(cwd, baselineBranch)) {
     throw new Error(
       `[apm] \u8FDC\u7A0B\u4E0D\u5B58\u5728\u57FA\u7EBF\u5206\u652F origin/${baselineBranch}\uFF0C\u8BF7\u786E\u8BA4\u4ED3\u5E93\u9ED8\u8BA4\u5206\u652F\u5DF2\u63A8\u9001\u5230 origin`
     );
@@ -1264,7 +1292,7 @@ async function localBranchExists2(cwd, branch) {
     return false;
   }
 }
-async function remoteBranchExists(cwd, branch) {
+async function remoteBranchExists2(cwd, branch) {
   const out = await execGit3(
     cwd,
     ["ls-remote", "--heads", "origin", branch],
@@ -1298,7 +1326,7 @@ async function runCleanBranches(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const dryRun = options.dryRun ?? false;
   const includeRemote = options.includeRemote ?? false;
-  await ensureGitRepo2(cwd);
+  await ensureGitRepo3(cwd);
   await execGit3(cwd, ["fetch", "--prune", "origin"], true);
   const cfg = await ensureLoggedConfig();
   const api = createApmApiClient(cfg);
@@ -1335,7 +1363,7 @@ async function runCleanBranches(options = {}) {
     console.log("[apm] \u6CA1\u6709\u9700\u8981\u6E05\u7406\u7684 feat/session-* \u5206\u652F");
     return;
   }
-  let currentBranch = await getCurrentBranch2(cwd);
+  let currentBranch = await getCurrentBranch3(cwd);
   for (const item of toDelete) {
     const { branch, sessionId, reason } = item;
     const label = `${branch} (${sessionId}: ${reason})`;
@@ -1357,7 +1385,7 @@ async function runCleanBranches(options = {}) {
       await execGit3(cwd, ["branch", "-D", branch], true);
       console.log(`[apm] \u5DF2\u5220\u9664\u672C\u5730\u5206\u652F ${branch}`);
     }
-    if (await remoteBranchExists(cwd, branch)) {
+    if (await remoteBranchExists2(cwd, branch)) {
       await execGit3(cwd, ["push", "origin", "--delete", branch], true);
       console.log(`[apm] \u5DF2\u5220\u9664\u8FDC\u7A0B\u5206\u652F origin/${branch}`);
     }
@@ -2280,6 +2308,254 @@ function validateAgentWsMessage(value, kind) {
 
 // src/commands/connect/deploy-run.ts
 import { spawn } from "node:child_process";
+
+// 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) {
+    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] \u5DF2\u5F52\u6863\u90E8\u7F72\u4EA7\u7269: ${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;
+  }
+  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/connect/deploy-run.ts
 var DEPLOY_LOG_SYNC_INTERVAL_MS = 3e4;
 function resolveDeployCommand(environment) {
   return `apm deploy ${environment}`;
@@ -2385,6 +2661,8 @@ async function handleInboundDeploy(cfg, msg, signal) {
   console.log(`[apm] deploy command: ${command}`);
   const logSyncer = createDeployLogSyncer(api, deploymentRunId);
   let latestLog = "";
+  const previousDeploymentRunId = process.env[APM_DEPLOYMENT_RUN_ID_ENV];
+  process.env[APM_DEPLOYMENT_RUN_ID_ENV] = deploymentRunId;
   try {
     const { log: log2 } = await runShellCommand(command, workdir, signal, (log3) => {
       latestLog = log3;
@@ -2412,6 +2690,11 @@ async function handleInboundDeploy(cfg, msg, signal) {
     });
     console.error(`[apm] deploy failed id=${deploymentRunId}: ${detail}`);
   } finally {
+    if (previousDeploymentRunId === void 0) {
+      delete process.env[APM_DEPLOYMENT_RUN_ID_ENV];
+    } else {
+      process.env[APM_DEPLOYMENT_RUN_ID_ENV] = previousDeploymentRunId;
+    }
     logSyncer.dispose();
   }
 }
@@ -4067,7 +4350,7 @@ async function runCreatePr(options) {
 
 // src/commands/deploy/deploy-execute.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
-import path4 from "node:path";
+import path5 from "node:path";
 
 // src/commands/deploy/internal/apm-config.ts
 import { existsSync as existsSync15, readFileSync as readFileSync12 } from "node:fs";
@@ -4409,7 +4692,7 @@ var DeployExecutionError = class extends Error {
 
 // src/commands/deploy/internal/wisdom-auto-deploy.ts
 import { existsSync as existsSync17, readFileSync as readFileSync14 } from "node:fs";
-import path3 from "node:path";
+import path4 from "node:path";
 import { spawnSync as spawnSync4 } from "node:child_process";
 
 // src/commands/deploy/internal/wisdom-backend-deploy.ts
@@ -4418,31 +4701,31 @@ import {
   mkdirSync as mkdirSync8,
   readdirSync as readdirSync5,
   readFileSync as readFileSync13,
-  statSync as statSync5,
+  statSync as statSync6,
   writeFileSync as writeFileSync14
 } from "node:fs";
 import { spawnSync as spawnSync3 } from "node:child_process";
-import path2 from "node:path";
-import { Client } from "ssh2";
+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, readFile, unlink, writeFile } from "node:fs/promises";
-import path from "node:path";
+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 readdir(dir, { withFileTypes: true });
+  const entries = await readdir2(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
+    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 readFile(fullPath);
+      const content = await readFile3(fullPath);
       zipFolder.file(entry.name, content);
     }
   }
@@ -4550,8 +4833,8 @@ async function uploadAndMaybeExtract(settings, localZip, extract) {
   }
 }
 async function runWisdomSftpDeploy(params) {
-  const zipPath = path.join(params.localDir, "..", ".deploy-sftp-dist.zip");
-  const resolvedZipPath = path.resolve(zipPath);
+  const zipPath = path2.join(params.localDir, "..", ".deploy-sftp-dist.zip");
+  const resolvedZipPath = path2.resolve(zipPath);
   let zipSizeBytes = 0;
   try {
     zipSizeBytes = await zipDirectory(params.localDir, resolvedZipPath);
@@ -4560,6 +4843,11 @@ async function runWisdomSftpDeploy(params) {
       resolvedZipPath,
       params.extract
     );
+    await uploadDeployArtifactZip({
+      zipPath: resolvedZipPath,
+      projectName: params.projectName,
+      kind: "frontend"
+    });
   } finally {
     try {
       await unlink(resolvedZipPath);
@@ -4594,7 +4882,7 @@ function fail(message) {
 }
 function expandPath(pathStr) {
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return path2.resolve(pathStr.replace(/^~(?=\/|\\|$)/, home));
+  return path3.resolve(pathStr.replace(/^~(?=\/|\\|$)/, home));
 }
 function quoteForShell(value) {
   if (process.platform === "win32") {
@@ -4609,19 +4897,19 @@ function formatMavenLocalRepoArg(repoPath) {
   return `-Dmaven.repo.local=${repoPath}`;
 }
 function deployCacheDir() {
-  return path2.join(workspaceApmDir(), "deploy", ".deploy_cache");
+  return path3.join(workspaceApmDir(), "deploy", ".deploy_cache");
 }
 function manifestFilePath() {
-  return path2.join(deployCacheDir(), "manifest.json");
+  return path3.join(deployCacheDir(), "manifest.json");
 }
 function getTargetDir(projectRoot) {
-  return path2.join(projectRoot, MAVEN_MODULE, "target");
+  return path3.join(projectRoot, MAVEN_MODULE, "target");
 }
 function relativeKey(projectRoot, filePath) {
-  return path2.relative(projectRoot, filePath).split(path2.sep).join("/");
+  return path3.relative(projectRoot, filePath).split(path3.sep).join("/");
 }
 function fileSignature(filePath) {
-  const stat2 = statSync5(filePath);
+  const stat2 = statSync6(filePath);
   return { size: stat2.size, mtime: stat2.mtimeMs / 1e3 };
 }
 function loadManifest4() {
@@ -4643,12 +4931,12 @@ function shouldUploadLibFile(localPath, remoteAttr, manifest, projectRoot) {
   if (!remoteAttr) {
     return [false, "\u8FDC\u7A0B\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7"];
   }
-  const localSize = statSync5(localPath).size;
+  const localSize = statSync6(localPath).size;
   const remoteSize = remoteAttr.size;
   if (localSize !== remoteSize) {
     return [true, `\u5927\u5C0F\u53D8\u5316 ${remoteSize} -> ${localSize}`];
   }
-  if (isProjectLibJar(path2.basename(localPath)) && manifest) {
+  if (isProjectLibJar(path3.basename(localPath)) && manifest) {
     const key = relativeKey(projectRoot, localPath);
     const current = fileSignature(localPath);
     const previous = manifest[key];
@@ -4668,7 +4956,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 = path2.join(localLibDir, jarName);
+    const jarPath = path3.join(localLibDir, jarName);
     const remoteAttr = remoteStats.get(jarName);
     const [shouldUpload, reason] = shouldUploadLibFile(
       jarPath,
@@ -4691,8 +4979,8 @@ function updateManifestEntries(manifest, entries, projectRoot) {
 async function createUpdatePackage(entries, packageName) {
   const dir = deployCacheDir();
   mkdirSync8(dir, { recursive: true });
-  const zipPath = path2.join(dir, packageName);
-  log(`\u521B\u5EFA\u66F4\u65B0\u5305: ${path2.basename(zipPath)}\uFF08${entries.length} \u4E2A\u6587\u4EF6\uFF09`);
+  const zipPath = path3.join(dir, packageName);
+  log(`\u521B\u5EFA\u66F4\u65B0\u5305: ${path3.basename(zipPath)}\uFF08${entries.length} \u4E2A\u6587\u4EF6\uFF09`);
   const zip = new JSZip2();
   for (const entry of entries) {
     const content = readFileSync13(entry.path);
@@ -4756,8 +5044,8 @@ function locateLibDir(projectRoot) {
   if (!existsSync16(targetDir)) {
     fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
   }
-  const libDir = path2.join(targetDir, "lib");
-  if (!existsSync16(libDir) || !statSync5(libDir).isDirectory()) {
+  const libDir = path3.join(targetDir, "lib");
+  if (!existsSync16(libDir) || !statSync6(libDir).isDirectory()) {
     fail(`lib \u76EE\u5F55\u4E0D\u5B58\u5728: ${libDir}`);
   }
   const libJars = readdirSync5(libDir).filter((name) => name.endsWith(".jar"));
@@ -4772,16 +5060,16 @@ function locateMainJar(projectRoot) {
   if (!existsSync16(targetDir)) {
     fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
   }
-  const jarFiles = readdirSync5(targetDir).filter((name) => name.endsWith(".jar") && !name.endsWith(".jar.original")).map((name) => path2.join(targetDir, name)).sort((a, b) => statSync5(b).mtimeMs - statSync5(a).mtimeMs);
+  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);
   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: ${path2.basename(mainJar)}`);
+  log(`\u5B9A\u4F4D\u4E3B JAR \u4EA7\u7269: ${path3.basename(mainJar)}`);
   return mainJar;
 }
 async function connectSsh(config) {
-  const client = new Client();
+  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({
@@ -4826,7 +5114,7 @@ async function getRemoteFileStats(sftp, remoteDir) {
 }
 async function uploadUpdatePackage(sftp, zipPath, config) {
   const remoteDir = config.remoteVueDistDir.replace(/\/$/, "");
-  const remotePath = `${remoteDir}/${path2.basename(zipPath)}`;
+  const remotePath = `${remoteDir}/${path3.basename(zipPath)}`;
   log(`\u4E0A\u4F20\u66F4\u65B0\u5305 -> ${remotePath}`);
   try {
     await sftp.fastPut(zipPath, remotePath);
@@ -4839,7 +5127,7 @@ async function uploadUpdatePackage(sftp, zipPath, config) {
 async function uploadFullJar(sftp, localJarPath, config) {
   const remoteDir = config.remoteAppDir.replace(/\/$/, "");
   const remotePath = `${remoteDir}/${config.startupJar}`;
-  log(`\u4E0A\u4F20\u5168\u91CF JAR (${path2.basename(localJarPath)}) -> ${remotePath}`);
+  log(`\u4E0A\u4F20\u5168\u91CF JAR (${path3.basename(localJarPath)}) -> ${remotePath}`);
   try {
     await sftp.mkdir(remoteDir, true);
     await sftp.fastPut(localJarPath, remotePath);
@@ -5098,10 +5386,10 @@ async function restartRemoteService(client, config) {
   await runRemoteServiceScript(client, script, "restart");
 }
 async function runWisdomBackendDeploy(options) {
-  const projectRoot = path2.resolve(options.projectRoot ?? process.cwd());
+  const projectRoot = path3.resolve(options.projectRoot ?? process.cwd());
   const config = options.config;
   log(`=== \u81EA\u52A8\u90E8\u7F72: ${config.projectName} ===`);
-  log(`\u914D\u7F6E\u6587\u4EF6: ${path2.join(workspaceApmDir(), "apm.config.json")}`);
+  log(`\u914D\u7F6E\u6587\u4EF6: ${path3.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"}`
@@ -5115,6 +5403,21 @@ async function runWisdomBackendDeploy(options) {
     if (config.mode === "full") {
       const mainJar = locateMainJar(projectRoot);
       await uploadFullJar(conn.sftp, mainJar, config);
+      const archiveZipPath = await createUpdatePackage(
+        [
+          {
+            path: mainJar,
+            arcname: path3.basename(mainJar),
+            reason: "\u5168\u91CF JAR \u5F52\u6863"
+          }
+        ],
+        `.deploy-archive-${config.projectName}.jar.zip`
+      );
+      await uploadDeployArtifactZip({
+        zipPath: archiveZipPath,
+        projectName: config.projectName,
+        kind: "backend"
+      });
       log("\u91CD\u542F\u670D\u52A1...");
       await restartRemoteService(conn.client, config);
       await healthCheckService(conn.client, config);
@@ -5145,6 +5448,11 @@ async function runWisdomBackendDeploy(options) {
         zipPath,
         config
       );
+      await uploadDeployArtifactZip({
+        zipPath,
+        projectName: config.projectName,
+        kind: "backend"
+      });
       log("\u8FDC\u7A0B\u89E3\u538B lib \u76EE\u5F55\uFF08\u4EC5\u8986\u76D6\u5DF2\u6709 JAR\uFF09...");
       updated = await extractUpdatePackageOnRemote(
         conn.client,
@@ -5188,10 +5496,10 @@ function isWisdomLegacyDeploy(cfg) {
   return !hasNewFrontend && !hasNewBackend;
 }
 function detectWisdomProjectType(cwd) {
-  return existsSync17(path3.join(cwd, "package.json")) ? "frontend" : "backend";
+  return existsSync17(path4.join(cwd, "package.json")) ? "frontend" : "backend";
 }
 function readPackageScripts(cwd) {
-  const pkgPath = path3.join(cwd, "package.json");
+  const pkgPath = path4.join(cwd, "package.json");
   if (!existsSync17(pkgPath)) {
     return {};
   }
@@ -5236,7 +5544,7 @@ function runShellCommand2(command, cwd, captureOutput) {
   return output;
 }
 async function runWisdomAutoDeploy(options) {
-  const cwd = path3.resolve(options.cwd ?? process.cwd());
+  const cwd = path4.resolve(options.cwd ?? process.cwd());
   const captureOutput = options.captureOutput ?? false;
   const projectType = detectWisdomProjectType(cwd);
   console.error(
@@ -5247,14 +5555,14 @@ async function runWisdomAutoDeploy(options) {
     if (!deployCmd) {
       const lines = formatWisdomFrontendDeployNotConfiguredLines(
         options.env,
-        path3.join(cwd, "package.json")
+        path4.join(cwd, "package.json")
       );
       throw new DeployExecutionError(lines.join("\n"), 1, lines.join("\n"));
     }
     runShellCommand2(deployCmd, cwd, captureOutput);
     return { projectType };
   }
-  const configPath = options.configPath ?? path3.join(workspaceApmDir(cwd), "apm.config.json");
+  const configPath = options.configPath ?? path4.join(workspaceApmDir(cwd), "apm.config.json");
   const cfg = loadApmConfig({ configPath });
   const settings = resolveWisdomBackendDeployFromApmConfig(cfg);
   console.error(
@@ -5267,6 +5575,150 @@ async function runWisdomAutoDeploy(options) {
   return { projectType };
 }
 
+// src/commands/deploy/internal/deploy-baseline-sync.ts
+var LOG_PREFIX = "[apm] \u90E8\u7F72\u524D\u57FA\u7EBF\u540C\u6B65:";
+function formatGitError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function resolveBaselineBranch2(cwd, api) {
+  const workdirPath = resolveWorkdirPath(cwd);
+  const baseline = await api.cli.workspaceBaseline({ workdirPath });
+  if (!baseline.repositoryId) {
+    const detail = baseline.diagnostic?.message ?? `\u672A\u5728\u5E73\u53F0\u627E\u5230\u4E0E\u5F53\u524D\u76EE\u5F55\u5339\u914D\u7684\u5DE5\u4F5C\u76EE\u5F55\u767B\u8BB0\uFF1A${workdirPath}\uFF08\u89C4\u8303\u5316\uFF1A${baseline.workdirPath}\uFF09
+\u8BF7\u5148\u5728\u5E73\u53F0\u767B\u8BB0\u8BE5\u8DEF\u5F84\u5BF9\u5E94\u7684\u5DE5\u4F5C\u76EE\u5F55\u4E0E\u4ED3\u5E93\u3002`;
+    throw new Error(detail);
+  }
+  const baselineBranch = (baseline.defaultBranch ?? "").trim();
+  if (!baselineBranch) {
+    throw new Error("\u5E73\u53F0\u8FD4\u56DE\u7684\u57FA\u7EBF\u5206\u652F\u540D\u4E3A\u7A7A");
+  }
+  return baselineBranch;
+}
+async function isMergeInProgress(cwd) {
+  try {
+    await execGit(cwd, ["rev-parse", "-q", "--verify", "MERGE_HEAD"], true);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function abortMergeIfNeeded(cwd) {
+  if (await isMergeInProgress(cwd)) {
+    await execGit(cwd, ["merge", "--abort"], true);
+  }
+}
+async function restoreWorkingTree(cwd) {
+  await execGit(cwd, ["reset", "--hard", "HEAD"], true);
+}
+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}`);
+  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`);
+    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`);
+    return { merged: false, conflictRollback: true };
+  }
+}
+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`);
+  try {
+    await execGit(cwd, ["stash", "pop"], true);
+    note(`${LOG_PREFIX} \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`);
+    return true;
+  }
+}
+async function syncDeployBaselineBeforeDeploy(cwd) {
+  const lines = [];
+  const note = (message) => {
+    lines.push(message);
+    console.error(message);
+  };
+  const emptyResult = (partial = {}) => ({
+    log: lines.join("\n"),
+    skipped: true,
+    merged: false,
+    conflictRollback: false,
+    stashConflict: false,
+    ...partial
+  });
+  if (!await isGitRepo(cwd)) {
+    note(`${LOG_PREFIX} \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`);
+    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}`);
+  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`);
+  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`);
+    await execGit(cwd, [
+      "stash",
+      "push",
+      "-u",
+      "-m",
+      "apm: deploy baseline sync"
+    ]);
+    stashed = true;
+    note(`${LOG_PREFIX} \u5DF2 stash \u672A\u63D0\u4EA4\u6539\u52A8`);
+  }
+  const { merged, conflictRollback } = await mergeBaselineBranch(
+    cwd,
+    baselineBranch,
+    currentBranch,
+    note
+  );
+  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`);
+  } else if (merged) {
+    note(
+      `${LOG_PREFIX} \u5B8C\u6210\uFF08\u5F53\u524D\u5206\u652F ${currentBranch} \u5DF2\u5305\u542B ${baselineBranch} \u6700\u65B0\u4EE3\u7801\uFF09`
+    );
+  }
+  return {
+    log: lines.join("\n"),
+    skipped: false,
+    merged,
+    conflictRollback,
+    stashConflict
+  };
+}
+
 // src/commands/deploy/deploy-execute.ts
 function runShellCommand3(command, cwd, captureOutput) {
   const result = spawnSync5(command, {
@@ -5293,8 +5745,22 @@ function runShellCommand3(command, cwd, captureOutput) {
   return output;
 }
 async function executeDeploy(options) {
-  const cwd = path4.resolve(options.cwd ?? process.cwd());
+  const cwd = path5.resolve(options.cwd ?? process.cwd());
   const captureOutput = options.captureOutput ?? false;
+  const outputParts = [];
+  try {
+    const syncResult = await syncDeployBaselineBeforeDeploy(cwd);
+    if (syncResult.log.trim()) {
+      outputParts.push(syncResult.log);
+    }
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new DeployExecutionError(
+      `\u90E8\u7F72\u524D\u540C\u6B65\u57FA\u7EBF\u5206\u652F\u5931\u8D25: ${detail}`,
+      1,
+      detail
+    );
+  }
   const cfg = loadApmConfig({ configPath: options.configPath });
   if (isWisdomLegacyDeploy(cfg)) {
     try {
@@ -5304,7 +5770,7 @@ async function executeDeploy(options) {
         configPath: options.configPath,
         captureOutput
       });
-      return "";
+      return outputParts.join("\n");
     } catch (error) {
       if (error instanceof DeployExecutionError) {
         throw error;
@@ -5319,7 +5785,11 @@ async function executeDeploy(options) {
     const lines = formatDeployNotConfiguredLines(options.env, deployCommands);
     throw new DeployExecutionError(lines.join("\n"), 1, lines.join("\n"));
   }
-  return runShellCommand3(command, cwd, captureOutput);
+  const commandOutput = runShellCommand3(command, cwd, captureOutput);
+  if (commandOutput.trim()) {
+    outputParts.push(commandOutput);
+  }
+  return outputParts.join("\n");
 }
 function printDeployExecutionError(error) {
   if (error.output.trim()) {
@@ -5384,6 +5854,8 @@ async function runDeployWithBackendTracking(options) {
     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;
@@ -5430,6 +5902,11 @@ async function runDeployWithBackendTracking(options) {
     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();
@@ -5473,23 +5950,23 @@ function registerDeployMainCommand(program) {
 }
 
 // src/commands/deploy/backend.ts
-import path9 from "node:path";
+import path10 from "node:path";
 
 // src/commands/deploy/internal/backend-deploy/backend-deploy-workflow.ts
-import path8 from "node:path";
+import path9 from "node:path";
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/client.ts
 import Docker from "dockerode";
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/connection-options.ts
 import { existsSync as existsSync18, readFileSync as readFileSync15 } from "node:fs";
-import path5 from "node:path";
+import path6 from "node:path";
 function asOptionalTlsBuffer(value) {
   if (typeof value !== "string") {
     console.log("tls filepath not exist");
     return void 0;
   }
-  console.log("tls filepath", path5.join(process.cwd(), value));
+  console.log("tls filepath", path6.join(process.cwd(), value));
   const normalized = value.trim();
   if (normalized === "") {
     return void 0;
@@ -5705,8 +6182,8 @@ 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 readFileSync16, statSync as statSync6 } from "node:fs";
-import path6 from "node:path";
+import { existsSync as existsSync19, readFileSync as readFileSync16, statSync as statSync7 } from "node:fs";
+import path7 from "node:path";
 function stripSurroundingQuotes(value) {
   const t = value.trim();
   if (t.length >= 2) {
@@ -5721,8 +6198,8 @@ function loadEnvFromFile(envFilePath) {
   if (!envFilePath) {
     return {};
   }
-  const targetPath = path6.resolve(envFilePath);
-  if (!existsSync19(targetPath) || !statSync6(targetPath).isFile()) {
+  const targetPath = path7.resolve(envFilePath);
+  if (!existsSync19(targetPath) || !statSync7(targetPath).isFile()) {
     return {};
   }
   const raw = readFileSync16(targetPath, "utf-8");
@@ -5897,9 +6374,9 @@ function dockerPushImage(params, cwd) {
 
 // src/commands/deploy/internal/backend-deploy/resolve-dockerfile.ts
 import { existsSync as existsSync20 } from "node:fs";
-import path7 from "node:path";
+import path8 from "node:path";
 function resolveDockerBuildPaths(cwd) {
-  const dockerfilePath = path7.join(cwd, "Dockerfile");
+  const dockerfilePath = path8.join(cwd, "Dockerfile");
   Logger.info(`\u67E5\u627EDockerfile\u6587\u4EF6\uFF0C\u8DEF\u5F84: ${dockerfilePath}`);
   if (!existsSync20(dockerfilePath)) {
     throw new Error(`Dockerfile \u4E0D\u5B58\u5728\uFF1A${dockerfilePath}`);
@@ -5956,7 +6433,7 @@ var BackendDeployWorkflow = class {
       serveraddress
     });
     Logger.success("\u8FDC\u7A0B\u62C9\u53D6\u955C\u50CF\u5B8C\u6210");
-    const envFilePath = path8.resolve(cwd, this.params.envFilePath || ".env");
+    const envFilePath = path9.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()}`);
@@ -5996,7 +6473,7 @@ function registerDeployBackendCommands(program) {
       assertDeployImageTag(tag);
       const cfg = loadApmConfig({ configPath: opts.config });
       const fromApm = resolveBackendDeployFromApmConfig(cfg);
-      const dirAbs = path9.resolve(process.cwd(), opts.dir || "servers/api");
+      const dirAbs = path10.resolve(process.cwd(), opts.dir || "servers/api");
       const params = {
         image: fromApm.name,
         tag,
@@ -6028,146 +6505,6 @@ function registerDeployBackendCommands(program) {
 // src/commands/deploy/frontend.ts
 import { copyFile, readdir as readdir3, stat } from "node:fs/promises";
 import path11 from "node:path";
-
-// src/commands/deploy/internal/minio.ts
-import { statSync as statSync7 } from "node:fs";
-import { readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
-import path10 from "node:path";
-import * as Minio from "minio";
-var DEFAULT_MAX_FILE_SIZE_MB = 50;
-async function isDirectoryPath(dir) {
-  try {
-    const st = statSync7(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 readdir2(dir, { withFileTypes: true });
-    for (const e of entries) {
-      const name = e.name;
-      if (name === "." || name === "..") {
-        continue;
-      }
-      const abs = path10.join(dir, name);
-      const rel = prefix ? `${prefix}/${name}` : name;
-      if (e.isDirectory()) {
-        await walk(abs, rel);
-      } else if (e.isFile()) {
-        const st = statSync7(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 readFile2(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 = path10.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/frontend.ts
 function resolveArtifactNamePrefix(cfg) {
   const nameRaw = (cfg.name ?? "").trim();
   if (!nameRaw) {
@@ -6341,6 +6678,13 @@ function registerDeploySftpCommands(program) {
     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}`);
@@ -6350,7 +6694,8 @@ function registerDeploySftpCommands(program) {
         const result = await runWisdomSftpDeploy({
           localDir: root,
           settings,
-          extract: Boolean(opts.extract)
+          extract: Boolean(opts.extract),
+          projectName
         });
         console.log(JSON.stringify(result, null, 2));
       } catch (err) {

package/package.json

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