ai-project-manage-cli 6.0.65 → 6.0.67

package/dist/index.js

@@ -110,8 +110,8 @@ function toFsPath(inputPath) {
   }
   return `\\\\?\\${normalized}`;
 }
-function normalizeWorkdirPath(path10) {
-  let normalized = path10.trim().replace(/\\/g, "/").normalize("NFC");
+function normalizeWorkdirPath(path12) {
+  let normalized = path12.trim().replace(/\\/g, "/").normalize("NFC");
   if (normalized.startsWith("//?/")) {
     normalized = normalized.slice(4);
   }
@@ -326,9 +326,9 @@ function assertTemplateCopiedToApm(apmDir, workdir) {
     "sessions"
   ];
   for (const item of required) {
-    const path10 = join2(apmDir, item);
-    if (!existsSync(toFsPath(path10))) {
-      throw new Error(`[apm] \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path10}`);
+    const path12 = join2(apmDir, item);
+    if (!existsSync(toFsPath(path12))) {
+      throw new Error(`[apm] \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path12}`);
     }
   }
   const leakedRules = join2(workdir, "rules");
@@ -613,14 +613,14 @@ function projectDocumentLocalPath(apmRoot, documentPath) {
   const normalized = normalizeLocalDocumentPath(documentPath);
   return join4(projectDocumentsDir(apmRoot), ...normalized.split("/"));
 }
-function normalizeLocalDocumentPath(path10) {
-  const trimmed = path10.trim().replace(/\\/g, "/");
+function normalizeLocalDocumentPath(path12) {
+  const trimmed = path12.trim().replace(/\\/g, "/");
   if (!trimmed || trimmed.startsWith("/") || /^[a-zA-Z]:/.test(trimmed)) {
-    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path10}`);
+    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path12}`);
   }
   const segments = trimmed.split("/").filter(Boolean);
   if (segments.some((segment) => segment === ".." || segment === ".")) {
-    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path10}`);
+    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path12}`);
   }
   return segments.join("/");
 }
@@ -671,15 +671,15 @@ function diffManifestPaths(remote, local) {
     (local?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
   );
   const download = [];
-  for (const [path10, hash] of remoteMap) {
-    if (localMap.get(path10) !== hash) {
-      download.push(path10);
+  for (const [path12, hash] of remoteMap) {
+    if (localMap.get(path12) !== hash) {
+      download.push(path12);
     }
   }
   const deleteLocal = [];
-  for (const path10 of localMap.keys()) {
-    if (!remoteMap.has(path10)) {
-      deleteLocal.push(path10);
+  for (const path12 of localMap.keys()) {
+    if (!remoteMap.has(path12)) {
+      deleteLocal.push(path12);
     }
   }
   return { download, deleteLocal };
@@ -739,8 +739,8 @@ ${diagnostic ?? ""}`
     }
   }
   let deleted = 0;
-  for (const path10 of deleteLocal) {
-    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path10));
+  for (const path12 of deleteLocal) {
+    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path12));
     if (existsSync2(absPath)) {
       rmSync(absPath, { force: true });
       deleted += 1;
@@ -785,21 +785,21 @@ async function syncRepositoryProjectDocumentsPush(cfg, workdirPath, apmRoot) {
     ])
   );
   let synced = 0;
-  for (const path10 of localPaths) {
-    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path10));
+  for (const path12 of localPaths) {
+    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path12));
     const content = readFileSync3(absPath, "utf8");
     const contentHash = hashLocalFileContent(content);
-    if (remoteHashByPath.get(path10) === contentHash) {
+    if (remoteHashByPath.get(path12) === contentHash) {
       continue;
     }
     await api.cli.upsertRepositoryProjectDocument({
       repositoryId,
-      path: path10,
+      path: path12,
       content,
-      description: remoteDescriptionByPath.get(path10) ?? void 0
+      description: remoteDescriptionByPath.get(path12) ?? void 0
     });
     synced += 1;
-    console.log(`[apm] \u5DF2\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863: ${path10}`);
+    console.log(`[apm] \u5DF2\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863: ${path12}`);
   }
   if (synced === 0) {
     console.log("[apm] \u4ED3\u5E93\u9879\u76EE\u6587\u6863\u65E0\u53D8\u5316\uFF0C\u8DF3\u8FC7\u63A8\u9001");
@@ -1395,13 +1395,13 @@ async function downloadAttachment(cfg, attachmentId) {
   return Buffer.from(await res.arrayBuffer());
 }
 function loadManifest(dir) {
-  const path10 = join6(dir, MANIFEST_FILE2);
-  if (!existsSync4(path10)) {
+  const path12 = join6(dir, MANIFEST_FILE2);
+  if (!existsSync4(path12)) {
     return { version: 1, attachments: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync5(path10, "utf8")
+      readFileSync5(path12, "utf8")
     );
     if (parsed?.version === 1 && parsed.attachments && typeof parsed.attachments === "object") {
       return parsed;
@@ -1482,8 +1482,8 @@ function sanitizeSkillDirName(name) {
 function listBaseSkillDirNames() {
   if (!existsSync5(BASE_SKILLS_TEMPLATE_DIR)) return [];
   return readdirSync3(BASE_SKILLS_TEMPLATE_DIR).filter((name) => {
-    const path10 = join7(BASE_SKILLS_TEMPLATE_DIR, name);
-    return statSync2(path10).isDirectory();
+    const path12 = join7(BASE_SKILLS_TEMPLATE_DIR, name);
+    return statSync2(path12).isDirectory();
   });
 }
 function syncAgentsGuide(apmDir) {
@@ -1495,8 +1495,8 @@ function syncAgentsGuide(apmDir) {
 function listBaseRuleFileNames() {
   if (!existsSync5(BASE_RULES_TEMPLATE_DIR)) return [];
   return readdirSync3(BASE_RULES_TEMPLATE_DIR).filter((name) => {
-    const path10 = join7(BASE_RULES_TEMPLATE_DIR, name);
-    return statSync2(path10).isFile();
+    const path12 = join7(BASE_RULES_TEMPLATE_DIR, name);
+    return statSync2(path12).isFile();
   });
 }
 function syncBaseRules(rulesDir) {
@@ -1559,13 +1559,13 @@ function ruleLocalFileName(ruleName) {
   return `${sanitized}.md`;
 }
 function loadManifest2(rulesDir) {
-  const path10 = join8(rulesDir, MANIFEST_FILE3);
-  if (!existsSync6(toFsPath(path10))) {
+  const path12 = join8(rulesDir, MANIFEST_FILE3);
+  if (!existsSync6(toFsPath(path12))) {
     return { version: 1, rules: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync6(toFsPath(path10), "utf8")
+      readFileSync6(toFsPath(path12), "utf8")
     );
     if (parsed?.version === 1 && parsed.rules && typeof parsed.rules === "object") {
       return parsed;
@@ -2102,7 +2102,7 @@ async function runUpdateMessageStatus(options) {
 }
 
 // src/commands/connect.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 import WebSocket from "ws";
 
 // src/ws/protocol.ts
@@ -2226,19 +2226,918 @@ function validateAgentWsMessage(value, kind) {
 
 // src/commands/connect/deploy-run.ts
 import { spawn } from "node:child_process";
-import { readFileSync as readFileSync9 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync12 } from "node:fs";
 import { join as join13 } from "node:path";
+
+// src/commands/deploy/internal/wisdom-auto-deploy.ts
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "node:fs";
+import path3 from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+
+// src/commands/deploy/internal/apm-config.ts
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
+function loadApmConfig(options) {
+  const p = resolve3(
+    process.cwd(),
+    options?.configPath ?? resolve3(workspaceApmDir(), "apm.config.json")
+  );
+  if (!existsSync11(p)) {
+    console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
+    process.exit(1);
+  }
+  try {
+    const raw = readFileSync9(p, "utf8");
+    return JSON.parse(raw);
+  } catch (e) {
+    console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
+    process.exit(1);
+  }
+}
+function req(v, field) {
+  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
+    console.error(`apm.config.json \u4E2D backendDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+    process.exit(1);
+  }
+  return v;
+}
+function reqTopLevelName(cfg) {
+  const n = (cfg.name ?? "").trim();
+  if (!n) {
+    console.error(
+      "\u8BF7\u5728 apm.config.json \u9876\u5C42\u914D\u7F6E name\uFF08\u4E0E\u524D\u7AEF\u5236\u54C1\u524D\u7F00\u3001\u540E\u7AEF\u955C\u50CF\u540D\u5171\u7528\uFF09"
+    );
+    process.exit(1);
+  }
+  return n;
+}
+function reqBackendPositiveInt(v, field) {
+  const n = Number(v);
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) {
+    console.error(`apm.config.json \u4E2D backendDeploy.${field} \u987B\u4E3A\u6B63\u6574\u6570`);
+    process.exit(1);
+  }
+  return n;
+}
+function resolveBackendDeployFromApmConfig(cfg) {
+  const b = cfg.backendDeploy ?? {};
+  const protoRaw = req(b.remoteProtocol, "remoteProtocol").trim().toLowerCase();
+  if (protoRaw !== "http" && protoRaw !== "https") {
+    console.error(
+      "apm.config.json \u4E2D backendDeploy.remoteProtocol \u53EA\u80FD\u4E3A http \u6216 https"
+    );
+    process.exit(1);
+  }
+  const remoteProtocol = protoRaw;
+  let mappings = [];
+  const rawPorts = b.containerPortsMappings;
+  if (rawPorts !== void 0 && rawPorts !== null) {
+    if (!Array.isArray(rawPorts)) {
+      console.error(
+        "apm.config.json \u4E2D backendDeploy.containerPortsMappings \u987B\u4E3A\u5B57\u7B26\u4E32\u6570\u7EC4\uFF08\u53EF\u4E3A\u7A7A\uFF0C\u7701\u7565\u5219\u4E0D\u52A0\u7AEF\u53E3\u6620\u5C04\uFF09"
+      );
+      process.exit(1);
+    }
+    mappings = rawPorts.map((x) => String(x).trim()).filter(Boolean);
+  }
+  return {
+    name: reqTopLevelName(cfg),
+    registryHost: req(b.registryHost, "registryHost").trim(),
+    registryNamespace: req(b.registryNamespace, "registryNamespace").trim(),
+    registryUser: req(b.registryUser, "registryUser").trim(),
+    registryPassword: req(b.registryPassword, "registryPassword").trim(),
+    remoteHost: req(b.remoteHost, "remoteHost").trim(),
+    remotePort: reqBackendPositiveInt(b.remotePort, "remotePort"),
+    remoteProtocol,
+    caPath: b.caPath?.trim(),
+    certPath: b.certPath?.trim(),
+    keyPath: b.keyPath?.trim(),
+    envFilePath: typeof b.envFilePath === "string" ? b.envFilePath.trim() : "",
+    containerPortsMappings: mappings,
+    dockerNetwork: b.dockerNetwork?.trim() || void 0
+  };
+}
+function reqFe(v, field) {
+  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
+    console.error(`apm.config.json \u4E2D frontendDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+    process.exit(1);
+  }
+  return v;
+}
+function resolveFrontendDeployFromApmConfig(cfg) {
+  const f = cfg.frontendDeploy ?? {};
+  const port = Number(f.port);
+  return {
+    endpoint: reqFe(f.endpoint, "endpoint").trim(),
+    port: Number.isFinite(port) && port > 0 ? port : 9e3,
+    useSsl: Boolean(f.useSsl),
+    accessKey: reqFe(f.accessKey, "accessKey").trim(),
+    secretKey: reqFe(f.secretKey, "secretKey").trim(),
+    bucket: reqFe(f.bucket, "bucket").trim()
+  };
+}
+function reqWd(v, field) {
+  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
+    console.error(`apm.config.json \u4E2D wisdomDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+    process.exit(1);
+  }
+  return v;
+}
+function reqWisdomPositiveInt(v, field) {
+  const n = Number(v);
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) {
+    console.error(`apm.config.json \u4E2D wisdomDeploy.${field} \u987B\u4E3A\u6B63\u6574\u6570`);
+    process.exit(1);
+  }
+  return n;
+}
+function resolveWisdomDeployFromApmConfig(cfg) {
+  const w = cfg.wisdomDeploy ?? {};
+  return {
+    host: reqWd(w.host, "host").trim(),
+    port: reqWisdomPositiveInt(w.port, "port"),
+    username: reqWd(w.username, "username").trim(),
+    password: reqWd(w.password, "password").trim(),
+    remotePath: reqWd(w.remotePath, "remotePath").trim()
+  };
+}
+function reqHc(v, field) {
+  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
+    console.error(`apm.config.json \u4E2D healthCheck.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+    process.exit(1);
+  }
+  return v;
+}
+function reqWb(v, field) {
+  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
+    console.error(`apm.config.json \u4E2D wisdomDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+    process.exit(1);
+  }
+  return v;
+}
+function resolveWisdomBackendDeployFromApmConfig(cfg) {
+  const projectName = reqTopLevelName(cfg);
+  const w = cfg.wisdomDeploy ?? {};
+  const h = cfg.healthCheck ?? {};
+  const jarPath = reqWb(w.jarPath, "jarPath").trim();
+  const remoteAppDir = posixDirname(jarPath);
+  const healthPort = Number(reqHc(h.port, "port"));
+  const healthTimeout = Number(reqHc(h.timeout, "timeout"));
+  if (!Number.isFinite(healthPort) || !Number.isInteger(healthPort) || healthPort < 1) {
+    console.error("apm.config.json \u4E2D healthCheck.port \u987B\u4E3A\u6B63\u6574\u6570");
+    process.exit(1);
+  }
+  if (!Number.isFinite(healthTimeout) || !Number.isInteger(healthTimeout) || healthTimeout < 1) {
+    console.error("apm.config.json \u4E2D healthCheck.timeout \u987B\u4E3A\u6B63\u6574\u6570");
+    process.exit(1);
+  }
+  return {
+    projectName,
+    host: reqWd(w.host, "host").trim(),
+    port: reqWisdomPositiveInt(w.port, "port"),
+    username: reqWd(w.username, "username").trim(),
+    password: reqWd(w.password, "password").trim(),
+    remoteVueDistDir: reqWd(w.remotePath, "remotePath").trim(),
+    remoteAppDir,
+    remoteLibDir: `${remoteAppDir}/lib`,
+    startupJar: posixBasename(jarPath),
+    packageName: `${projectName}.jar.zip`,
+    mavenLocalRepo: reqWb(w.mavenLocalRepo, "mavenLocalRepo").trim(),
+    healthCheckPort: healthPort,
+    healthCheckContext: reqHc(h.context, "context").trim(),
+    healthCheckTimeout: healthTimeout
+  };
+}
+function posixDirname(p) {
+  const normalized = p.replace(/\\/g, "/");
+  const idx = normalized.lastIndexOf("/");
+  if (idx <= 0) {
+    return normalized.startsWith("/") ? "/" : ".";
+  }
+  return normalized.slice(0, idx);
+}
+function posixBasename(p) {
+  const normalized = p.replace(/\\/g, "/");
+  const idx = normalized.lastIndexOf("/");
+  return idx >= 0 ? normalized.slice(idx + 1) : normalized;
+}
+
+// src/commands/deploy/internal/wisdom-backend-deploy.ts
+import {
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync5,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync10,
+  statSync as statSync5,
+  writeFileSync as writeFileSync10
+} from "node:fs";
+import { spawnSync as spawnSync2 } from "node:child_process";
+import path2 from "node:path";
+import { Client } 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 JSZip from "jszip";
+import SftpClient from "ssh2-sftp-client";
+async function addDirToZip(dir, zipFolder) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.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);
+      zipFolder.file(entry.name, content);
+    }
+  }
+}
+async function zipDirectory(distDir, zipPath) {
+  console.error(`\u538B\u7F29\u76EE\u5F55: ${distDir}`);
+  const zip = new JSZip();
+  await addDirToZip(distDir, zip);
+  const content = await zip.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    compressionOptions: { level: 6 }
+  });
+  await writeFile(zipPath, content);
+  const sizeMb = (content.length / 1024 / 1024).toFixed(2);
+  console.error(`\u5DF2\u751F\u6210: ${zipPath} (${sizeMb} MB)`);
+  return content.length;
+}
+async function ensureRemoteDir(sftp, dir) {
+  const parts = dir.replace(/\\/g, "/").split("/").filter(Boolean);
+  let current = dir.startsWith("/") ? "" : ".";
+  for (const part of parts) {
+    current = current ? `${current}/${part}` : `/${part}`;
+    try {
+      await sftp.mkdir(current, true);
+    } catch {
+    }
+  }
+}
+function execCommand(client, command) {
+  return new Promise((resolve5, reject) => {
+    client.exec(command, (err, stream) => {
+      if (err) return reject(err);
+      let stdout = "";
+      let stderr = "";
+      stream.on("close", (code) => {
+        if (code !== 0) {
+          reject(new Error(`\u8FDC\u7A0B\u547D\u4EE4\u5931\u8D25 (${code}): ${stderr || stdout}`));
+          return;
+        }
+        resolve5(stdout);
+      }).on("data", (data) => {
+        stdout += data.toString();
+      });
+      stream.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+    });
+  });
+}
+function shellSingleQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function buildClearRemoteDirExceptZipCommand(target) {
+  const normalized = target.replace(/\\/g, "/").replace(/\/$/, "");
+  const quotedTarget = shellSingleQuote(normalized);
+  const script = [
+    `T=${quotedTarget}`,
+    "S=$(mktemp -d)",
+    'while IFS= read -r -d "" z; do r="${z#${T}/}"',
+    'mkdir -p "${S}/$(dirname "$r")"',
+    'mv "$z" "${S}/${r}"',
+    'done < <(find "$T" -mindepth 1 -type f -iname "*.zip" -print0)',
+    'rm -rf "${T}"/*',
+    'while IFS= read -r -d "" r; do r="${r#./}"',
+    'mkdir -p "${T}/$(dirname "$r")"',
+    'mv "${S}/${r}" "${T}/${r}"',
+    'done < <(cd "$S" 2>/dev/null && find . -type f -print0)',
+    'rm -rf "$S"'
+  ].join("; ");
+  return `bash -c ${shellSingleQuote(script)}`;
+}
+async function uploadAndMaybeExtract(settings, localZip, extract) {
+  const remoteZipPath = `${settings.remotePath.replace(/\/$/, "")}/dist.zip`;
+  console.error(
+    `\u8FDE\u63A5 ${settings.username}@${settings.host}:${settings.port} ...`
+  );
+  const sftp = new SftpClient();
+  try {
+    await sftp.connect({
+      host: settings.host,
+      port: settings.port,
+      username: settings.username,
+      password: settings.password,
+      readyTimeout: 2e4,
+      tryKeyboard: true
+    });
+    await ensureRemoteDir(sftp, settings.remotePath);
+    await sftp.put(localZip, remoteZipPath);
+    console.error(`  \u2713 ${localZip} -> ${remoteZipPath}`);
+    if (extract) {
+      const target = settings.remotePath.replace(/\/$/, "");
+      const client = sftp.client;
+      const clearCmd = buildClearRemoteDirExceptZipCommand(target);
+      console.error(`\u8FDC\u7A0B\u6E05\u7406\u89E3\u538B\u76EE\u5F55: ${clearCmd}`);
+      await execCommand(client, clearCmd);
+      const unzipCmd = `unzip -o "${remoteZipPath}" -d "${target}"`;
+      console.error(`\u8FDC\u7A0B\u89E3\u538B: ${unzipCmd}`);
+      await execCommand(client, unzipCmd);
+      console.error("\u8FDC\u7A0B\u89E3\u538B\u5B8C\u6210!");
+    }
+    console.error(extract ? "\u90E8\u7F72\u5B8C\u6210!" : "\u4E0A\u4F20\u5B8C\u6210!");
+  } finally {
+    await sftp.end();
+  }
+}
+async function runWisdomSftpDeploy(params) {
+  const zipPath = path.join(params.localDir, "..", ".deploy-sftp-dist.zip");
+  const resolvedZipPath = path.resolve(zipPath);
+  let zipSizeBytes = 0;
+  try {
+    zipSizeBytes = await zipDirectory(params.localDir, resolvedZipPath);
+    await uploadAndMaybeExtract(
+      params.settings,
+      resolvedZipPath,
+      params.extract
+    );
+  } finally {
+    try {
+      await unlink(resolvedZipPath);
+      console.error(`\u5DF2\u6E05\u7406\u672C\u5730\u4E34\u65F6\u6587\u4EF6: ${resolvedZipPath}`);
+    } catch {
+    }
+  }
+  return {
+    ok: true,
+    localDir: params.localDir,
+    host: params.settings.host,
+    remotePath: params.settings.remotePath,
+    zipSizeBytes,
+    extracted: params.extract
+  };
+}
+
+// src/commands/deploy/internal/wisdom-backend-deploy.ts
+var SPRINGBOOT_SCRIPT = "springboot.sh";
+var MAVEN_MODULE = "jeecg-module-system/jeecg-system-start";
+var MAVEN_PROFILE = "dev";
+function log(message) {
+  const now = /* @__PURE__ */ new Date();
+  const hh = String(now.getHours()).padStart(2, "0");
+  const mm = String(now.getMinutes()).padStart(2, "0");
+  const ss = String(now.getSeconds()).padStart(2, "0");
+  console.error(`[${hh}:${mm}:${ss}] ${message}`);
+}
+function fail(message) {
+  log(`ERROR: ${message}`);
+  process.exit(1);
+}
+function expandPath(pathStr) {
+  return path2.resolve(pathStr.replace(/^~(?=\/|$)/, process.env.HOME ?? ""));
+}
+function deployCacheDir() {
+  return path2.join(workspaceApmDir(), "deploy", ".deploy_cache");
+}
+function manifestFilePath() {
+  return path2.join(deployCacheDir(), "manifest.json");
+}
+function getTargetDir(projectRoot) {
+  return path2.join(projectRoot, MAVEN_MODULE, "target");
+}
+function relativeKey(projectRoot, filePath) {
+  return path2.relative(projectRoot, filePath).split(path2.sep).join("/");
+}
+function fileSignature(filePath) {
+  const stat2 = statSync5(filePath);
+  return { size: stat2.size, mtime: stat2.mtimeMs / 1e3 };
+}
+function loadManifest3() {
+  const manifestPath2 = manifestFilePath();
+  if (!existsSync12(manifestPath2)) {
+    return {};
+  }
+  return JSON.parse(readFileSync10(manifestPath2, "utf8"));
+}
+function saveManifest3(manifest) {
+  const dir = deployCacheDir();
+  mkdirSync5(dir, { recursive: true });
+  writeFileSync10(manifestFilePath(), JSON.stringify(manifest, null, 2), "utf8");
+}
+function isProjectLibJar(jarName) {
+  return jarName.startsWith("jeecg-");
+}
+function shouldUploadLibFile(localPath, remoteAttr, manifest, projectRoot) {
+  if (!remoteAttr) {
+    return [false, "\u8FDC\u7A0B\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7"];
+  }
+  const localSize = statSync5(localPath).size;
+  const remoteSize = remoteAttr.size;
+  if (localSize !== remoteSize) {
+    return [true, `\u5927\u5C0F\u53D8\u5316 ${remoteSize} -> ${localSize}`];
+  }
+  if (isProjectLibJar(path2.basename(localPath)) && manifest) {
+    const key = relativeKey(projectRoot, localPath);
+    const current = fileSignature(localPath);
+    const previous = manifest[key];
+    if (!previous) {
+      return [true, "\u9879\u76EE\u6A21\u5757\u672A\u8BB0\u5F55"];
+    }
+    if (previous.size !== current.size) {
+      return [true, "\u9879\u76EE\u6A21\u5757\u5927\u5C0F\u53D8\u5316"];
+    }
+    if (previous.mtime < current.mtime) {
+      return [true, "\u9879\u76EE\u6A21\u5757\u91CD\u65B0\u6784\u5EFA"];
+    }
+  }
+  return [false, "\u5927\u5C0F\u4E00\u81F4\uFF0C\u8DF3\u8FC7"];
+}
+function listLibFilesToUpload(localLibDir, remoteStats, projectRoot, manifest = null) {
+  const entries = [];
+  const jarFiles = readdirSync5(localLibDir).filter((name) => name.endsWith(".jar")).sort();
+  for (const jarName of jarFiles) {
+    const jarPath = path2.join(localLibDir, jarName);
+    const remoteAttr = remoteStats.get(jarName);
+    const [shouldUpload, reason] = shouldUploadLibFile(
+      jarPath,
+      remoteAttr,
+      manifest,
+      projectRoot
+    );
+    if (shouldUpload) {
+      entries.push({ path: jarPath, arcname: jarName, reason });
+    }
+  }
+  return entries;
+}
+function updateManifestEntries(manifest, entries, projectRoot) {
+  for (const entry of entries) {
+    manifest[relativeKey(projectRoot, entry.path)] = fileSignature(entry.path);
+  }
+  return manifest;
+}
+async function createUpdatePackage(entries, packageName) {
+  const dir = deployCacheDir();
+  mkdirSync5(dir, { recursive: true });
+  const zipPath = path2.join(dir, packageName);
+  log(`\u521B\u5EFA\u66F4\u65B0\u5305: ${path2.basename(zipPath)}\uFF08${entries.length} \u4E2A\u6587\u4EF6\uFF09`);
+  const zip = new JSZip2();
+  for (const entry of entries) {
+    const content = readFileSync10(entry.path);
+    zip.file(entry.arcname, content);
+    log(`  \u6253\u5305: ${entry.arcname} (${entry.reason})`);
+  }
+  const buffer = await zip.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    compressionOptions: { level: 6 }
+  });
+  writeFileSync10(zipPath, buffer);
+  return zipPath;
+}
+function getMvnExecutable() {
+  const isWin = process.platform === "win32";
+  const candidates = isWin ? ["mvn.cmd", "mvn.bat", "mvn"] : ["mvn"];
+  for (const name of candidates) {
+    const result = spawnSync2(isWin ? "where" : "which", [name], {
+      encoding: "utf8"
+    });
+    if (result.status === 0 && result.stdout.trim()) {
+      return result.stdout.trim().split(/\r?\n/)[0];
+    }
+  }
+  fail("\u672A\u627E\u5230 mvn \u547D\u4EE4\uFF0C\u8BF7\u786E\u8BA4 Maven \u5DF2\u5B89\u88C5\u5E76\u52A0\u5165 PATH");
+}
+function runMavenBuild(projectRoot, mavenLocalRepo) {
+  const mavenRepo = expandPath(mavenLocalRepo);
+  const cmd = [
+    getMvnExecutable(),
+    "clean",
+    "package",
+    `-P${MAVEN_PROFILE}`,
+    `-Dmaven.repo.local=${mavenRepo}`,
+    "-DskipTests"
+  ];
+  log(`\u5F00\u59CB Maven \u6784\u5EFA: ${cmd.join(" ")}`);
+  log(`Maven \u672C\u5730\u4ED3\u5E93: ${mavenRepo}`);
+  const result = spawnSync2(cmd[0], cmd.slice(1), {
+    cwd: projectRoot,
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    fail(`Maven \u6784\u5EFA\u5931\u8D25\uFF0C\u9000\u51FA\u7801: ${result.status ?? 1}`);
+  }
+}
+function locateLibDir(projectRoot) {
+  const targetDir = getTargetDir(projectRoot);
+  if (!existsSync12(targetDir)) {
+    fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
+  }
+  const libDir = path2.join(targetDir, "lib");
+  if (!existsSync12(libDir) || !statSync5(libDir).isDirectory()) {
+    fail(`lib \u76EE\u5F55\u4E0D\u5B58\u5728: ${libDir}`);
+  }
+  const libJars = readdirSync5(libDir).filter((name) => name.endsWith(".jar"));
+  if (libJars.length === 0) {
+    fail(`lib \u76EE\u5F55\u4E0B\u6CA1\u6709\u4F9D\u8D56 JAR: ${libDir}`);
+  }
+  log(`\u5B9A\u4F4D lib \u4EA7\u7269: ${libJars.length} \u4E2A`);
+  return libDir;
+}
+async function connectSsh(config) {
+  const client = new Client();
+  log(`\u8FDE\u63A5\u670D\u52A1\u5668 ${config.username}@${config.host}:${config.port}`);
+  await new Promise((resolve5, reject) => {
+    client.on("ready", () => resolve5()).on("error", (err) => reject(err)).connect({
+      host: config.host,
+      port: config.port,
+      username: config.username,
+      password: config.password,
+      readyTimeout: 3e4,
+      tryKeyboard: true
+    });
+  });
+  const sftp = new SftpClient2();
+  await sftp.connect({
+    host: config.host,
+    port: config.port,
+    username: config.username,
+    password: config.password,
+    readyTimeout: 3e4,
+    tryKeyboard: true
+  });
+  return { client, sftp };
+}
+async function closeSsh(conn) {
+  try {
+    await conn.sftp.end();
+  } catch {
+  }
+  conn.client.end();
+}
+async function getRemoteFileStats(sftp, remoteDir) {
+  const stats = /* @__PURE__ */ new Map();
+  try {
+    const listing = await sftp.list(remoteDir);
+    for (const item of listing) {
+      if (item.name.endsWith(".jar")) {
+        stats.set(item.name, { filename: item.name, size: item.size });
+      }
+    }
+  } catch {
+  }
+  return stats;
+}
+async function uploadUpdatePackage(sftp, zipPath, config) {
+  const remoteDir = config.remoteVueDistDir.replace(/\/$/, "");
+  const remotePath = `${remoteDir}/${path2.basename(zipPath)}`;
+  log(`\u4E0A\u4F20\u66F4\u65B0\u5305 -> ${remotePath}`);
+  try {
+    await sftp.fastPut(zipPath, remotePath);
+    log("\u66F4\u65B0\u5305\u4E0A\u4F20\u6210\u529F");
+  } catch (err) {
+    fail(`\u66F4\u65B0\u5305\u4E0A\u4F20\u5931\u8D25: ${err instanceof Error ? err.message : err}`);
+  }
+  return remotePath;
+}
+async function runRemoteCommand(client, command, options) {
+  const check = options?.check ?? true;
+  const stream = options?.stream ?? false;
+  log(`\u8FDC\u7A0B\u6267\u884C: ${command}`);
+  return new Promise((resolve5, reject) => {
+    client.exec(command, (err, execStream) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      let out = "";
+      let errText = "";
+      execStream.on("data", (data) => {
+        const text = data.toString();
+        out += text;
+        if (stream) {
+          process.stdout.write(text);
+        }
+      });
+      execStream.stderr.on("data", (data) => {
+        errText += data.toString();
+      });
+      execStream.on("close", (code) => {
+        if (!stream) {
+          if (out) {
+            console.log(out.trimEnd());
+          }
+          if (errText) {
+            console.error(errText.trimEnd());
+          }
+        } else if (out && !out.endsWith("\n")) {
+          process.stdout.write("\n");
+        }
+        if (check && code !== 0) {
+          fail(`\u8FDC\u7A0B\u547D\u4EE4\u5931\u8D25 (exit ${code}): ${command}`);
+        }
+        resolve5({ exitCode: code, out: out.trim(), err: errText.trim() });
+      });
+    });
+  });
+}
+function buildExtractUpdatePackageScript(remoteZipPath, remoteLibDir) {
+  const quotedZip = shellSingleQuote(remoteZipPath);
+  const quotedLib = shellSingleQuote(remoteLibDir);
+  return `
+set -e
+TMP=$(mktemp -d)
+trap 'rm -rf "$TMP"' EXIT
+unzip -oq ${quotedZip} -d "$TMP"
+updated=0
+while IFS= read -r -d '' src; do
+  name=$(basename "$src")
+  dest=${quotedLib}/"$name"
+  if [ -f "$dest" ]; then
+    cp -f "$src" "$dest"
+    echo "\u8986\u76D6: $name"
+    updated=$((updated + 1))
+  else
+    echo "\u8DF3\u8FC7(\u8FDC\u7A0B\u4E0D\u5B58\u5728): $name"
+  fi
+done < <(find "$TMP" -name '*.jar' -type f -print0)
+echo "UPDATED_COUNT=$updated"
+`.trim();
+}
+async function extractUpdatePackageOnRemote(client, config, remoteZipPath) {
+  const script = buildExtractUpdatePackageScript(
+    remoteZipPath,
+    config.remoteLibDir
+  );
+  const { out } = await runRemoteCommand(client, script);
+  const match = out.match(/UPDATED_COUNT=(\d+)/);
+  if (!match) {
+    fail(`\u8FDC\u7A0B\u89E3\u538B\u5931\u8D25\uFF0C\u672A\u83B7\u53D6\u66F4\u65B0\u6570\u91CF
+\u8F93\u51FA: ${out || "(\u7A7A)"}`);
+  }
+  const updated = Number.parseInt(match[1], 10);
+  log(`lib \u89E3\u538B\u5B8C\u6210: \u8986\u76D6 ${updated} \u4E2A`);
+  return updated;
+}
+function springbootOutputIndicatesSuccess(action, combined) {
+  const lower = combined.toLowerCase();
+  if (action === "health") {
+    return combined.includes("\u5065\u5EB7\u68C0\u67E5\u901A\u8FC7");
+  }
+  if (action === "start" || action === "restart") {
+    return combined.includes("is starting") || lower.includes("is running");
+  }
+  if (action === "stop") {
+    return combined.includes("is stopping") || lower.includes("not running") || lower.includes("please check it");
+  }
+  if (action === "status") {
+    return lower.includes("running") || lower.includes("not running");
+  }
+  return true;
+}
+async function runSpringbootAction(client, config, action, ...args) {
+  if (action === "start" || action === "restart") {
+    if (args.length === 0) {
+      fail(`\u8FDC\u7A0B ${action} \u7F3A\u5C11 jar \u53C2\u6570`);
+    }
+    const jar = args[0].trim().split(/\r?\n/)[0].trim();
+    if (!jar) {
+      fail(`\u65E0\u6548\u7684 jar \u540D\u79F0: ${JSON.stringify(args[0])}`);
+    }
+  }
+  const quotedArgs = [action, ...args].map((arg) => shellSingleQuote(arg));
+  const command = [
+    `cd ${shellSingleQuote(config.remoteAppDir)}`,
+    `./${SPRINGBOOT_SCRIPT} ${quotedArgs.join(" ")}`
+  ].join(" && ");
+  const { exitCode, out, err } = await runRemoteCommand(client, command, {
+    check: false
+  });
+  const combined = `${out}
+${err}`.trim();
+  const outputOk = springbootOutputIndicatesSuccess(action, combined);
+  if (action === "health") {
+    if (exitCode !== 0 || !outputOk) {
+      fail(`\u5065\u5EB7\u68C0\u67E5\u5931\u8D25
+\u547D\u4EE4: ${command}
+\u8F93\u51FA: ${combined || "(\u7A7A)"}`);
+    }
+    return combined;
+  }
+  if (exitCode !== 0 && !outputOk) {
+    fail(`\u8FDC\u7A0B ${action} \u5931\u8D25: ${args.join(" ")}
+${combined}`);
+  }
+  if ((action === "start" || action === "restart") && !outputOk) {
+    fail(
+      `\u8FDC\u7A0B ${action} \u672A\u6210\u529F: ${args.join(" ")}
+\u547D\u4EE4: ${command}
+\u8F93\u51FA: ${combined || "(\u7A7A)"}`
+    );
+  }
+  return combined;
+}
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "");
+}
+async function getRunningJar(client, config) {
+  const combined = await runSpringbootAction(
+    client,
+    config,
+    "status",
+    config.startupJar
+  );
+  const text = stripAnsi(combined).trim().toLowerCase();
+  if (text.includes("not running")) {
+    return null;
+  }
+  if (text.includes("running")) {
+    return config.startupJar;
+  }
+  return null;
+}
+async function healthCheckService(client, config) {
+  const port = String(config.healthCheckPort);
+  const context = config.healthCheckContext;
+  const timeout = String(config.healthCheckTimeout);
+  log(`\u5065\u5EB7\u68C0\u67E5: springboot.sh health ${port} ${context} ${timeout}`);
+  await runSpringbootAction(client, config, "health", port, context, timeout);
+}
+async function runWisdomBackendDeploy(options) {
+  const projectRoot = path2.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(`\u9879\u76EE\u6839\u76EE\u5F55: ${projectRoot}`);
+  if (!options.skipMaven) {
+    runMavenBuild(projectRoot, config.mavenLocalRepo);
+  }
+  const libDir = locateLibDir(projectRoot);
+  let manifest = loadManifest3();
+  const conn = await connectSsh(config);
+  try {
+    const remoteLibStats = await getRemoteFileStats(
+      conn.sftp,
+      config.remoteLibDir
+    );
+    log("\u6536\u96C6 JAR \u66F4\u65B0...");
+    const libUploadEntries = listLibFilesToUpload(
+      libDir,
+      remoteLibStats,
+      projectRoot,
+      manifest
+    );
+    let updated = 0;
+    if (libUploadEntries.length > 0) {
+      const zipPath = await createUpdatePackage(
+        libUploadEntries,
+        config.packageName
+      );
+      const remoteZipPath = await uploadUpdatePackage(
+        conn.sftp,
+        zipPath,
+        config
+      );
+      log("\u8FDC\u7A0B\u89E3\u538B lib \u76EE\u5F55\uFF08\u4EC5\u8986\u76D6\u5DF2\u6709 JAR\uFF09...");
+      updated = await extractUpdatePackageOnRemote(
+        conn.client,
+        config,
+        remoteZipPath
+      );
+    } else {
+      log("\u65E0 JAR \u9700\u8981\u66F4\u65B0\uFF0C\u8DF3\u8FC7\u66F4\u65B0\u5305\u4E0A\u4F20");
+    }
+    const runningJar = await getRunningJar(conn.client, config);
+    let needRestart = updated > 0;
+    if (!needRestart && !runningJar) {
+      log("\u670D\u52A1\u672A\u8FD0\u884C\uFF0C\u9700\u8981\u542F\u52A8");
+      needRestart = true;
+    } else if (!needRestart) {
+      log("\u6CA1\u6709\u6587\u4EF6\u9700\u8981\u66F4\u65B0\uFF0C\u8DF3\u8FC7\u91CD\u542F");
+    }
+    if (needRestart) {
+      log("\u91CD\u542F\u670D\u52A1...");
+      await runSpringbootAction(
+        conn.client,
+        config,
+        "restart",
+        config.startupJar
+      );
+    }
+    await healthCheckService(conn.client, config);
+    if (libUploadEntries.length > 0) {
+      manifest = updateManifestEntries(manifest, libUploadEntries, projectRoot);
+      saveManifest3(manifest);
+    }
+  } finally {
+    await closeSsh(conn);
+  }
+  log("\u90E8\u7F72\u5B8C\u6210");
+}
+
+// src/commands/deploy/internal/wisdom-auto-deploy.ts
+function isWisdomLegacyDeploy(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;
+}
+function detectWisdomProjectType(cwd) {
+  return existsSync13(path3.join(cwd, "package.json")) ? "frontend" : "backend";
+}
+function readPackageScripts(cwd) {
+  const pkgPath = path3.join(cwd, "package.json");
+  if (!existsSync13(pkgPath)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync11(pkgPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.scripts ?? {};
+  } catch {
+    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 runShellCommand(command, cwd) {
+  console.error(`==> ${command}`);
+  const result = spawnSync3(command, {
+    cwd,
+    stdio: "inherit",
+    shell: true,
+    env: process.env
+  });
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+}
+async function runWisdomAutoDeploy(options) {
+  const cwd = path3.resolve(options.cwd ?? process.cwd());
+  const projectType = detectWisdomProjectType(cwd);
+  console.error(
+    `[apm] \u533B\u52A1\u5B58\u91CF\u9879\u76EE\u81EA\u52A8\u8BC6\u522B: ${projectType === "frontend" ? "\u524D\u7AEF Vue" : "\u540E\u7AEF Java"}`
+  );
+  if (projectType === "frontend") {
+    const deployCmd = resolveFrontendDeployCommand(options.env, cwd);
+    if (!deployCmd) {
+      console.error(
+        `\u524D\u7AEF\u9879\u76EE ${path3.join(cwd, "package.json")} \u4E2D\u672A\u627E\u5230 deploy:${options.env} \u811A\u672C`
+      );
+      process.exit(1);
+    }
+    runShellCommand(deployCmd, cwd);
+    return { projectType };
+  }
+  const configPath = options.configPath ?? path3.join(workspaceApmDir(cwd), "apm.config.json");
+  const cfg = loadApmConfig({ configPath });
+  const settings = resolveWisdomBackendDeployFromApmConfig(cfg);
+  console.error(
+    `[apm] \u540E\u7AEF\u90E8\u7F72\u4E0D\u533A\u5206 test/online\uFF0C\u5FFD\u7565\u73AF\u5883\u53C2\u6570: ${options.env}`
+  );
+  await runWisdomBackendDeploy({
+    config: settings,
+    projectRoot: cwd,
+    skipMaven: Boolean(options.skipMaven)
+  });
+  return { projectType };
+}
+
+// src/commands/connect/deploy-run.ts
 var DEPLOY_LOG_SYNC_INTERVAL_MS = 3e4;
-function readDeployConfig(workdir) {
+function readApmConfig(workdir) {
   const configPath = join13(workspaceApmDir(workdir), "apm.config.json");
+  if (!existsSync14(configPath)) {
+    return void 0;
+  }
   try {
-    const raw = readFileSync9(configPath, "utf8");
-    const parsed = JSON.parse(raw);
-    return parsed.deploy;
+    const raw = readFileSync12(configPath, "utf8");
+    return JSON.parse(raw);
   } catch {
     return void 0;
   }
 }
+function readDeployConfig(workdir) {
+  return readApmConfig(workdir)?.deploy;
+}
 function resolveDeployCommand(workdir, environment) {
   const command = readDeployConfig(workdir)?.[environment];
   if (typeof command === "string" && command.trim()) {
@@ -2252,7 +3151,7 @@ function missingDeployCommandMessage(environment) {
 function buildDeployLog(stdout, stderr) {
   return [stdout, stderr].filter(Boolean).join("\n");
 }
-function runShellCommand(command, cwd, signal, onOutput) {
+function runShellCommand2(command, cwd, signal, onOutput) {
   return new Promise((resolve5, reject) => {
     const child = spawn(command, {
       cwd,
@@ -2287,15 +3186,15 @@ function runShellCommand(command, cwd, signal, onOutput) {
     });
     child.on("close", (code) => {
       signal.removeEventListener("abort", onAbort);
-      const log = buildDeployLog(stdout, stderr);
+      const log2 = buildDeployLog(stdout, stderr);
       if (code === 0) {
-        resolve5({ log });
+        resolve5({ log: log2 });
         return;
       }
       const error = new Error(
         `\u90E8\u7F72\u547D\u4EE4\u9000\u51FA\u7801 ${code ?? "unknown"}: ${command}`
       );
-      error.log = log;
+      error.log = log2;
       reject(error);
     });
   });
@@ -2322,8 +3221,8 @@ function createDeployLogSyncer(api, deploymentRunId) {
     });
   }, DEPLOY_LOG_SYNC_INTERVAL_MS);
   return {
-    updateLog(log) {
-      latestLog = log;
+    updateLog(log2) {
+      latestLog = log2;
     },
     async flush() {
       clearInterval(timer);
@@ -2343,6 +3242,39 @@ async function handleInboundDeploy(cfg, msg, signal) {
     status: "DEPLOYING"
   });
   const workdir = requireRemoteWorkdir(msg.workdir);
+  const apmConfig = readApmConfig(workdir);
+  if (apmConfig && isWisdomLegacyDeploy(apmConfig)) {
+    console.log(
+      `[apm] deploy start id=${deploymentRunId} env=${msg.environment} cwd=${workdir} (wisdom auto)`
+    );
+    const logSyncer2 = createDeployLogSyncer(api, deploymentRunId);
+    try {
+      await runWisdomAutoDeploy({
+        env: msg.environment,
+        cwd: workdir
+      });
+      await logSyncer2.flush();
+      await api.cli.completeTaskDeployment({
+        id: deploymentRunId,
+        status: "SUCCESS",
+        log: "\u533B\u52A1\u5B58\u91CF\u9879\u76EE\u81EA\u52A8\u90E8\u7F72\u5B8C\u6210"
+      });
+      console.log(`[apm] deploy success id=${deploymentRunId}`);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      await logSyncer2.flush();
+      await api.cli.completeTaskDeployment({
+        id: deploymentRunId,
+        status: "FAILED",
+        log: detail,
+        error: detail
+      });
+      console.error(`[apm] deploy failed id=${deploymentRunId}: ${detail}`);
+    } finally {
+      logSyncer2.dispose();
+    }
+    return;
+  }
   const command = resolveDeployCommand(workdir, msg.environment);
   if (!command) {
     const error = missingDeployCommandMessage(msg.environment);
@@ -2362,28 +3294,28 @@ async function handleInboundDeploy(cfg, msg, signal) {
   const logSyncer = createDeployLogSyncer(api, deploymentRunId);
   let latestLog = "";
   try {
-    const { log } = await runShellCommand(command, workdir, signal, (log2) => {
-      latestLog = log2;
-      logSyncer.updateLog(log2);
+    const { log: log2 } = await runShellCommand2(command, workdir, signal, (log3) => {
+      latestLog = log3;
+      logSyncer.updateLog(log3);
     });
-    latestLog = log;
-    logSyncer.updateLog(log);
+    latestLog = log2;
+    logSyncer.updateLog(log2);
     await logSyncer.flush();
     await api.cli.completeTaskDeployment({
       id: deploymentRunId,
       status: "SUCCESS",
-      log
+      log: log2
     });
     console.log(`[apm] deploy success id=${deploymentRunId}`);
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
-    const log = error && typeof error === "object" && "log" in error ? String(error.log ?? latestLog) : latestLog;
-    logSyncer.updateLog(log);
+    const log2 = error && typeof error === "object" && "log" in error ? String(error.log ?? latestLog) : latestLog;
+    logSyncer.updateLog(log2);
     await logSyncer.flush();
     await api.cli.completeTaskDeployment({
       id: deploymentRunId,
       status: "FAILED",
-      log,
+      log: log2,
       error: detail
     });
     console.error(`[apm] deploy failed id=${deploymentRunId}: ${detail}`);
@@ -2659,17 +3591,17 @@ ${JSON.stringify(event, null, 2)}
 }
 
 // src/commands/connect/agent-session-registry.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname4, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync6, readFileSync as readFileSync13, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname4, resolve as resolve4 } from "node:path";
 function registryPath(workdir, sessionId) {
-  return resolve3(workdir, ".apm", "sessions", sessionId, "cursor-agents.json");
+  return resolve4(workdir, ".apm", "sessions", sessionId, "cursor-agents.json");
 }
-function readRegistry(path10) {
-  if (!existsSync11(path10)) {
+function readRegistry(path12) {
+  if (!existsSync15(path12)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync10(path10, "utf8"));
+    const parsed = JSON.parse(readFileSync13(path12, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const result = {};
       for (const [key, value] of Object.entries(
@@ -2685,9 +3617,9 @@ function readRegistry(path10) {
   }
   return {};
 }
-function writeRegistry(path10, registry) {
-  mkdirSync5(dirname4(path10), { recursive: true });
-  writeFileSync10(path10, `${JSON.stringify(registry, null, 2)}
+function writeRegistry(path12, registry) {
+  mkdirSync6(dirname4(path12), { recursive: true });
+  writeFileSync11(path12, `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 function loadSessionAgentId(workdir, sessionId, user) {
@@ -2695,19 +3627,19 @@ function loadSessionAgentId(workdir, sessionId, user) {
   return registry[user];
 }
 function saveSessionAgentId(workdir, sessionId, user, agentId) {
-  const path10 = registryPath(workdir, sessionId);
-  const registry = readRegistry(path10);
+  const path12 = registryPath(workdir, sessionId);
+  const registry = readRegistry(path12);
   registry[user] = agentId;
-  writeRegistry(path10, registry);
+  writeRegistry(path12, registry);
 }
 function clearSessionAgentId(workdir, sessionId, user) {
-  const path10 = registryPath(workdir, sessionId);
-  const registry = readRegistry(path10);
+  const path12 = registryPath(workdir, sessionId);
+  const registry = readRegistry(path12);
   if (!(user in registry)) {
     return;
   }
   delete registry[user];
-  writeRegistry(path10, registry);
+  writeRegistry(path12, registry);
 }
 
 // src/commands/connect/cursor-message-log.ts
@@ -3101,20 +4033,20 @@ async function runCursorAgent(cfg, ctx, options) {
 }
 
 // src/commands/connect/cli-version-sync.ts
-import { existsSync as existsSync12, readFileSync as readFileSync11, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "fs";
 import { join as join14 } from "path";
 var CLI_VERSION_FILE = ".cli-version.json";
 function manifestPath(apmDir) {
   return join14(apmDir, CLI_VERSION_FILE);
 }
-function loadManifest3(apmDir) {
-  const path10 = toFsPath(manifestPath(apmDir));
-  if (!existsSync12(path10)) {
+function loadManifest4(apmDir) {
+  const path12 = toFsPath(manifestPath(apmDir));
+  if (!existsSync16(path12)) {
     return null;
   }
   try {
     const parsed = JSON.parse(
-      readFileSync11(path10, "utf8")
+      readFileSync14(path12, "utf8")
     );
     if (parsed?.version === 1 && typeof parsed.cliVersion === "string" && parsed.cliVersion.trim()) {
       return parsed;
@@ -3123,9 +4055,9 @@ function loadManifest3(apmDir) {
   }
   return null;
 }
-function saveManifest3(apmDir, cliVersion) {
+function saveManifest4(apmDir, cliVersion) {
   const manifest = { version: 1, cliVersion };
-  writeFileSync11(
+  writeFileSync12(
     toFsPath(manifestPath(apmDir)),
     `${JSON.stringify(manifest, null, 2)}
 `,
@@ -3138,7 +4070,7 @@ function shouldSyncSkillsForCliVersion(workdir, currentVersion) {
   if (cached === currentVersion) {
     return false;
   }
-  const stored = loadManifest3(workspaceApmDir(workdir));
+  const stored = loadManifest4(workspaceApmDir(workdir));
   if (stored?.cliVersion === currentVersion) {
     syncedInSession.set(workdir, currentVersion);
     return false;
@@ -3146,7 +4078,7 @@ function shouldSyncSkillsForCliVersion(workdir, currentVersion) {
   return true;
 }
 function markSkillsSyncedForCliVersion(workdir, cliVersion) {
-  saveManifest3(workspaceApmDir(workdir), cliVersion);
+  saveManifest4(workspaceApmDir(workdir), cliVersion);
   syncedInSession.set(workdir, cliVersion);
 }
 
@@ -3373,7 +4305,7 @@ function reexecConnect(options) {
   if (server) {
     args.push("--server", server);
   }
-  const result = spawnSync2(process.execPath, args, { stdio: "inherit" });
+  const result = spawnSync4(process.execPath, args, { stdio: "inherit" });
   if (result.error) {
     console.error("[apm] \u91CD\u542F connect \u5931\u8D25:", result.error.message);
     process.exit(1);
@@ -3509,202 +4441,123 @@ async function runConnect(options) {
         activeTasks.delete(task);
       });
     });
-    ws.on("close", (code, reason) => {
-      console.log(
-        `[apm] \u8FDE\u63A5\u5DF2\u65AD\u5F00 code=${code}${reason ? ` reason=${reason.toString()}` : ""}`
-      );
-      void shutdown();
-    });
-    ws.on("error", (err) => {
-      console.error("[apm] WebSocket \u9519\u8BEF:", err.message);
-      reject(err);
-    });
-    process.on("SIGINT", () => {
-      console.log("[apm] \u6B63\u5728\u5173\u95ED\u2026");
-      void shutdown();
-    });
-    process.on("SIGTERM", () => {
-      void shutdown();
-    });
-  });
-}
-
-// src/commands/create-pr.ts
-async function runCreatePr(options) {
-  const sessionId = options.sessionId.trim();
-  if (!sessionId) {
-    console.error("[apm] sessionId \u4E0D\u80FD\u4E3A\u7A7A");
-    process.exit(1);
-  }
-  const title = options.title.trim();
-  if (!title) {
-    console.error("[apm] \u8BF7\u901A\u8FC7 --title \u6307\u5B9A PR \u6807\u9898");
-    process.exit(1);
-  }
-  const cfg = await ensureLoggedConfig();
-  const api = createApmApiClient(cfg);
-  const workdir = resolveWorkdirPath(options.cwd ?? process.cwd());
-  const pr = await api.cli.createPullRequest({
-    sessionId,
-    workdir,
-    title,
-    content: options.content ?? ""
-  });
-  console.log(`[apm] PR \u5DF2\u5C31\u7EEA #${pr.number} (${pr.state}): ${pr.url}`);
-}
-
-// src/commands/deploy/backend.ts
-import path5 from "node:path";
-
-// src/commands/deploy/internal/apm-config.ts
-import { existsSync as existsSync13, readFileSync as readFileSync12 } from "node:fs";
-import { resolve as resolve4 } from "node:path";
-function loadApmConfig(options) {
-  const p = resolve4(
-    process.cwd(),
-    options?.configPath ?? resolve4(workspaceApmDir(), "apm.config.json")
-  );
-  if (!existsSync13(p)) {
-    console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
-    process.exit(1);
-  }
-  try {
-    const raw = readFileSync12(p, "utf8");
-    return JSON.parse(raw);
-  } catch (e) {
-    console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
-    process.exit(1);
-  }
-}
-function req(v, field) {
-  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
-    console.error(`apm.config.json \u4E2D backendDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
-    process.exit(1);
-  }
-  return v;
-}
-function reqTopLevelName(cfg) {
-  const n = (cfg.name ?? "").trim();
-  if (!n) {
-    console.error(
-      "\u8BF7\u5728 apm.config.json \u9876\u5C42\u914D\u7F6E name\uFF08\u4E0E\u524D\u7AEF\u5236\u54C1\u524D\u7F00\u3001\u540E\u7AEF\u955C\u50CF\u540D\u5171\u7528\uFF09"
-    );
-    process.exit(1);
-  }
-  return n;
-}
-function reqBackendPositiveInt(v, field) {
-  const n = Number(v);
-  if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) {
-    console.error(`apm.config.json \u4E2D backendDeploy.${field} \u987B\u4E3A\u6B63\u6574\u6570`);
-    process.exit(1);
-  }
-  return n;
-}
-function resolveBackendDeployFromApmConfig(cfg) {
-  const b = cfg.backendDeploy ?? {};
-  const protoRaw = req(b.remoteProtocol, "remoteProtocol").trim().toLowerCase();
-  if (protoRaw !== "http" && protoRaw !== "https") {
-    console.error(
-      "apm.config.json \u4E2D backendDeploy.remoteProtocol \u53EA\u80FD\u4E3A http \u6216 https"
-    );
-    process.exit(1);
-  }
-  const remoteProtocol = protoRaw;
-  let mappings = [];
-  const rawPorts = b.containerPortsMappings;
-  if (rawPorts !== void 0 && rawPorts !== null) {
-    if (!Array.isArray(rawPorts)) {
-      console.error(
-        "apm.config.json \u4E2D backendDeploy.containerPortsMappings \u987B\u4E3A\u5B57\u7B26\u4E32\u6570\u7EC4\uFF08\u53EF\u4E3A\u7A7A\uFF0C\u7701\u7565\u5219\u4E0D\u52A0\u7AEF\u53E3\u6620\u5C04\uFF09"
-      );
-      process.exit(1);
-    }
-    mappings = rawPorts.map((x) => String(x).trim()).filter(Boolean);
-  }
-  return {
-    name: reqTopLevelName(cfg),
-    registryHost: req(b.registryHost, "registryHost").trim(),
-    registryNamespace: req(b.registryNamespace, "registryNamespace").trim(),
-    registryUser: req(b.registryUser, "registryUser").trim(),
-    registryPassword: req(b.registryPassword, "registryPassword").trim(),
-    remoteHost: req(b.remoteHost, "remoteHost").trim(),
-    remotePort: reqBackendPositiveInt(b.remotePort, "remotePort"),
-    remoteProtocol,
-    caPath: b.caPath?.trim(),
-    certPath: b.certPath?.trim(),
-    keyPath: b.keyPath?.trim(),
-    envFilePath: typeof b.envFilePath === "string" ? b.envFilePath.trim() : "",
-    containerPortsMappings: mappings,
-    dockerNetwork: b.dockerNetwork?.trim() || void 0
-  };
+    ws.on("close", (code, reason) => {
+      console.log(
+        `[apm] \u8FDE\u63A5\u5DF2\u65AD\u5F00 code=${code}${reason ? ` reason=${reason.toString()}` : ""}`
+      );
+      void shutdown();
+    });
+    ws.on("error", (err) => {
+      console.error("[apm] WebSocket \u9519\u8BEF:", err.message);
+      reject(err);
+    });
+    process.on("SIGINT", () => {
+      console.log("[apm] \u6B63\u5728\u5173\u95ED\u2026");
+      void shutdown();
+    });
+    process.on("SIGTERM", () => {
+      void shutdown();
+    });
+  });
 }
-function reqFe(v, field) {
-  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
-    console.error(`apm.config.json \u4E2D frontendDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+
+// src/commands/create-pr.ts
+async function runCreatePr(options) {
+  const sessionId = options.sessionId.trim();
+  if (!sessionId) {
+    console.error("[apm] sessionId \u4E0D\u80FD\u4E3A\u7A7A");
     process.exit(1);
   }
-  return v;
-}
-function resolveFrontendDeployFromApmConfig(cfg) {
-  const f = cfg.frontendDeploy ?? {};
-  const port = Number(f.port);
-  return {
-    endpoint: reqFe(f.endpoint, "endpoint").trim(),
-    port: Number.isFinite(port) && port > 0 ? port : 9e3,
-    useSsl: Boolean(f.useSsl),
-    accessKey: reqFe(f.accessKey, "accessKey").trim(),
-    secretKey: reqFe(f.secretKey, "secretKey").trim(),
-    bucket: reqFe(f.bucket, "bucket").trim()
-  };
-}
-function reqWd(v, field) {
-  if (v === void 0 || v === null || typeof v === "string" && !v.trim()) {
-    console.error(`apm.config.json \u4E2D wisdomDeploy.${field} \u4E0D\u80FD\u4E3A\u7A7A`);
+  const title = options.title.trim();
+  if (!title) {
+    console.error("[apm] \u8BF7\u901A\u8FC7 --title \u6307\u5B9A PR \u6807\u9898");
     process.exit(1);
   }
-  return v;
+  const cfg = await ensureLoggedConfig();
+  const api = createApmApiClient(cfg);
+  const workdir = resolveWorkdirPath(options.cwd ?? process.cwd());
+  const pr = await api.cli.createPullRequest({
+    sessionId,
+    workdir,
+    title,
+    content: options.content ?? ""
+  });
+  console.log(`[apm] PR \u5DF2\u5C31\u7EEA #${pr.number} (${pr.state}): ${pr.url}`);
 }
-function reqWisdomPositiveInt(v, field) {
-  const n = Number(v);
-  if (!Number.isFinite(n) || !Number.isInteger(n) || n < 1) {
-    console.error(`apm.config.json \u4E2D wisdomDeploy.${field} \u987B\u4E3A\u6B63\u6574\u6570`);
-    process.exit(1);
+
+// src/commands/deploy/deploy.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
+function runShellCommand3(command, cwd) {
+  console.error(`==> ${command}`);
+  const result = spawnSync5(command, {
+    cwd,
+    stdio: "inherit",
+    shell: true,
+    env: process.env
+  });
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
   }
-  return n;
 }
-function resolveWisdomDeployFromApmConfig(cfg) {
-  const w = cfg.wisdomDeploy ?? {};
-  return {
-    host: reqWd(w.host, "host").trim(),
-    port: reqWisdomPositiveInt(w.port, "port"),
-    username: reqWd(w.username, "username").trim(),
-    password: reqWd(w.password, "password").trim(),
-    remotePath: reqWd(w.remotePath, "remotePath").trim()
-  };
+function registerDeployMainCommand(program) {
+  program.command("deploy").description(
+    "\u7EDF\u4E00\u90E8\u7F72\uFF1A\u533B\u52A1\u5B58\u91CF\u81EA\u52A8\u8BC6\u522B\u524D\u540E\u7AEF\uFF08\u524D\u7AEF\u6309 deploy:<env> \u811A\u672C\uFF1B\u540E\u7AEF test/online \u540C\u4E00\u5957\uFF09\uFF1B\u5176\u4ED6\u9879\u76EE\u6309 deploy.<\u73AF\u5883> \u6267\u884C shell \u547D\u4EE4"
+  ).argument("<env>", "\u90E8\u7F72\u73AF\u5883\u540D\uFF08\u5982 test\u3001online\uFF09").option(
+    "--config <path>",
+    "apm.config.json \u8DEF\u5F84\uFF08\u9ED8\u8BA4 .apm/apm.config.json\uFF09"
+  ).option("--skip-maven", "\u8DF3\u8FC7 Maven \u6784\u5EFA\uFF08\u4EC5\u533B\u52A1\u540E\u7AEF\uFF09").action(
+    async (env, opts) => {
+      const cwd = process.cwd();
+      const cfg = loadApmConfig({ configPath: opts.config });
+      if (isWisdomLegacyDeploy(cfg)) {
+        await runWisdomAutoDeploy({
+          env,
+          cwd,
+          configPath: opts.config,
+          skipMaven: opts.skipMaven
+        });
+        return;
+      }
+      const deployCommands = cfg.deploy ?? {};
+      const command = deployCommands[env]?.trim();
+      if (!command) {
+        const keys = Object.keys(deployCommands);
+        console.error(
+          keys.length > 0 ? `apm.config.json \u4E2D\u672A\u914D\u7F6E deploy.${env}\uFF0C\u53EF\u7528\u73AF\u5883: ${keys.join(
+            ", "
+          )}` : `apm.config.json \u4E2D\u672A\u914D\u7F6E deploy \u6BB5`
+        );
+        process.exit(1);
+      }
+      runShellCommand3(command, cwd);
+    }
+  );
 }
 
+// src/commands/deploy/backend.ts
+import path8 from "node:path";
+
 // src/commands/deploy/internal/backend-deploy/backend-deploy-workflow.ts
-import path4 from "node:path";
+import path7 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 existsSync14, readFileSync as readFileSync13 } from "node:fs";
-import path from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync15 } from "node:fs";
+import path4 from "node:path";
 function asOptionalTlsBuffer(value) {
   if (typeof value !== "string") {
     console.log("tls filepath not exist");
     return void 0;
   }
-  console.log("tls filepath", path.join(process.cwd(), value));
+  console.log("tls filepath", path4.join(process.cwd(), value));
   const normalized = value.trim();
   if (normalized === "") {
     return void 0;
   }
-  if (existsSync14(normalized)) {
-    return readFileSync13(normalized);
+  if (existsSync17(normalized)) {
+    return readFileSync15(normalized);
   }
   const looksLikePath = /[\\/]/.test(normalized) || normalized.endsWith(".pem");
   if (looksLikePath) {
@@ -3914,8 +4767,8 @@ var DockerodeClient = class {
 var createDockerodeClient = (config) => new DockerodeClient(config);
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/env.ts
-import { existsSync as existsSync15, readFileSync as readFileSync14, statSync as statSync5 } from "node:fs";
-import path2 from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync16, statSync as statSync6 } from "node:fs";
+import path5 from "node:path";
 function stripSurroundingQuotes(value) {
   const t = value.trim();
   if (t.length >= 2) {
@@ -3930,11 +4783,11 @@ function loadEnvFromFile(envFilePath) {
   if (!envFilePath) {
     return {};
   }
-  const targetPath = path2.resolve(envFilePath);
-  if (!existsSync15(targetPath) || !statSync5(targetPath).isFile()) {
+  const targetPath = path5.resolve(envFilePath);
+  if (!existsSync18(targetPath) || !statSync6(targetPath).isFile()) {
     return {};
   }
-  const raw = readFileSync14(targetPath, "utf-8");
+  const raw = readFileSync16(targetPath, "utf-8");
   const result = {};
   for (const line of raw.split(/\r?\n/)) {
     const normalized = line.trim();
@@ -4105,12 +4958,12 @@ function dockerPushImage(params, cwd) {
 }
 
 // src/commands/deploy/internal/backend-deploy/resolve-dockerfile.ts
-import { existsSync as existsSync16 } from "node:fs";
-import path3 from "node:path";
+import { existsSync as existsSync19 } from "node:fs";
+import path6 from "node:path";
 function resolveDockerBuildPaths(cwd) {
-  const dockerfilePath = path3.join(cwd, "Dockerfile");
+  const dockerfilePath = path6.join(cwd, "Dockerfile");
   Logger.info(`\u67E5\u627EDockerfile\u6587\u4EF6\uFF0C\u8DEF\u5F84: ${dockerfilePath}`);
-  if (!existsSync16(dockerfilePath)) {
+  if (!existsSync19(dockerfilePath)) {
     throw new Error(`Dockerfile \u4E0D\u5B58\u5728\uFF1A${dockerfilePath}`);
   }
   Logger.info("\u2713 Dockerfile \u5B58\u5728");
@@ -4165,7 +5018,7 @@ var BackendDeployWorkflow = class {
       serveraddress
     });
     Logger.success("\u8FDC\u7A0B\u62C9\u53D6\u955C\u50CF\u5B8C\u6210");
-    const envFilePath = path4.resolve(cwd, this.params.envFilePath || ".env");
+    const envFilePath = path7.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()}`);
@@ -4205,7 +5058,7 @@ function registerDeployBackendCommands(program) {
       assertDeployImageTag(tag);
       const cfg = loadApmConfig({ configPath: opts.config });
       const fromApm = resolveBackendDeployFromApmConfig(cfg);
-      const dirAbs = path5.resolve(process.cwd(), opts.dir || "servers/api");
+      const dirAbs = path8.resolve(process.cwd(), opts.dir || "servers/api");
       const params = {
         image: fromApm.name,
         tag,
@@ -4235,18 +5088,18 @@ function registerDeployBackendCommands(program) {
 }
 
 // src/commands/deploy/frontend.ts
-import { copyFile, readdir as readdir2, stat } from "node:fs/promises";
-import path7 from "node:path";
+import { copyFile, readdir as readdir3, stat } from "node:fs/promises";
+import path10 from "node:path";
 
 // src/commands/deploy/internal/minio.ts
-import { statSync as statSync6 } from "node:fs";
-import { readdir, readFile } from "node:fs/promises";
-import path6 from "node:path";
+import { statSync as statSync7 } from "node:fs";
+import { readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
+import path9 from "node:path";
 import * as Minio from "minio";
 var DEFAULT_MAX_FILE_SIZE_MB = 50;
 async function isDirectoryPath(dir) {
   try {
-    const st = statSync6(dir);
+    const st = statSync7(dir);
     return st.isDirectory();
   } catch {
     return false;
@@ -4265,18 +5118,18 @@ function sanitizeRelativePath(rel) {
 async function collectFiles(root) {
   const out = [];
   async function walk(dir, prefix) {
-    const entries = await readdir(dir, { withFileTypes: true });
+    const entries = await readdir2(dir, { withFileTypes: true });
     for (const e of entries) {
       const name = e.name;
       if (name === "." || name === "..") {
         continue;
       }
-      const abs = path6.join(dir, name);
+      const abs = path9.join(dir, name);
       const rel = prefix ? `${prefix}/${name}` : name;
       if (e.isDirectory()) {
         await walk(abs, rel);
       } else if (e.isFile()) {
-        const st = statSync6(abs);
+        const st = statSync7(abs);
         out.push({
           absPath: abs,
           relativePath: rel.replace(/\\/g, "/"),
@@ -4290,7 +5143,7 @@ async function collectFiles(root) {
   return out;
 }
 async function readArtifactFile(absPath) {
-  return readFile(absPath);
+  return readFile2(absPath);
 }
 function toMB(bytes) {
   return Math.round(bytes / (1024 * 1024) * 1e3) / 1e3;
@@ -4314,7 +5167,7 @@ var MIME = {
   ".map": "application/json"
 };
 function detectMimeType(filePath) {
-  const ext = path6.extname(filePath).toLowerCase();
+  const ext = path9.extname(filePath).toLowerCase();
   return MIME[ext] ?? "";
 }
 var MinioClient = class {
@@ -4402,7 +5255,7 @@ function artifactObjectKey(namePrefix, branchSegment, relativePath) {
   return `${base}/${branchSegment}/dist/${rel}`;
 }
 async function ensureArtifactRootIndexHtml(root) {
-  const indexHtmlPath = path7.join(root, "index.html");
+  const indexHtmlPath = path10.join(root, "index.html");
   try {
     const st = await stat(indexHtmlPath);
     if (st.isFile()) {
@@ -4412,14 +5265,14 @@ async function ensureArtifactRootIndexHtml(root) {
   }
   let entries;
   try {
-    entries = await readdir2(root, { withFileTypes: true });
+    entries = await readdir3(root, { withFileTypes: true });
   } catch (e) {
     console.error(`\u65E0\u6CD5\u8BFB\u53D6\u4EA7\u7269\u76EE\u5F55\uFF1A${root}`, e);
     process.exit(1);
   }
   const dirNames = entries.filter((e) => e.isDirectory()).map((e) => String(e.name)).sort();
   for (const name of dirNames) {
-    const candidate = path7.join(root, name, "index.html");
+    const candidate = path10.join(root, name, "index.html");
     try {
       const st = await stat(candidate);
       if (!st.isFile()) {
@@ -4430,7 +5283,7 @@ async function ensureArtifactRootIndexHtml(root) {
     }
     await copyFile(candidate, indexHtmlPath);
     console.error(
-      `\u4EA7\u7269\u534F\u8BAE\uFF1A\u5DF2\u5C06 ${path7.join(name, "index.html")} \u590D\u5236\u4E3A\u6839\u76EE\u5F55 index.html`
+      `\u4EA7\u7269\u534F\u8BAE\uFF1A\u5DF2\u5C06 ${path10.join(name, "index.html")} \u590D\u5236\u4E3A\u6839\u76EE\u5F55 index.html`
     );
     return;
   }
@@ -4466,7 +5319,7 @@ function registerDeployFrontendCommands(program) {
         secretKey: settings.secretKey
       });
       const bucket = settings.bucket;
-      const root = path7.resolve(process.cwd(), opts.dir || "apps/web/dist");
+      const root = path10.resolve(process.cwd(), opts.dir || "apps/web/dist");
       if (!await isDirectoryPath(root)) {
         console.error(`\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${root}`);
         process.exit(1);
@@ -4535,159 +5388,7 @@ function registerDeployFrontendCommands(program) {
 }
 
 // src/commands/deploy/sftp.ts
-import path9 from "node:path";
-
-// src/commands/deploy/internal/wisdom-sftp.ts
-import { readdir as readdir3, readFile as readFile2, unlink, writeFile } from "node:fs/promises";
-import path8 from "node:path";
-import JSZip from "jszip";
-import SftpClient from "ssh2-sftp-client";
-async function addDirToZip(dir, zipFolder) {
-  const entries = await readdir3(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path8.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      const folder = zipFolder.folder(entry.name);
-      if (folder) {
-        await addDirToZip(fullPath, folder);
-      }
-    } else {
-      const content = await readFile2(fullPath);
-      zipFolder.file(entry.name, content);
-    }
-  }
-}
-async function zipDirectory(distDir, zipPath) {
-  console.error(`\u538B\u7F29\u76EE\u5F55: ${distDir}`);
-  const zip = new JSZip();
-  await addDirToZip(distDir, zip);
-  const content = await zip.generateAsync({
-    type: "nodebuffer",
-    compression: "DEFLATE",
-    compressionOptions: { level: 6 }
-  });
-  await writeFile(zipPath, content);
-  const sizeMb = (content.length / 1024 / 1024).toFixed(2);
-  console.error(`\u5DF2\u751F\u6210: ${zipPath} (${sizeMb} MB)`);
-  return content.length;
-}
-async function ensureRemoteDir(sftp, dir) {
-  const parts = dir.replace(/\\/g, "/").split("/").filter(Boolean);
-  let current = dir.startsWith("/") ? "" : ".";
-  for (const part of parts) {
-    current = current ? `${current}/${part}` : `/${part}`;
-    try {
-      await sftp.mkdir(current, true);
-    } catch {
-    }
-  }
-}
-function execCommand(client, command) {
-  return new Promise((resolve5, reject) => {
-    client.exec(command, (err, stream) => {
-      if (err) return reject(err);
-      let stdout = "";
-      let stderr = "";
-      stream.on("close", (code) => {
-        if (code !== 0) {
-          reject(new Error(`\u8FDC\u7A0B\u547D\u4EE4\u5931\u8D25 (${code}): ${stderr || stdout}`));
-          return;
-        }
-        resolve5(stdout);
-      }).on("data", (data) => {
-        stdout += data.toString();
-      });
-      stream.stderr.on("data", (data) => {
-        stderr += data.toString();
-      });
-    });
-  });
-}
-function shellSingleQuote(value) {
-  return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-function buildClearRemoteDirExceptZipCommand(target) {
-  const normalized = target.replace(/\\/g, "/").replace(/\/$/, "");
-  const quotedTarget = shellSingleQuote(normalized);
-  const script = [
-    `T=${quotedTarget}`,
-    "S=$(mktemp -d)",
-    'while IFS= read -r -d "" z; do r="${z#${T}/}"',
-    'mkdir -p "${S}/$(dirname "$r")"',
-    'mv "$z" "${S}/${r}"',
-    'done < <(find "$T" -mindepth 1 -type f -iname "*.zip" -print0)',
-    'rm -rf "${T}"/*',
-    'while IFS= read -r -d "" r; do r="${r#./}"',
-    'mkdir -p "${T}/$(dirname "$r")"',
-    'mv "${S}/${r}" "${T}/${r}"',
-    'done < <(cd "$S" 2>/dev/null && find . -type f -print0)',
-    'rm -rf "$S"'
-  ].join("; ");
-  return `bash -c ${shellSingleQuote(script)}`;
-}
-async function uploadAndMaybeExtract(settings, localZip, extract) {
-  const remoteZipPath = `${settings.remotePath.replace(/\/$/, "")}/dist.zip`;
-  console.error(
-    `\u8FDE\u63A5 ${settings.username}@${settings.host}:${settings.port} ...`
-  );
-  const sftp = new SftpClient();
-  try {
-    await sftp.connect({
-      host: settings.host,
-      port: settings.port,
-      username: settings.username,
-      password: settings.password,
-      readyTimeout: 2e4,
-      tryKeyboard: true
-    });
-    await ensureRemoteDir(sftp, settings.remotePath);
-    await sftp.put(localZip, remoteZipPath);
-    console.error(`  \u2713 ${localZip} -> ${remoteZipPath}`);
-    if (extract) {
-      const target = settings.remotePath.replace(/\/$/, "");
-      const client = sftp.client;
-      const clearCmd = buildClearRemoteDirExceptZipCommand(target);
-      console.error(`\u8FDC\u7A0B\u6E05\u7406\u89E3\u538B\u76EE\u5F55: ${clearCmd}`);
-      await execCommand(client, clearCmd);
-      const unzipCmd = `unzip -o "${remoteZipPath}" -d "${target}"`;
-      console.error(`\u8FDC\u7A0B\u89E3\u538B: ${unzipCmd}`);
-      await execCommand(client, unzipCmd);
-      console.error("\u8FDC\u7A0B\u89E3\u538B\u5B8C\u6210!");
-    }
-    console.error(extract ? "\u90E8\u7F72\u5B8C\u6210!" : "\u4E0A\u4F20\u5B8C\u6210!");
-  } finally {
-    await sftp.end();
-  }
-}
-async function runWisdomSftpDeploy(params) {
-  const zipPath = path8.join(params.localDir, "..", ".deploy-sftp-dist.zip");
-  const resolvedZipPath = path8.resolve(zipPath);
-  let zipSizeBytes = 0;
-  try {
-    zipSizeBytes = await zipDirectory(params.localDir, resolvedZipPath);
-    await uploadAndMaybeExtract(
-      params.settings,
-      resolvedZipPath,
-      params.extract
-    );
-  } finally {
-    try {
-      await unlink(resolvedZipPath);
-      console.error(`\u5DF2\u6E05\u7406\u672C\u5730\u4E34\u65F6\u6587\u4EF6: ${resolvedZipPath}`);
-    } catch {
-    }
-  }
-  return {
-    ok: true,
-    localDir: params.localDir,
-    host: params.settings.host,
-    remotePath: params.settings.remotePath,
-    zipSizeBytes,
-    extracted: params.extract
-  };
-}
-
-// src/commands/deploy/sftp.ts
+import path11 from "node:path";
 function registerDeploySftpCommands(program) {
   program.command("deploy-sftp").description(
     "\u5C06\u6307\u5B9A\u76EE\u5F55\u538B\u7F29\u4E3A zip \u540E\u901A\u8FC7 SFTP \u4E0A\u4F20\u5230\u8FDC\u7A0B\u670D\u52A1\u5668\uFF08\u8FDE\u63A5\u4FE1\u606F\u89C1 apm.config.json wisdomDeploy\uFF09"
@@ -4702,7 +5403,7 @@ function registerDeploySftpCommands(program) {
     async (opts) => {
       const cfg = loadApmConfig({ configPath: opts.config });
       const settings = resolveWisdomDeployFromApmConfig(cfg);
-      const root = path9.resolve(process.cwd(), opts.dir || "apps/web/dist");
+      const root = path11.resolve(process.cwd(), opts.dir || "apps/web/dist");
       if (!await isDirectoryPath(root)) {
         console.error(`\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A${root}`);
         process.exit(1);
@@ -4723,11 +5424,30 @@ function registerDeploySftpCommands(program) {
   );
 }
 
+// src/commands/deploy/wisdom-backend.ts
+function registerDeployWisdomBackendCommands(program) {
+  program.command("deploy-wisdom-backend").description(
+    "Maven \u6784\u5EFA\u540E\u901A\u8FC7 SFTP \u589E\u91CF\u66F4\u65B0\u8FDC\u7A0B lib \u76EE\u5F55\u5E76\u91CD\u542F Spring Boot \u670D\u52A1\uFF08\u914D\u7F6E\u89C1 apm.config.json \u7684 wisdomDeploy \u4E0E healthCheck\uFF09"
+  ).option(
+    "--config <path>",
+    "apm.config.json \u8DEF\u5F84\uFF08\u9ED8\u8BA4 .apm/apm.config.json\uFF09"
+  ).option("--skip-maven", "\u8DF3\u8FC7 Maven \u6784\u5EFA\uFF0C\u4EC5\u4E0A\u4F20\u5E76\u91CD\u542F").action(async (opts) => {
+    const cfg = loadApmConfig({ configPath: opts.config });
+    const settings = resolveWisdomBackendDeployFromApmConfig(cfg);
+    await runWisdomBackendDeploy({
+      config: settings,
+      skipMaven: Boolean(opts.skipMaven)
+    });
+  });
+}
+
 // src/commands/deploy/index.ts
 function registerDeployCommands(program) {
+  registerDeployMainCommand(program);
   registerDeployBackendCommands(program);
   registerDeployFrontendCommands(program);
   registerDeploySftpCommands(program);
+  registerDeployWisdomBackendCommands(program);
 }
 
 // src/index.ts