ai-project-manage-cli 6.0.102 → 6.0.104

package/dist/index.js

@@ -2389,7 +2389,7 @@ async function runUpdateMessageStatus(options) {
 
 // src/commands/connect.ts
 import WebSocket from "ws";
-import { setTimeout as delay2 } from "node:timers/promises";
+import { setTimeout as delay3 } from "node:timers/promises";
 
 // src/ws/protocol.ts
 function nonEmptyString(v) {
@@ -2511,8 +2511,67 @@ function validateAgentWsMessage(value, kind) {
   return validateMessagePush(o);
 }
 
+// src/commands/deploy/deploy-log-utils.ts
+import { setTimeout as delay } from "node:timers/promises";
+var DEPLOY_SPAWN_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
+var DEPLOY_LOG_SYNC_MAX_CHUNK_BYTES = 4 * 1024 * 1024;
+var DEPLOY_COMPLETE_LOG_MAX_BYTES = 9 * 1024 * 1024;
+var DEPLOY_LOG_SYNC_MAX_ATTEMPTS = 3;
+async function retryDeployLogSync(fn, attempts = DEPLOY_LOG_SYNC_MAX_ATTEMPTS) {
+  let lastError;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < attempts) {
+        await delay(1e3 * attempt);
+      }
+    }
+  }
+  throw lastError;
+}
+function splitUtf8StringByMaxBytes(value, maxBytes) {
+  if (maxBytes <= 0) {
+    throw new Error("maxBytes must be positive");
+  }
+  const bytes = Buffer.from(value, "utf8");
+  if (bytes.length <= maxBytes) {
+    return [value];
+  }
+  const chunks = [];
+  let offset = 0;
+  while (offset < bytes.length) {
+    let end = Math.min(offset + maxBytes, bytes.length);
+    while (end > offset && (bytes[end] & 192) === 128) {
+      end -= 1;
+    }
+    if (end <= offset) {
+      end = Math.min(offset + maxBytes, bytes.length);
+    }
+    chunks.push(bytes.subarray(offset, end).toString("utf8"));
+    offset = end;
+  }
+  return chunks;
+}
+function truncateDeployLogForComplete(log2) {
+  const bytes = Buffer.from(log2, "utf8");
+  if (bytes.length <= DEPLOY_COMPLETE_LOG_MAX_BYTES) {
+    return { log: log2, truncated: false };
+  }
+  const tailBudget = Math.max(DEPLOY_COMPLETE_LOG_MAX_BYTES - 512, 1024);
+  const prefix = `[apm] \u65E5\u5FD7\u8FC7\u957F\uFF08${Math.ceil(bytes.length / 1024)}KB\uFF09\uFF0C\u4EC5\u4FDD\u7559\u672B\u5C3E ${Math.floor(tailBudget / 1024)}KB
+`;
+  let tail = bytes.subarray(bytes.length - tailBudget).toString("utf8");
+  const brokenPrefix = tail.indexOf("\uFFFD");
+  if (brokenPrefix >= 0) {
+    const newline = tail.indexOf("\n", brokenPrefix);
+    tail = newline >= 0 ? tail.slice(newline + 1) : tail.slice(brokenPrefix + 1);
+  }
+  return { log: prefix + tail, truncated: true };
+}
+
 // src/commands/deploy/deploy-execute.ts
-import { spawnSync as spawnSync6 } from "node:child_process";
 import path5 from "node:path";
 
 // src/commands/deploy/internal/apm-config.ts
@@ -2819,33 +2878,17 @@ function posixBasename(p) {
 }
 
 // src/commands/deploy/internal/deploy-hints.ts
-function formatDeployNotConfiguredLines(env, deployCommands) {
-  const configuredEnvs = Object.keys(deployCommands).filter(
-    (key) => deployCommands[key]?.trim()
-  );
-  if (configuredEnvs.length > 0) {
-    return [
-      `[apm] \u65E0\u6CD5\u6267\u884C\u90E8\u7F72\uFF1Aapm.config.json \u4E2D\u672A\u914D\u7F6E deploy.${env}`,
-      `[apm] \u5F53\u524D\u5DF2\u914D\u7F6E\u7684\u73AF\u5883: ${configuredEnvs.join(", ")}`
-    ];
-  }
+function formatMissingWisdomDeployLines() {
   return [
-    "[apm] \u65E0\u6CD5\u6267\u884C\u90E8\u7F72\uFF1A\u5F53\u524D\u9879\u76EE\u672A\u914D\u7F6E\u81EA\u52A8\u5316\u90E8\u7F72\uFF08apm.config.json \u4E2D\u65E0 deploy \u6BB5\uFF09",
-    "[apm] \u90E8\u5206\u9879\u76EE\u4E0D\u652F\u6301\u6216\u672A\u542F\u7528\u81EA\u52A8\u5316\u90E8\u7F72\uFF0C\u5C5E\u6B63\u5E38\u60C5\u51B5\uFF0C\u53EF\u8DF3\u8FC7\u90E8\u7F72"
+    "[apm] \u65E0\u6CD5\u6267\u884C apm deploy\uFF1A\u8BF7\u5728 apm.config.json \u4E2D\u914D\u7F6E wisdomDeploy\uFF08host\u3001remotePath\uFF09"
   ];
 }
 function formatWisdomFrontendBuildNotConfiguredLines(env, packageJsonPath) {
   return [
-    `[apm] \u65E0\u6CD5\u6267\u884C\u4EC5\u6253\u5305\uFF1A${packageJsonPath} \u4E2D\u672A\u627E\u5230 build:${env} \u811A\u672C`,
+    `[apm] \u65E0\u6CD5\u6267\u884C\u524D\u7AEF\u90E8\u7F72\uFF1A${packageJsonPath} \u4E2D\u672A\u627E\u5230 build:${env} \u811A\u672C`,
     "[apm] \u8BF7\u914D\u7F6E npm run build:test / build:online \u540E\u518D\u8BD5"
   ];
 }
-function formatWisdomFrontendDeployNotConfiguredLines(env, packageJsonPath) {
-  return [
-    `[apm] \u65E0\u6CD5\u6267\u884C\u90E8\u7F72\uFF1A${packageJsonPath} \u4E2D\u672A\u627E\u5230 deploy:${env} \u811A\u672C`,
-    "[apm] \u82E5\u672C\u9879\u76EE\u4E0D\u652F\u6301\u81EA\u52A8\u5316\u90E8\u7F72\uFF0C\u5C5E\u6B63\u5E38\u60C5\u51B5\uFF0C\u53EF\u8DF3\u8FC7\u90E8\u7F72"
-  ];
-}
 
 // src/commands/deploy/deploy-errors.ts
 var DeployExecutionError = class extends Error {
@@ -2859,31 +2902,10 @@ var DeployExecutionError = class extends Error {
   }
 };
 
-// src/commands/deploy/internal/wisdom-auto-deploy.ts
-import { existsSync as existsSync15, readFileSync as readFileSync13, statSync as statSync7 } from "node:fs";
-import path4 from "node:path";
-import { spawnSync as spawnSync5 } from "node:child_process";
-
-// src/commands/deploy/internal/wisdom-backend-deploy.ts
-import {
-  existsSync as existsSync12,
-  mkdirSync as mkdirSync5,
-  readdirSync as readdirSync5,
-  readFileSync as readFileSync11,
-  statSync as statSync6,
-  writeFileSync as writeFileSync10
-} from "node:fs";
-import { spawnSync as spawnSync2 } from "node:child_process";
-import path3 from "node:path";
-import { Client as Client2 } from "ssh2";
-import JSZip2 from "jszip";
-import SftpClient2 from "ssh2-sftp-client";
-
-// src/commands/deploy/internal/wisdom-sftp.ts
-import { readdir as readdir2, readFile as readFile3, unlink, writeFile } from "node:fs/promises";
-import path2 from "node:path";
-import JSZip from "jszip";
-import SftpClient from "ssh2-sftp-client";
+// src/commands/deploy/deploy-debug-log.ts
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { existsSync as existsSync14 } from "node:fs";
+import { dirname as dirname5, join as join16 } from "node:path";
 
 // src/commands/deploy/internal/deploy-artifact-minio.ts
 import { readFile as readFile2 } from "node:fs/promises";
@@ -3135,1711 +3157,1974 @@ async function uploadDeployArtifactZip(options) {
   };
 }
 
-// src/commands/deploy/internal/wisdom-sftp.ts
-async function addDirToZip(dir, zipFolder) {
-  const entries = await readdir2(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = path2.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      const folder = zipFolder.folder(entry.name);
-      if (folder) {
-        await addDirToZip(fullPath, folder);
-      }
-    } else {
-      const content = await readFile3(fullPath);
-      zipFolder.file(entry.name, content);
-    }
+// src/commands/deploy/internal/deploy-shell-env.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { dirname as dirname4 } from "node:path";
+
+// src/commands/daemon.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { setTimeout as delay2 } from "node:timers/promises";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
+import { join as join15 } from "path";
+
+// src/commands/connect-lock.ts
+import {
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync11,
+  unlinkSync,
+  writeFileSync as writeFileSync10
+} from "fs";
+import { join as join14 } from "path";
+var CONNECT_LOCK_PATH = join14(APM_CONFIG_DIR, "connect.lock");
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
   }
 }
-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;
-}
-var SFTP_UPLOAD_MAX_ATTEMPTS = 3;
-var SFTP_FAST_PUT_OPTIONS = {
-  chunkSize: 64 * 1024,
-  concurrency: 4
-};
-function buildSftpConnectOptions(settings) {
-  return {
-    host: settings.host,
-    port: settings.port,
-    username: settings.username,
-    password: settings.password,
-    readyTimeout: 3e4,
-    tryKeyboard: true,
-    keepaliveInterval: 1e4,
-    keepaliveCountMax: 3
-  };
-}
-async function sleep(ms) {
-  await new Promise((resolve5) => setTimeout(resolve5, ms));
-}
-async function uploadZipWithRetry(settings, localZip, remoteZipPath) {
-  let lastError;
-  for (let attempt = 1; attempt <= SFTP_UPLOAD_MAX_ATTEMPTS; attempt++) {
-    const sftp = new SftpClient();
-    try {
-      if (attempt > 1) {
-        console.error(
-          `SFTP \u4E0A\u4F20\u91CD\u8BD5 (${attempt}/${SFTP_UPLOAD_MAX_ATTEMPTS})...`
-        );
-      }
-      await sftp.connect(buildSftpConnectOptions(settings));
-      await ensureRemoteDir(sftp, settings.remotePath);
-      await sftp.fastPut(localZip, remoteZipPath, SFTP_FAST_PUT_OPTIONS);
-      return sftp;
-    } catch (err) {
-      lastError = err;
-      try {
-        await sftp.end();
-      } catch {
-      }
-      if (attempt < SFTP_UPLOAD_MAX_ATTEMPTS) {
-        const message = err instanceof Error ? err.message : String(err);
-        const delaySec = attempt * 2;
-        console.error(`SFTP \u4E0A\u4F20\u5931\u8D25 (${message})\uFF0C${delaySec}s \u540E\u91CD\u8BD5...`);
-        await sleep(delaySec * 1e3);
-      }
-    }
+function sleepSync(ms) {
+  const deadline = Date.now() + ms;
+  while (Date.now() < deadline) {
   }
-  throw lastError;
 }
-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 waitForPm2LockHandoff(timeoutMs = 5e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    pruneStaleConnectLock();
+    const lock = readConnectLock();
+    if (!lock || lock.mode !== "pm2" || lock.pid === process.pid || !isProcessAlive(lock.pid)) {
+      return;
     }
+    sleepSync(100);
   }
 }
-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 = await uploadZipWithRetry(settings, localZip, remoteZipPath);
+function readConnectLock() {
+  if (!existsSync12(CONNECT_LOCK_PATH)) return null;
   try {
-    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!");
+    const raw = readFileSync11(CONNECT_LOCK_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.pid !== "number" || parsed.mode !== "foreground" && parsed.mode !== "pm2" || typeof parsed.startedAt !== "string") {
+      return null;
     }
-    console.error(extract ? "\u90E8\u7F72\u5B8C\u6210!" : "\u4E0A\u4F20\u5B8C\u6210!");
-  } finally {
-    await sftp.end();
+    return parsed;
+  } catch {
+    return null;
   }
 }
-async function runWisdomSftpDeploy(params) {
-  const zipPath = path2.join(params.localDir, "..", ".deploy-sftp-dist.zip");
-  const resolvedZipPath = path2.resolve(zipPath);
-  const packOnly = Boolean(params.packOnly);
-  let zipSizeBytes = 0;
-  let artifactUploaded = false;
+function pruneStaleConnectLock() {
+  const lock = readConnectLock();
+  if (!lock) return;
+  if (isProcessAlive(lock.pid)) return;
   try {
-    zipSizeBytes = await zipDirectory(params.localDir, resolvedZipPath);
-    if (!packOnly) {
-      await uploadAndMaybeExtract(
-        params.settings,
-        resolvedZipPath,
-        params.extract
-      );
-    } else {
-      console.error("[apm] \u4EC5\u6253\u5305\u6A21\u5F0F\uFF1A\u8DF3\u8FC7 SFTP \u8FDC\u7A0B\u4E0A\u4F20");
-    }
-    const artifact = await uploadDeployArtifactZip({
-      zipPath: resolvedZipPath,
-      projectName: params.projectName,
-      kind: "frontend",
-      uploadWithoutRunId: packOnly && !resolveDeploymentRunIdFromEnv()
-    });
-    artifactUploaded = artifact !== null;
-    if (packOnly && artifactUploaded) {
-      console.error("\u6253\u5305\u5E76\u4E0A\u4F20 MinIO \u5B8C\u6210\uFF08\u672A\u4E0A\u4F20\u8FDC\u7A0B\u670D\u52A1\u5668\uFF09");
+    unlinkSync(CONNECT_LOCK_PATH);
+  } catch {
+  }
+}
+function acquireConnectLock(mode) {
+  pruneStaleConnectLock();
+  const existing = readConnectLock();
+  if (existing && isProcessAlive(existing.pid)) {
+    if (existing.pid === process.pid) {
+      return;
     }
-  } finally {
-    try {
-      await unlink(resolvedZipPath);
-      console.error(`\u5DF2\u6E05\u7406\u672C\u5730\u4E34\u65F6\u6587\u4EF6: ${resolvedZipPath}`);
-    } catch {
+    if (mode === "pm2" && existing.mode === "pm2") {
+      forceReleaseConnectLock();
+    } else {
+      console.error(
+        `[apm] \u5DF2\u6709 apm connect \u5728\u8FD0\u884C (pid=${existing.pid}, mode=${existing.mode})`
+      );
+      process.exit(1);
     }
   }
-  return {
-    ok: true,
-    localDir: params.localDir,
-    host: params.settings.host,
-    remotePath: params.settings.remotePath,
-    zipSizeBytes,
-    extracted: packOnly ? false : params.extract,
-    packOnly,
-    artifactUploaded
+  mkdirSync5(APM_CONFIG_DIR, { recursive: true });
+  const lock = {
+    pid: process.pid,
+    mode,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
+  writeFileSync10(
+    CONNECT_LOCK_PATH,
+    JSON.stringify(lock, null, 2) + "\n",
+    "utf8"
+  );
+}
+function releaseConnectLock() {
+  const lock = readConnectLock();
+  if (lock?.pid !== process.pid) return;
+  try {
+    unlinkSync(CONNECT_LOCK_PATH);
+  } catch {
+  }
+}
+function forceReleaseConnectLock() {
+  try {
+    if (existsSync12(CONNECT_LOCK_PATH)) {
+      unlinkSync(CONNECT_LOCK_PATH);
+    }
+  } catch {
+  }
 }
 
-// src/commands/deploy/internal/wisdom-backend-deploy.ts
-var SPRINGBOOT_JAVA_OPTS = "-XX:+UseG1GC -XX:+HeapDumpOnOutOfMemoryError -Xms512M -Xmx1G";
-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}`);
+// src/commands/daemon.ts
+var PM2_APP_NAME = "apm-connect";
+var PM2_ECOSYSTEM_PATH = join15(
+  APM_CONFIG_DIR,
+  "connect.ecosystem.config.cjs"
+);
+var PM2_CONNECT_ENTRY_PATH = join15(APM_CONFIG_DIR, "connect.entry.cjs");
+var PM2_CONNECT_LAUNCH_PATH = join15(
+  APM_CONFIG_DIR,
+  "connect.launch.json"
+);
+var LEGACY_PM2_ECOSYSTEM_PATH = join15(
+  APM_CONFIG_DIR,
+  "connect.ecosystem.cjs"
+);
+var LEGACY_PM2_APP_NAMES = ["connect.ecosystem"];
+var CONNECT_ENTRY_SCRIPT = `'use strict';
+const { spawnSync } = require('node:child_process');
+const { readFileSync } = require('node:fs');
+const { join } = require('node:path');
+
+const launchConfigPath = join(__dirname, 'connect.launch.json');
+let config;
+try {
+  config = JSON.parse(readFileSync(launchConfigPath, 'utf8'));
+} catch (err) {
+  console.error('[apm] \u65E0\u6CD5\u8BFB\u53D6 connect.launch.json:', err instanceof Error ? err.message : err);
+  process.exit(1);
 }
-function fail(message) {
-  log(`ERROR: ${message}`);
+
+const nodeArgs = [config.apmScript, ...(config.connectArgs || [])];
+const childEnv = {
+  ...process.env,
+  ...(config.env || {}),
+  APM_CONNECT_UNDER_PM2: '1',
+};
+
+const result = spawnSync(config.nodePath, nodeArgs, {
+  cwd: config.cwd || undefined,
+  env: childEnv,
+  stdio: 'inherit',
+  windowsHide: true,
+});
+
+if (result.error) {
+  console.error('[apm] connect \u542F\u52A8\u5931\u8D25:', result.error.message);
   process.exit(1);
 }
-function expandPath(pathStr) {
-  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return path3.resolve(pathStr.replace(/^~(?=\/|\\|$)/, home));
+process.exit(result.status ?? 0);
+`;
+function resolveConnectArgs(server) {
+  const args = ["connect"];
+  const trimmed = server?.trim();
+  if (trimmed) {
+    args.push("--server", trimmed.replace(/\/+$/, ""));
+  }
+  return args;
 }
-function quoteForShell(value) {
-  if (process.platform === "win32") {
-    return `"${value.replace(/"/g, '""')}"`;
+var PM2_LAUNCH_ENV_KEYS = [
+  "PATH",
+  "HOME",
+  "USER",
+  "SHELL",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "NVM_DIR",
+  "NVM_BIN",
+  "NVM_INC",
+  "FNM_DIR",
+  "VOLTA_HOME",
+  "PNPM_HOME",
+  "npm_config_prefix",
+  "NODE_HOME"
+];
+function collectPm2LaunchEnv() {
+  const env = {};
+  for (const key of PM2_LAUNCH_ENV_KEYS) {
+    const value = process.env[key]?.trim();
+    if (value) {
+      env[key] = value;
+    }
   }
-  return shellSingleQuote(value);
+  return env;
 }
-function formatMavenLocalRepoArg(repoPath) {
+function buildConnectPm2Ecosystem(options) {
+  const env = {};
+  const baseUrl = options.baseUrl?.trim().replace(/\/+$/, "");
+  if (baseUrl) {
+    env.AI_PM_SERVER = baseUrl;
+  }
+  const app = {
+    name: PM2_APP_NAME,
+    script: options.entryScript,
+    cwd: APM_CONFIG_DIR,
+    autorestart: true,
+    min_uptime: "10s",
+    max_restarts: 10,
+    restart_delay: 3e3,
+    exp_backoff_restart_delay: 1e3,
+    max_memory_restart: "2G",
+    kill_timeout: 5e3,
+    shutdown_with_message: true,
+    instances: 1,
+    exec_mode: "fork",
+    env
+  };
   if (process.platform === "win32") {
-    return `-Dmaven.repo.local=${quoteForShell(repoPath)}`;
+    app.windowsHide = true;
   }
-  return `-Dmaven.repo.local=${repoPath}`;
+  return {
+    apps: [app]
+  };
 }
-function deployCacheDir() {
-  return path3.join(workspaceApmDir(), "deploy", ".deploy_cache");
+function formatConnectPm2EcosystemFile(ecosystem) {
+  return `module.exports = ${JSON.stringify(ecosystem, null, 2)};
+`;
 }
-function manifestFilePath() {
-  return path3.join(deployCacheDir(), "manifest.json");
+var useNpmShell2 = process.platform === "win32";
+function runNpm2(args, options = {}) {
+  return spawnSync2(useNpmShell2 ? "npm.cmd" : "npm", args, {
+    ...options,
+    shell: useNpmShell2
+  });
 }
-function getTargetDir(projectRoot) {
-  return path3.join(projectRoot, MAVEN_MODULE, "target");
+function resolveNpmGlobalBin() {
+  const binResult = runNpm2(["bin", "-g"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (binResult.status !== 0) return null;
+  return binResult.stdout?.toString().trim() || null;
 }
-function relativeKey(projectRoot, filePath) {
-  return path3.relative(projectRoot, filePath).split(path3.sep).join("/");
+function resolvePm2FromNpmRoot() {
+  const rootResult = runNpm2(["root", "-g"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (rootResult.status !== 0) return null;
+  const root = rootResult.stdout?.toString().trim();
+  if (!root) return null;
+  for (const rel of ["pm2/bin/pm2", "pm2/bin/pm2.js"]) {
+    const candidate = join15(root, ...rel.split("/"));
+    if (existsSync13(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
 }
-function fileSignature(filePath) {
-  const stat2 = statSync6(filePath);
-  return { size: stat2.size, mtime: stat2.mtimeMs / 1e3 };
+function isPm2NodeScript(path13) {
+  return path13.endsWith(".js") || /[\\/]pm2[\\/]bin[\\/]pm2$/.test(path13);
 }
-function loadManifest3() {
-  const manifestPath2 = manifestFilePath();
-  if (!existsSync12(manifestPath2)) {
-    return {};
+function buildPm2SpawnTarget(binPath) {
+  if (isPm2NodeScript(binPath)) {
+    return {
+      command: process.execPath,
+      prefixArgs: [binPath],
+      displayPath: binPath
+    };
   }
-  return JSON.parse(readFileSync11(manifestPath2, "utf8"));
+  return {
+    command: binPath,
+    prefixArgs: [],
+    displayPath: binPath
+  };
 }
-function saveManifest3(manifest) {
-  const dir = deployCacheDir();
-  mkdirSync5(dir, { recursive: true });
-  writeFileSync10(manifestFilePath(), JSON.stringify(manifest, null, 2), "utf8");
+function spawnPm2Target(target, args, options = {}) {
+  const useShell = useNpmShell2 && target.prefixArgs.length === 0;
+  return spawnSync2(target.command, [...target.prefixArgs, ...args], {
+    encoding: "utf8",
+    env: process.env,
+    shell: useShell,
+    windowsHide: useNpmShell2,
+    ...options
+  });
 }
-function isProjectLibJar(jarName) {
-  return jarName.startsWith("jeecg-");
+function spawnPm2At(binPath, args, options = {}) {
+  return spawnPm2Target(buildPm2SpawnTarget(binPath), args, options);
 }
-function shouldUploadLibFile(localPath, remoteAttr, manifest, projectRoot) {
-  if (!remoteAttr) {
-    return [false, "\u8FDC\u7A0B\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7"];
-  }
-  const localSize = statSync6(localPath).size;
-  const remoteSize = remoteAttr.size;
-  if (localSize !== remoteSize) {
-    return [true, `\u5927\u5C0F\u53D8\u5316 ${remoteSize} -> ${localSize}`];
+function verifyPm2Bin(pm2Bin) {
+  if (!pm2Bin.trim() || !existsSync13(pm2Bin)) {
+    return false;
   }
-  if (isProjectLibJar(path3.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"];
+  const result = spawnPm2At(pm2Bin, ["--version"], {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return !result.error && result.status === 0;
+}
+function collectPm2Candidates() {
+  const candidates = [];
+  const globalBin = resolveNpmGlobalBin();
+  if (globalBin) {
+    if (useNpmShell2) {
+      candidates.push(join15(globalBin, "pm2.cmd"));
+      candidates.push(join15(globalBin, "pm2"));
+    } else {
+      candidates.push(join15(globalBin, "pm2"));
     }
-    if (previous.mtime < current.mtime) {
-      return [true, "\u9879\u76EE\u6A21\u5757\u91CD\u65B0\u6784\u5EFA"];
+  }
+  const fromRoot = resolvePm2FromNpmRoot();
+  if (fromRoot) {
+    candidates.push(fromRoot);
+  }
+  const whichResult = spawnSync2(useNpmShell2 ? "where" : "which", ["pm2"], {
+    encoding: "utf8",
+    shell: useNpmShell2,
+    env: process.env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (whichResult.status === 0) {
+    const fromPath = whichResult.stdout?.toString().trim().split(/\r?\n/).map((line) => line.trim()).filter(Boolean) ?? [];
+    if (useNpmShell2) {
+      fromPath.sort((a, b) => {
+        const aCmd = a.toLowerCase().endsWith(".cmd") ? 0 : 1;
+        const bCmd = b.toLowerCase().endsWith(".cmd") ? 0 : 1;
+        return aCmd - bCmd;
+      });
     }
+    candidates.push(...fromPath);
   }
-  return [false, "\u5927\u5C0F\u4E00\u81F4\uFF0C\u8DF3\u8FC7"];
+  return candidates;
 }
-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 = path3.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 });
+function findGlobalPm2() {
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of collectPm2Candidates()) {
+    const key = useNpmShell2 ? candidate.toLowerCase() : candidate;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (verifyPm2Bin(candidate)) {
+      return candidate;
     }
   }
-  return entries;
+  return null;
 }
-function updateManifestEntries(manifest, entries, projectRoot) {
-  for (const entry of entries) {
-    manifest[relativeKey(projectRoot, entry.path)] = fileSignature(entry.path);
+function installGlobalPm2() {
+  console.log("[apm] \u672A\u68C0\u6D4B\u5230\u5168\u5C40 pm2\uFF0C\u6B63\u5728\u5B89\u88C5 npm install -g pm2 \u2026");
+  const result = runNpm2(["install", "-g", "pm2"], {
+    encoding: "utf8",
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    console.error("[apm] \u5B89\u88C5 pm2 \u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u6267\u884C: npm install -g pm2");
+    process.exit(result.status ?? 1);
   }
-  return manifest;
 }
-async function createUpdatePackage(entries, packageName) {
-  const dir = deployCacheDir();
-  mkdirSync5(dir, { recursive: true });
-  const zipPath = path3.join(dir, packageName);
-  log(`\u521B\u5EFA\u66F4\u65B0\u5305: ${path3.basename(zipPath)}\uFF08${entries.length} \u4E2A\u6587\u4EF6\uFF09`);
-  const zip = new JSZip2();
-  for (const entry of entries) {
-    const content = readFileSync11(entry.path);
-    zip.file(entry.arcname, content);
-    log(`  \u6253\u5305: ${entry.arcname} (${entry.reason})`);
+function readPm2Version(pm2Bin) {
+  const result = spawnPm2At(pm2Bin, ["--version"], {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.error || result.status !== 0) {
+    return null;
   }
-  const buffer = await zip.generateAsync({
-    type: "nodebuffer",
-    compression: "DEFLATE",
-    compressionOptions: { level: 6 }
+  return result.stdout?.toString().trim() || null;
+}
+function logPm2Ready(pm2Bin, installed2) {
+  const version = readPm2Version(pm2Bin);
+  const versionSuffix = version ? ` ${version}` : "";
+  if (installed2) {
+    console.log(`[apm] \u5168\u5C40 pm2 \u5DF2\u5B89\u88C5${versionSuffix}: ${pm2Bin}`);
+  } else {
+    console.log(`[apm] \u5DF2\u68C0\u6D4B\u5230\u5168\u5C40 pm2${versionSuffix}: ${pm2Bin}`);
+  }
+}
+function isPm2DaemonOutOfDate(output) {
+  return /In-memory PM2 is out-of-date/i.test(output);
+}
+function ensurePm2DaemonUpdated(pm2Bin) {
+  const probe = spawnPm2At(pm2Bin, ["jlist"], {
+    stdio: ["ignore", "pipe", "pipe"]
   });
-  writeFileSync10(zipPath, buffer);
-  return zipPath;
+  const combined = `${probe.stdout ?? ""}
+${probe.stderr ?? ""}`;
+  if (!isPm2DaemonOutOfDate(combined)) {
+    return;
+  }
+  console.log("[apm] \u68C0\u6D4B\u5230 PM2 \u5185\u5B58\u7248\u672C\u4E0E\u672C\u5730\u4E0D\u4E00\u81F4\uFF0C\u6B63\u5728\u6267\u884C pm2 update \u2026");
+  const update = spawnPm2At(pm2Bin, ["update"], {
+    stdio: "inherit"
+  });
+  if (update.error || update.status !== 0) {
+    console.error("[apm] pm2 update \u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u6267\u884C: pm2 update");
+  }
 }
-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 ${name}` : `which ${name}`, {
-      encoding: "utf8",
-      shell: true
-    });
-    if (result.status === 0 && result.stdout.trim()) {
-      return result.stdout.trim().split(/\r?\n/)[0].trim();
+function ensureGlobalPm2(options) {
+  const existing = findGlobalPm2();
+  if (existing) {
+    ensurePm2DaemonUpdated(existing);
+    if (!options?.quiet) {
+      logPm2Ready(existing, false);
     }
+    return existing;
   }
-  fail("\u672A\u627E\u5230 mvn \u547D\u4EE4\uFF0C\u8BF7\u786E\u8BA4 Maven \u5DF2\u5B89\u88C5\u5E76\u52A0\u5165 PATH");
-}
-function runMavenBuild(projectRoot, mavenLocalRepo, repoSource) {
-  const mavenRepo = expandPath(mavenLocalRepo);
-  const mvn = getMvnExecutable();
-  const command = [
-    quoteForShell(mvn),
-    "clean",
-    "package",
-    `-P${MAVEN_PROFILE}`,
-    formatMavenLocalRepoArg(mavenRepo),
-    "-DskipTests"
-  ].join(" ");
-  log("\u5F00\u59CB Maven \u6784\u5EFA...");
-  if (repoSource) {
-    log(
-      `Maven \u672C\u5730\u4ED3\u5E93: ${mavenRepo} (\u6765\u6E90: ${repoSource.source}/${repoSource.sourceDetail})`
+  installGlobalPm2();
+  const installed2 = findGlobalPm2();
+  if (!installed2) {
+    const globalBin = resolveNpmGlobalBin();
+    const moduleEntry = resolvePm2FromNpmRoot();
+    console.error(
+      "[apm] \u5B89\u88C5 pm2 \u540E\u4ECD\u65E0\u6CD5\u627E\u5230\u53EF\u6267\u884C\u6587\u4EF6\uFF0C\u8BF7\u624B\u52A8\u6267\u884C: npm install -g pm2"
     );
-  } else {
-    log(`Maven \u672C\u5730\u4ED3\u5E93: ${mavenRepo}`);
+    if (globalBin) {
+      console.error(`[apm] npm \u5168\u5C40 bin: ${globalBin}`);
+    }
+    if (moduleEntry) {
+      console.error(`[apm] \u5DF2\u68C0\u6D4B\u5230 pm2 \u6A21\u5757: ${moduleEntry}`);
+      console.error(
+        "[apm] \u82E5 pm2 --version \u53EF\u7528\uFF0C\u8BF7\u68C0\u67E5 Node/npm \u5168\u5C40\u5B89\u88C5\u6743\u9650\u6216 PATH"
+      );
+    }
+    process.exit(1);
   }
-  log(`\u6784\u5EFA\u76EE\u5F55: ${projectRoot}`);
-  const result = spawnSync2(command, {
-    cwd: projectRoot,
-    stdio: "inherit",
-    shell: true,
-    env: process.env
-  });
-  if (result.status !== 0) {
-    fail(`Maven \u6784\u5EFA\u5931\u8D25\uFF0C\u9000\u51FA\u7801: ${result.status ?? 1}`);
+  ensurePm2DaemonUpdated(installed2);
+  if (!options?.quiet) {
+    logPm2Ready(installed2, true);
   }
+  return installed2;
 }
-function locateLibDir(projectRoot) {
-  const targetDir = getTargetDir(projectRoot);
-  if (!existsSync12(targetDir)) {
-    fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
+function resolveApmEntryPath(entryArg = process.argv[1]) {
+  const fromArgv = entryArg?.trim();
+  if (fromArgv && existsSync13(fromArgv)) {
+    return fromArgv;
   }
-  const libDir = path3.join(targetDir, "lib");
-  if (!existsSync12(libDir) || !statSync6(libDir).isDirectory()) {
-    fail(`lib \u76EE\u5F55\u4E0D\u5B58\u5728: ${libDir}`);
+  const npmResult = spawnSync2(useNpmShell2 ? "npm.cmd" : "npm", ["root", "-g"], {
+    encoding: "utf8",
+    shell: useNpmShell2,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (npmResult.status === 0) {
+    const globalRoot = npmResult.stdout?.toString().trim();
+    if (globalRoot) {
+      const candidate = join15(globalRoot, CLI_PACKAGE_NAME, "dist", "index.js");
+      if (existsSync13(candidate)) {
+        return candidate;
+      }
+    }
   }
-  const libJars = readdirSync5(libDir).filter((name) => name.endsWith(".jar"));
-  if (libJars.length === 0) {
-    fail(`lib \u76EE\u5F55\u4E0B\u6CA1\u6709\u4F9D\u8D56 JAR: ${libDir}`);
+  if (fromArgv) {
+    return fromArgv;
   }
-  log(`\u5B9A\u4F4D lib \u4EA7\u7269: ${libJars.length} \u4E2A`);
-  return libDir;
+  console.error("[apm] \u65E0\u6CD5\u89E3\u6790 apm \u5165\u53E3\u8DEF\u5F84");
+  process.exit(1);
 }
-function locateMainJar(projectRoot) {
-  const targetDir = getTargetDir(projectRoot);
-  if (!existsSync12(targetDir)) {
-    fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
+function isRunningUnderPm2() {
+  if (process.env.APM_CONNECT_UNDER_PM2 === "1") {
+    return true;
   }
-  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}`);
+  if (process.env.pm_id === void 0) {
+    return false;
   }
-  const mainJar = jarFiles[0];
-  log(`\u5B9A\u4F4D\u4E3B JAR \u4EA7\u7269: ${path3.basename(mainJar)}`);
-  return mainJar;
+  const name = process.env.name;
+  return name === PM2_APP_NAME || name !== void 0 && LEGACY_PM2_APP_NAMES.includes(name);
 }
-async function connectSsh(config) {
-  const client = new Client2();
-  log(`\u8FDE\u63A5\u670D\u52A1\u5668 ${config.username}@${config.host}:${config.port}`);
-  await new Promise((resolve5, reject) => {
-    client.on("ready", () => resolve5()).on("error", (err) => reject(err)).connect({
-      host: config.host,
-      port: config.port,
-      username: config.username,
-      password: config.password,
-      readyTimeout: 3e4,
-      tryKeyboard: true
-    });
-  });
-  const sftp = new SftpClient2();
-  await sftp.connect({
-    host: config.host,
-    port: config.port,
-    username: config.username,
-    password: config.password,
-    readyTimeout: 3e4,
-    tryKeyboard: true
-  });
-  return { client, sftp };
+function isConnectPm2Process(app) {
+  if (app.name === PM2_APP_NAME) {
+    return true;
+  }
+  return app.name !== void 0 && LEGACY_PM2_APP_NAMES.includes(app.name);
 }
-async function closeSsh(conn) {
+function listPm2Processes() {
   try {
-    await conn.sftp.end();
+    const raw = runPm2Json(["jlist"]);
+    return JSON.parse(raw);
   } catch {
+    return [];
   }
-  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 {
+function findPm2ConnectProcess() {
+  return listPm2Processes().find(isConnectPm2Process) ?? null;
+}
+function resolvePm2ConnectName(app) {
+  return app?.name ?? PM2_APP_NAME;
+}
+function deletePm2AppIfExists(name) {
+  const pm2Bin = findGlobalPm2();
+  if (!pm2Bin) {
+    return;
   }
-  return stats;
+  ensurePm2DaemonUpdated(pm2Bin);
+  spawnPm2At(pm2Bin, ["delete", name], {
+    stdio: "ignore"
+  });
 }
-async function uploadUpdatePackage(sftp, zipPath, config) {
-  const remoteDir = config.remoteVueDistDir.replace(/\/$/, "");
-  const remotePath = `${remoteDir}/${path3.basename(zipPath)}`;
-  log(`\u4E0A\u4F20\u66F4\u65B0\u5305 -> ${remotePath}`);
-  try {
-    await sftp.fastPut(zipPath, remotePath);
-    log("\u66F4\u65B0\u5305\u4E0A\u4F20\u6210\u529F");
-  } catch (err) {
-    fail(`\u66F4\u65B0\u5305\u4E0A\u4F20\u5931\u8D25: ${err instanceof Error ? err.message : err}`);
+function removePm2ConnectProcesses() {
+  const seen = /* @__PURE__ */ new Set();
+  for (const app of listPm2Processes()) {
+    if (!isConnectPm2Process(app) || !app.name || seen.has(app.name)) {
+      continue;
+    }
+    seen.add(app.name);
+    deletePm2AppIfExists(app.name);
   }
-  return remotePath;
+  for (const legacyName of LEGACY_PM2_APP_NAMES) {
+    deletePm2AppIfExists(legacyName);
+  }
+  deletePm2AppIfExists(PM2_APP_NAME);
 }
-async function uploadFullJar(sftp, localJarPath, config) {
-  const remoteDir = config.remoteAppDir.replace(/\/$/, "");
-  const remotePath = `${remoteDir}/${config.startupJar}`;
-  log(`\u4E0A\u4F20\u5168\u91CF JAR (${path3.basename(localJarPath)}) -> ${remotePath}`);
-  try {
-    await sftp.mkdir(remoteDir, true);
-    await sftp.fastPut(localJarPath, remotePath);
-    log("\u5168\u91CF JAR \u4E0A\u4F20\u6210\u529F");
-  } catch (err) {
-    fail(`\u5168\u91CF JAR \u4E0A\u4F20\u5931\u8D25: ${err instanceof Error ? err.message : err}`);
+function runPm2(args, options) {
+  const pm2Bin = ensureGlobalPm2({ quiet: true });
+  const result = spawnPm2At(pm2Bin, args, {
+    stdio: options?.inherit ? "inherit" : ["ignore", "pipe", "pipe"]
+  });
+  if (result.error) {
+    console.error("[apm] \u6267\u884C pm2 \u5931\u8D25:", result.error.message);
+    process.exit(1);
+  }
+  if (result.status !== 0) {
+    const stderr = result.stderr?.toString().trim();
+    const stdout = result.stdout?.toString().trim();
+    const detail = stderr || stdout || `exit code ${result.status}`;
+    console.error(`[apm] pm2 ${args.join(" ")} \u5931\u8D25: ${detail}`);
+    process.exit(result.status ?? 1);
   }
 }
-async function runRemoteCommand(client, command, options) {
-  const check = options?.check ?? true;
-  const stream = options?.stream ?? false;
-  const label = options?.label ?? "\u8FDC\u7A0B\u547D\u4EE4";
-  return new Promise((resolve5, reject) => {
-    client.exec(command, (err, execStream) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      let out = "";
-      let errText = "";
-      execStream.on("data", (data) => {
-        const text = data.toString();
-        out += text;
-        if (stream) {
-          process.stdout.write(text);
-        }
-      });
-      execStream.stderr.on("data", (data) => {
-        errText += data.toString();
-      });
-      execStream.on("close", (code) => {
-        if (stream && out && !out.endsWith("\n")) {
-          process.stdout.write("\n");
-        }
-        if (check && code !== 0) {
-          const combined = `${out}
-${errText}`.trim();
-          fail(
-            `${label}\u5931\u8D25 (exit ${code})` + (combined ? `
-\u8F93\u51FA: ${combined}` : "")
-          );
-        }
-        resolve5({ exitCode: code, out: out.trim(), err: errText.trim() });
-      });
-    });
+function runPm2Json(args) {
+  const pm2Bin = findGlobalPm2();
+  if (!pm2Bin) {
+    return "[]";
+  }
+  ensurePm2DaemonUpdated(pm2Bin);
+  const result = spawnPm2At(pm2Bin, args, {
+    stdio: ["ignore", "pipe", "pipe"]
   });
+  if (result.status !== 0) return "[]";
+  return result.stdout?.toString() ?? "[]";
 }
-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();
+function isPm2ConnectOnline() {
+  const app = findPm2ConnectProcess();
+  if (!app) return false;
+  const status = app.pm2_env?.status;
+  return status === "online" || status === "launching";
 }
-async function extractUpdatePackageOnRemote(client, config, remoteZipPath) {
-  const script = buildExtractUpdatePackageScript(
-    remoteZipPath,
-    config.remoteLibDir
-  );
-  const { out } = await runRemoteCommand(client, script, {
-    label: "\u8FDC\u7A0B\u89E3\u538B"
-  });
-  const match = out.match(/UPDATED_COUNT=(\d+)/);
-  if (!match) {
-    fail(`\u8FDC\u7A0B\u89E3\u538B\u5931\u8D25\uFF0C\u672A\u83B7\u53D6\u66F4\u65B0\u6570\u91CF
-\u8F93\u51FA: ${out || "(\u7A7A)"}`);
+function printConnectNotRunningHint() {
+  console.log(`[apm] ${PM2_APP_NAME} \u672A\u5728\u8FD0\u884C`);
+  console.log("[apm] \u542F\u52A8\u5B88\u62A4: apm connect --daemon");
+}
+function assertConnectNotRunning() {
+  pruneStaleConnectLock();
+  const lock = readConnectLock();
+  if (lock && isProcessAlive(lock.pid) && lock.pid !== process.pid) {
+    console.error(
+      `[apm] \u5DF2\u6709 apm connect \u5728\u8FD0\u884C (pid=${lock.pid}, mode=${lock.mode})\uFF0C\u8BF7\u5148\u505C\u6B62\u540E\u518D\u542F\u52A8`
+    );
+    process.exit(1);
+  }
+  if (!isRunningUnderPm2() && isPm2ConnectOnline()) {
+    console.error(
+      "[apm] \u5DF2\u6709 apm connect \u5B88\u62A4\u8FDB\u7A0B\u5728\u8FD0\u884C\uFF0C\u8BF7\u5148\u6267\u884C apm daemon stop"
+    );
+    process.exit(1);
   }
-  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");
+function resolveRuntimePaths() {
+  return {
+    apmScript: resolveApmEntryPath(),
+    nodePath: process.execPath
+  };
+}
+function reexecConnectWithResolvedPath(options) {
+  const apmScript = resolveApmEntryPath();
+  const args = [apmScript, "connect"];
+  const server = options.server?.trim();
+  if (server) {
+    args.push("--server", server);
   }
-  if (action === "start" || action === "restart") {
-    return combined.includes("is starting") || lower.includes("is running");
+  const result = spawnSync2(process.execPath, args, { stdio: "inherit" });
+  if (result.error) {
+    console.error("[apm] \u91CD\u542F connect \u5931\u8D25:", result.error.message);
+    process.exit(1);
   }
-  if (action === "stop") {
-    return combined.includes("is stopping") || lower.includes("not running") || lower.includes("please check it");
+  process.exit(result.status ?? 0);
+}
+async function handleConnectAfterUpdate(options) {
+  console.log("[apm] \u66F4\u65B0\u5B8C\u6210\uFF0C\u6B63\u5728\u4EE5\u65B0\u7248\u672C\u91CD\u65B0\u8FDE\u63A5\u2026");
+  await prepareEcosystem(options.server);
+  if (isRunningUnderPm2()) {
+    runPm2(["reload", PM2_ECOSYSTEM_PATH, "--update-env"], { inherit: true });
+    console.log("[apm] \u5DF2\u901A\u77E5 PM2 \u4F7F\u7528\u65B0\u7248\u672C\u91CD\u65B0\u52A0\u8F7D connect");
+    process.exit(0);
   }
-  if (action === "status") {
-    return lower.includes("running") || lower.includes("not running");
+  reexecConnectWithResolvedPath(options);
+}
+async function resolveBaseUrl(server) {
+  if (server?.trim()) {
+    return server.trim().replace(/\/+$/, "");
   }
-  return true;
+  const cfg = await tryReadApmConfig();
+  return cfg?.baseUrl;
 }
-function buildRemoteStatusScript(remoteAppDir, appName) {
-  const dir = shellSingleQuote(remoteAppDir);
-  const jar = shellSingleQuote(appName);
-  return `
-set -e
-cd ${dir}
-appName=${jar}
-appIds=$(ps -ef | grep java | grep "$appName" | awk '{print $2}')
-if [ -z "$appIds" ]; then
-  echo -e "\\033[31m Not running \\033[0m"
-else
-  echo -e "\\033[32m Running [$appIds] \\033[0m"
-fi
-`.trim();
-}
-function buildRemoteRestartScript(remoteAppDir) {
-  const dir = shellSingleQuote(remoteAppDir);
-  const javaOpts = shellSingleQuote(SPRINGBOOT_JAVA_OPTS);
-  return `
-set -e
-cd ${dir}
-releaseApp=$(ls -t | grep '.jar$' | head -n1)
-lastVersionApp=$(ls -t | grep '.jar$' | head -n2 | tail -n1)
-appName=$lastVersionApp
-appIds=$(ps -ef | grep java | grep "$appName" | awk '{print $2}')
-if [ -z "$appIds" ]; then
-  echo "Maybe $appName not running, please check it..."
-else
-  echo "The $appName is stopping..."
-  echo "$appIds" | xargs kill
-fi
-for i in $(seq 15 -1 1); do
-  echo -n "$i "
-  sleep 1
-done
-echo 0
-if [ ! -d "backup" ]; then
-  mkdir backup
-fi
-for i in $(ls | grep '.jar$' | grep -vFx "$releaseApp"); do
-  echo "backup $i"
-  mv "$i" backup/
-done
-appName=$releaseApp
-count=$(ps -ef | grep java | grep "$appName" | wc -l)
-if [ "$count" != "0" ]; then
-  echo "Maybe $appName is running, please check it..."
-else
-  echo "The $appName is starting..."
-  nohup java -jar "./$appName" ${javaOpts} > nohup.out 2>&1 &
-fi
-`.trim();
-}
-function normalizeHealthContext(context) {
-  let normalized = context.trim() || "/";
-  if (!normalized.startsWith("/")) {
-    normalized = `/${normalized}`;
-  }
-  if (!normalized.endsWith("/")) {
-    normalized = `${normalized}/`;
+function writeConnectLaunchFiles(options) {
+  mkdirSync6(APM_CONFIG_DIR, { recursive: true });
+  writeFileSync11(PM2_CONNECT_ENTRY_PATH, CONNECT_ENTRY_SCRIPT, "utf8");
+  const env = {
+    ...collectPm2LaunchEnv()
+  };
+  const baseUrl = options.baseUrl?.trim().replace(/\/+$/, "");
+  if (baseUrl) {
+    env.AI_PM_SERVER = baseUrl;
   }
-  return normalized;
-}
-function buildRemoteHealthScript(port, context, timeoutSecs) {
-  const normalizedContext = normalizeHealthContext(context);
-  const portStr = String(port);
-  const timeoutStr = String(timeoutSecs);
-  return `
-set -e
-port=${shellSingleQuote(portStr)}
-context=${shellSingleQuote(normalizedContext)}
-timeout=${shellSingleQuote(timeoutStr)}
-check_url="http://127.0.0.1:${portStr}${normalizedContext}"
-echo "\u5065\u5EB7\u68C0\u67E5: \${check_url} (\u8D85\u65F6 \${timeout}s)"
-deadline=$(($(date +%s) + timeout))
-attempt=0
-while [ $(date +%s) -lt $deadline ]; do
-  attempt=$((attempt + 1))
-  code=$(curl -s -o /dev/null -w "%{http_code}" "$check_url" 2>/dev/null || echo "000")
-  code=$(echo "$code" | tail -n1 | tr -d '[:space:]')
-  if [ \${#code} -ge 3 ]; then
-    status=\${code:0:3}
-    if echo "$status" | grep -qE '^[0-9]+$' && [ "$status" -ge 200 ] && [ "$status" -lt 500 ]; then
-      echo -e "\\033[32m\u5065\u5EB7\u68C0\u67E5\u901A\u8FC7 (HTTP \${status})\\033[0m"
-      exit 0
-    fi
-  fi
-  remaining=$((deadline - $(date +%s)))
-  if [ $remaining -lt 0 ]; then
-    remaining=0
-  fi
-  echo "\u7B49\u5F85\u670D\u52A1\u542F\u52A8... \u7B2C \${attempt} \u6B21\uFF0C\u5269\u4F59 \${remaining}s"
-  sleep 5
-done
-echo -e "\\033[31m\u5065\u5EB7\u68C0\u67E5\u8D85\u65F6 (\${timeout}s): \${check_url}\\033[0m"
-exit 1
-`.trim();
+  const launch = {
+    nodePath: options.nodePath,
+    apmScript: options.apmScript,
+    connectArgs: options.connectArgs,
+    cwd: options.cwd,
+    env
+  };
+  writeFileSync11(
+    PM2_CONNECT_LAUNCH_PATH,
+    JSON.stringify(launch, null, 2) + "\n",
+    "utf8"
+  );
 }
-async function runRemoteServiceScript(client, script, action) {
-  const { exitCode, out, err } = await runRemoteCommand(client, script, {
-    check: false,
-    label: action === "status" ? "\u8FDC\u7A0B status" : action === "restart" ? "\u8FDC\u7A0B restart" : "\u5065\u5EB7\u68C0\u67E5"
+function writeEcosystemFile(options) {
+  writeConnectLaunchFiles(options);
+  const ecosystem = buildConnectPm2Ecosystem({
+    entryScript: PM2_CONNECT_ENTRY_PATH,
+    baseUrl: options.baseUrl
   });
-  const combined = `${out}
-${err}`.trim();
-  const outputOk = springbootOutputIndicatesSuccess(action, combined);
-  if (action === "health") {
-    if (exitCode !== 0 || !outputOk) {
-      fail(`\u5065\u5EB7\u68C0\u67E5\u5931\u8D25
-\u8F93\u51FA: ${combined || "(\u7A7A)"}`);
-    }
-    return combined;
-  }
-  if (exitCode !== 0 && !outputOk) {
-    fail(`\u8FDC\u7A0B ${action} \u5931\u8D25
-${combined}`);
-  }
-  if (action === "restart" && !outputOk) {
-    fail(`\u8FDC\u7A0B restart \u672A\u6210\u529F
-\u8F93\u51FA: ${combined || "(\u7A7A)"}`);
-  }
-  return combined;
-}
-function stripAnsi(text) {
-  return text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "");
-}
-async function getRunningJar(client, config) {
-  const script = buildRemoteStatusScript(
-    config.remoteAppDir,
-    config.startupJar
+  writeFileSync11(
+    PM2_ECOSYSTEM_PATH,
+    formatConnectPm2EcosystemFile(ecosystem),
+    "utf8"
   );
-  const combined = await runRemoteServiceScript(client, script, "status");
-  const text = stripAnsi(combined).trim().toLowerCase();
-  if (text.includes("not running")) {
-    return null;
-  }
-  if (text.includes("running")) {
-    return config.startupJar;
+  if (existsSync13(LEGACY_PM2_ECOSYSTEM_PATH)) {
+    try {
+      unlinkSync2(LEGACY_PM2_ECOSYSTEM_PATH);
+    } catch {
+    }
   }
-  return null;
-}
-async function healthCheckService(client, config) {
-  log("\u5065\u5EB7\u68C0\u67E5...");
-  const script = buildRemoteHealthScript(
-    config.healthCheckPort,
-    config.healthCheckContext,
-    config.healthCheckTimeout
-  );
-  await runRemoteServiceScript(client, script, "health");
 }
-async function restartRemoteService(client, config) {
-  const script = buildRemoteRestartScript(config.remoteAppDir);
-  await runRemoteServiceScript(client, script, "restart");
-}
-function listAllLibFilesForArchive(libDir) {
-  return readdirSync5(libDir).filter((name) => name.endsWith(".jar")).sort().map((jarName) => ({
-    path: path3.join(libDir, jarName),
-    arcname: jarName,
-    reason: "\u4EC5\u6253\u5305\u5F52\u6863"
-  }));
-}
-async function runWisdomBackendDeploy(options) {
-  const projectRoot = path3.resolve(options.projectRoot ?? process.cwd());
-  const config = options.config;
-  const packOnly = Boolean(options.packOnly);
-  log(`=== \u81EA\u52A8\u90E8\u7F72: ${config.projectName} ===`);
-  log(`\u914D\u7F6E\u6587\u4EF6: ${path3.join(workspaceApmDir(), "apm.config.json")}`);
-  log(`\u9879\u76EE\u6839\u76EE\u5F55: ${projectRoot}`);
-  log(
-    `\u90E8\u7F72\u6A21\u5F0F: ${config.mode}${config.mode === "full" ? "\uFF08\u5168\u91CF JAR\uFF0C\u8DF3\u8FC7 lib \u68C0\u67E5\uFF09" : "\uFF08\u589E\u91CF lib \u66F4\u65B0\uFF09"}${packOnly ? "\uFF1B\u4EC5\u6253\u5305\uFF08\u4E0D\u4E0A\u4F20\u8FDC\u7A0B\uFF09" : ""}`
-  );
-  runMavenBuild(projectRoot, config.mavenLocalRepo, {
-    source: config.mavenLocalRepoSource,
-    sourceDetail: config.mavenLocalRepoSourceDetail
+async function prepareEcosystem(server) {
+  await ensureLoggedConfig();
+  const cfg = await ensureApmConfig();
+  const { apmScript, nodePath } = resolveRuntimePaths();
+  const connectArgs = resolveConnectArgs(server);
+  const baseUrl = await resolveBaseUrl(server);
+  writeEcosystemFile({
+    apmScript,
+    nodePath,
+    connectArgs,
+    baseUrl,
+    cwd: process.cwd()
   });
-  if (packOnly) {
-    const uploadWithoutRunId = !resolveDeploymentRunIdFromEnv();
-    if (config.mode === "full") {
-      const mainJar = locateMainJar(projectRoot);
-      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",
-        uploadWithoutRunId
-      });
-    } else {
-      const libDir = locateLibDir(projectRoot);
-      const entries = listAllLibFilesForArchive(libDir);
-      if (entries.length === 0) {
-        fail("lib \u76EE\u5F55\u4E0B\u6CA1\u6709\u53EF\u5F52\u6863\u7684 JAR");
-      }
-      const zipPath = await createUpdatePackage(entries, config.packageName);
-      await uploadDeployArtifactZip({
-        zipPath,
-        projectName: config.projectName,
-        kind: "backend",
-        uploadWithoutRunId
-      });
-    }
-    log("\u4EC5\u6253\u5305\u5B8C\u6210\uFF08\u672A\u4E0A\u4F20\u8FDC\u7A0B\u670D\u52A1\u5668\uFF09");
-    return;
-  }
-  const conn = await connectSsh(config);
-  try {
-    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);
-      log("\u90E8\u7F72\u5B8C\u6210");
-      return;
-    }
-    const libDir = locateLibDir(projectRoot);
-    let manifest = loadManifest3();
-    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
-      );
-      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,
-        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 restartRemoteService(conn.client, config);
-    }
-    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");
+  return cfg;
 }
-
-// src/commands/deploy/internal/deploy-shell-env.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
-import { dirname as dirname4 } from "node:path";
-
-// src/commands/daemon.ts
-import { spawnSync as spawnSync3 } from "child_process";
-import { setTimeout as delay } from "node:timers/promises";
-import { existsSync as existsSync14, mkdirSync as mkdirSync7, unlinkSync as unlinkSync2, writeFileSync as writeFileSync12 } from "fs";
-import { join as join15 } from "path";
-
-// src/commands/connect-lock.ts
-import {
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync12,
-  unlinkSync,
-  writeFileSync as writeFileSync11
-} from "fs";
-import { join as join14 } from "path";
-var CONNECT_LOCK_PATH = join14(APM_CONFIG_DIR, "connect.lock");
-function isProcessAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
+async function runDaemonStart(options) {
+  assertConnectNotRunning();
+  await runUpdate();
+  ensureGlobalPm2();
+  const cfg = await prepareEcosystem(options.server);
+  removePm2ConnectProcesses();
+  runPm2(["start", PM2_ECOSYSTEM_PATH, "--update-env"], { inherit: true });
+  await delay2(1e3);
+  if (!isPm2ConnectOnline()) {
+    console.error(
+      `[apm] ${PM2_APP_NAME} \u542F\u52A8\u540E\u672A\u5904\u4E8E online \u72B6\u6001\uFF0C\u8BF7\u6267\u884C: apm daemon logs -n 200`
+    );
   }
-}
-function sleepSync(ms) {
-  const deadline = Date.now() + ms;
-  while (Date.now() < deadline) {
+  console.log(
+    `[apm] ${PM2_APP_NAME} \u5DF2\u7531 PM2 \u542F\u52A8\uFF08server=${options.server?.trim() || cfg.baseUrl}\uFF09`
+  );
+  if (options.follow) {
+    console.log(
+      "[apm] \u6B63\u5728\u8DDF\u8E2A\u65E5\u5FD7\uFF08Ctrl+C \u4EC5\u9000\u51FA\u65E5\u5FD7\u67E5\u770B\uFF0C\u5B88\u62A4\u8FDB\u7A0B\u7EE7\u7EED\u8FD0\u884C\uFF09"
+    );
+    runDaemonLogs({ follow: true });
+    return;
   }
+  console.log("[apm] \u67E5\u770B\u72B6\u6001: apm daemon status");
+  console.log("[apm] \u67E5\u770B\u65E5\u5FD7: apm daemon logs -f");
+  console.log("[apm] \u505C\u6B62: apm daemon stop");
 }
-function waitForPm2LockHandoff(timeoutMs = 5e3) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    pruneStaleConnectLock();
-    const lock = readConnectLock();
-    if (!lock || lock.mode !== "pm2" || lock.pid === process.pid || !isProcessAlive(lock.pid)) {
-      return;
-    }
-    sleepSync(100);
+async function runDaemonStop() {
+  pruneStaleConnectLock();
+  if (!isPm2ConnectOnline()) {
+    killConnectLockProcessIfAlive();
+    forceReleaseConnectLock();
+    console.log(`[apm] ${PM2_APP_NAME} \u672A\u5728\u8FD0\u884C`);
+    return;
   }
-}
-function readConnectLock() {
-  if (!existsSync13(CONNECT_LOCK_PATH)) return null;
-  try {
-    const raw = readFileSync12(CONNECT_LOCK_PATH, "utf8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed.pid !== "number" || parsed.mode !== "foreground" && parsed.mode !== "pm2" || typeof parsed.startedAt !== "string") {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
+  runPm2(["stop", resolvePm2ConnectName(findPm2ConnectProcess())], {
+    inherit: true
+  });
+  for (let i = 0; i < 10; i += 1) {
+    if (!isPm2ConnectOnline()) break;
+    await delay2(500);
+  }
+  if (isPm2ConnectOnline()) {
+    console.log(`[apm] \u4F18\u96C5\u505C\u6B62\u8D85\u65F6\uFF0C\u5F3A\u5236\u79FB\u9664 ${PM2_APP_NAME}\u2026`);
+    runPm2(["delete", resolvePm2ConnectName(findPm2ConnectProcess())], {
+      inherit: true
+    });
   }
+  killConnectLockProcessIfAlive();
+  forceReleaseConnectLock();
+  console.log(`[apm] ${PM2_APP_NAME} \u5DF2\u505C\u6B62`);
 }
-function pruneStaleConnectLock() {
+function killConnectLockProcessIfAlive() {
+  pruneStaleConnectLock();
   const lock = readConnectLock();
-  if (!lock) return;
-  if (isProcessAlive(lock.pid)) return;
+  if (!lock || !isProcessAlive(lock.pid)) return;
   try {
-    unlinkSync(CONNECT_LOCK_PATH);
+    process.kill(lock.pid, "SIGTERM");
   } catch {
+    forceReleaseConnectLock();
+    return;
   }
-}
-function acquireConnectLock(mode) {
-  pruneStaleConnectLock();
-  const existing = readConnectLock();
-  if (existing && isProcessAlive(existing.pid)) {
-    if (existing.pid === process.pid) {
-      return;
-    }
-    if (mode === "pm2" && existing.mode === "pm2") {
-      forceReleaseConnectLock();
-    } else {
-      console.error(
-        `[apm] \u5DF2\u6709 apm connect \u5728\u8FD0\u884C (pid=${existing.pid}, mode=${existing.mode})`
-      );
-      process.exit(1);
+  if (isProcessAlive(lock.pid)) {
+    try {
+      process.kill(lock.pid, "SIGKILL");
+    } catch {
     }
   }
-  mkdirSync6(APM_CONFIG_DIR, { recursive: true });
-  const lock = {
-    pid: process.pid,
-    mode,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  writeFileSync11(
-    CONNECT_LOCK_PATH,
-    JSON.stringify(lock, null, 2) + "\n",
-    "utf8"
-  );
+  forceReleaseConnectLock();
 }
-function releaseConnectLock() {
+async function runDaemonRestart(options) {
+  pruneStaleConnectLock();
   const lock = readConnectLock();
-  if (lock?.pid !== process.pid) return;
-  try {
-    unlinkSync(CONNECT_LOCK_PATH);
-  } catch {
+  if (lock && isProcessAlive(lock.pid) && !isPm2ConnectOnline()) {
+    console.error(
+      `[apm] \u5DF2\u6709\u524D\u53F0 apm connect \u5728\u8FD0\u884C (pid=${lock.pid})\uFF0C\u8BF7\u5148\u505C\u6B62\u540E\u518D\u542F\u52A8\u5B88\u62A4\u8FDB\u7A0B`
+    );
+    process.exit(1);
   }
+  await runUpdate();
+  await prepareEcosystem(options.server);
+  removePm2ConnectProcesses();
+  runPm2(["start", PM2_ECOSYSTEM_PATH, "--update-env"], { inherit: true });
+  console.log(`[apm] ${PM2_APP_NAME} \u5DF2\u91CD\u542F`);
 }
-function forceReleaseConnectLock() {
-  try {
-    if (existsSync13(CONNECT_LOCK_PATH)) {
-      unlinkSync(CONNECT_LOCK_PATH);
-    }
-  } catch {
+async function runDaemonDelete() {
+  ensureGlobalPm2();
+  const app = findPm2ConnectProcess();
+  if (!app?.name) {
+    console.log(`[apm] ${PM2_APP_NAME} \u672A\u5728 PM2 \u4E2D\u6CE8\u518C`);
+    return;
   }
+  runPm2(["delete", app.name], { inherit: true });
+  forceReleaseConnectLock();
+  console.log(`[apm] ${app.name} \u5DF2\u4ECE PM2 \u79FB\u9664`);
 }
-
-// src/commands/daemon.ts
-var PM2_APP_NAME = "apm-connect";
-var PM2_ECOSYSTEM_PATH = join15(
-  APM_CONFIG_DIR,
-  "connect.ecosystem.config.cjs"
-);
-var PM2_CONNECT_ENTRY_PATH = join15(APM_CONFIG_DIR, "connect.entry.cjs");
-var PM2_CONNECT_LAUNCH_PATH = join15(
-  APM_CONFIG_DIR,
-  "connect.launch.json"
-);
-var LEGACY_PM2_ECOSYSTEM_PATH = join15(
-  APM_CONFIG_DIR,
-  "connect.ecosystem.cjs"
-);
-var LEGACY_PM2_APP_NAMES = ["connect.ecosystem"];
-var CONNECT_ENTRY_SCRIPT = `'use strict';
-const { spawnSync } = require('node:child_process');
-const { readFileSync } = require('node:fs');
-const { join } = require('node:path');
-
-const launchConfigPath = join(__dirname, 'connect.launch.json');
-let config;
-try {
-  config = JSON.parse(readFileSync(launchConfigPath, 'utf8'));
-} catch (err) {
-  console.error('[apm] \u65E0\u6CD5\u8BFB\u53D6 connect.launch.json:', err instanceof Error ? err.message : err);
-  process.exit(1);
+async function runDaemonStatus() {
+  ensureGlobalPm2();
+  const app = findPm2ConnectProcess();
+  if (!app?.name) {
+    printConnectNotRunningHint();
+    return;
+  }
+  runPm2(["describe", app.name], { inherit: true });
 }
-
-const nodeArgs = [config.apmScript, ...(config.connectArgs || [])];
-const childEnv = {
-  ...process.env,
-  ...(config.env || {}),
-  APM_CONNECT_UNDER_PM2: '1',
-};
-
-const result = spawnSync(config.nodePath, nodeArgs, {
-  cwd: config.cwd || undefined,
-  env: childEnv,
-  stdio: 'inherit',
-  windowsHide: true,
-});
-
-if (result.error) {
-  console.error('[apm] connect \u542F\u52A8\u5931\u8D25:', result.error.message);
-  process.exit(1);
+async function runDaemonLogs(options) {
+  ensureGlobalPm2();
+  const app = findPm2ConnectProcess();
+  if (!app?.name) {
+    printConnectNotRunningHint();
+    return;
+  }
+  const args = ["logs", app.name, "--lines", String(options.lines ?? 100)];
+  if (!options.follow) {
+    args.push("--nostream");
+  }
+  runPm2(args, { inherit: true });
 }
-process.exit(result.status ?? 0);
-`;
-function resolveConnectArgs(server) {
-  const args = ["connect"];
-  const trimmed = server?.trim();
-  if (trimmed) {
-    args.push("--server", trimmed.replace(/\/+$/, ""));
+
+// src/commands/deploy/internal/deploy-shell-env.ts
+var PATH_SEP = process.platform === "win32" ? ";" : ":";
+var useNpmShell3 = process.platform === "win32";
+function resolveNpmGlobalBin2() {
+  const result = spawnSync3(useNpmShell3 ? "npm.cmd" : "npm", ["bin", "-g"], {
+    encoding: "utf8",
+    shell: useNpmShell3,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.status !== 0) {
+    return null;
   }
-  return args;
+  const bin = result.stdout?.toString().trim();
+  return bin || null;
 }
-var PM2_LAUNCH_ENV_KEYS = [
-  "PATH",
-  "HOME",
-  "USER",
-  "SHELL",
-  "LANG",
-  "LC_ALL",
-  "LC_CTYPE",
-  "NVM_DIR",
-  "NVM_BIN",
-  "NVM_INC",
-  "FNM_DIR",
-  "VOLTA_HOME",
-  "PNPM_HOME",
-  "npm_config_prefix",
-  "NODE_HOME"
-];
-function collectPm2LaunchEnv() {
-  const env = {};
-  for (const key of PM2_LAUNCH_ENV_KEYS) {
-    const value = process.env[key]?.trim();
-    if (value) {
-      env[key] = value;
-    }
+function prependPath(pathValue, segment) {
+  if (!segment) {
+    return pathValue ?? "";
+  }
+  if (!pathValue) {
+    return segment;
+  }
+  const segments = pathValue.split(PATH_SEP);
+  if (segments.includes(segment)) {
+    return pathValue;
   }
-  return env;
+  return `${segment}${PATH_SEP}${pathValue}`;
 }
-function buildConnectPm2Ecosystem(options) {
-  const env = {};
-  const baseUrl = options.baseUrl?.trim().replace(/\/+$/, "");
-  if (baseUrl) {
-    env.AI_PM_SERVER = baseUrl;
+function buildDeployShellEnv(extra) {
+  const env = { ...process.env, ...extra };
+  const pathSegments = [dirname4(process.execPath)];
+  const globalBin = resolveNpmGlobalBin2();
+  if (globalBin) {
+    pathSegments.push(globalBin);
   }
-  const app = {
-    name: PM2_APP_NAME,
-    script: options.entryScript,
-    cwd: APM_CONFIG_DIR,
-    autorestart: true,
-    min_uptime: "10s",
-    max_restarts: 10,
-    restart_delay: 3e3,
-    exp_backoff_restart_delay: 1e3,
-    max_memory_restart: "1G",
-    kill_timeout: 5e3,
-    shutdown_with_message: true,
-    instances: 1,
-    exec_mode: "fork",
-    env
-  };
-  if (process.platform === "win32") {
-    app.windowsHide = true;
+  try {
+    resolveApmEntryPath();
+  } catch {
   }
-  return {
-    apps: [app]
-  };
+  for (const segment of pathSegments) {
+    env.PATH = prependPath(env.PATH, segment);
+  }
+  return env;
 }
-function formatConnectPm2EcosystemFile(ecosystem) {
-  return `module.exports = ${JSON.stringify(ecosystem, null, 2)};
-`;
+
+// src/commands/deploy/deploy-debug-log.ts
+var LOG_PREFIX = "[apm:deploy-debug]";
+var SENSITIVE_ENV_KEY = /(password|secret|token|api[_-]?key|authorization|credential|private|passwd)/i;
+var PATH_SEP2 = process.platform === "win32" ? ";" : ":";
+function logLine(message) {
+  console.error(`${LOG_PREFIX} ${message}`);
+}
+function pathEntries(value) {
+  if (!value?.trim()) return [];
+  return value.split(PATH_SEP2).filter(Boolean);
+}
+function summarizePath(value, maxEntries = 12) {
+  const entries = pathEntries(value);
+  if (entries.length === 0) return "(empty)";
+  const head = entries.slice(0, maxEntries).join(PATH_SEP2);
+  if (entries.length <= maxEntries) return head;
+  return `${head}${PATH_SEP2}\u2026 (+${entries.length - maxEntries} more)`;
+}
+function pickEnvKeys(env, keys) {
+  const out = {};
+  for (const key of keys) {
+    const value = env[key];
+    if (value !== void 0 && value !== "") {
+      out[key] = value;
+    }
+  }
+  return out;
 }
-var useNpmShell2 = process.platform === "win32";
-function runNpm2(args, options = {}) {
-  return spawnSync3(useNpmShell2 ? "npm.cmd" : "npm", args, {
-    ...options,
-    shell: useNpmShell2
-  });
+function collectInterestingEnv(env) {
+  const keys = /* @__PURE__ */ new Set([
+    "PATH",
+    "HOME",
+    "USER",
+    "LOGNAME",
+    "SHELL",
+    "LANG",
+    "LC_ALL",
+    "NODE_ENV",
+    "npm_config_registry",
+    "NPM_CONFIG_REGISTRY",
+    "npm_config_prefix",
+    "NPM_CONFIG_PREFIX",
+    APM_DEPLOYMENT_RUN_ID_ENV
+  ]);
+  for (const key of Object.keys(env)) {
+    if (/^npm_config_/i.test(key) || /^NPM_CONFIG_/i.test(key)) {
+      keys.add(key);
+    }
+    if (/^APM_/i.test(key) && !SENSITIVE_ENV_KEY.test(key)) {
+      keys.add(key);
+    }
+  }
+  const picked = {};
+  for (const key of [...keys].sort()) {
+    const value = env[key];
+    if (value === void 0 || value === "") continue;
+    picked[key] = SENSITIVE_ENV_KEY.test(key) ? "***" : value;
+  }
+  return picked;
 }
-function resolveNpmGlobalBin() {
-  const binResult = runNpm2(["bin", "-g"], {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  if (binResult.status !== 0) return null;
-  return binResult.stdout?.toString().trim() || null;
+function describePathDelta(before, after) {
+  const beforeSet = new Set(pathEntries(before));
+  const added = pathEntries(after).filter((entry) => !beforeSet.has(entry));
+  if (added.length === 0) return "buildDeployShellEnv \u672A prepend \u65B0 PATH \u6BB5";
+  return `prepend: ${added.join(PATH_SEP2)}`;
 }
-function resolvePm2FromNpmRoot() {
-  const rootResult = runNpm2(["root", "-g"], {
+function probeCommand(label, command, cwd, env) {
+  const result = spawnSync4(command, {
+    cwd,
+    shell: true,
+    env,
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"]
   });
-  if (rootResult.status !== 0) return null;
-  const root = rootResult.stdout?.toString().trim();
-  if (!root) return null;
-  for (const rel of ["pm2/bin/pm2", "pm2/bin/pm2.js"]) {
-    const candidate = join15(root, ...rel.split("/"));
-    if (existsSync14(candidate)) {
-      return candidate;
-    }
-  }
-  return null;
+  const stdout = String(result.stdout ?? "").trim();
+  const stderr = String(result.stderr ?? "").trim();
+  const detail = stdout || stderr || "(no output)";
+  logLine(
+    `probe ${label}: exit=${result.status ?? "null"} output=${detail.slice(
+      0,
+      500
+    )}`
+  );
 }
-function isPm2NodeScript(path13) {
-  return path13.endsWith(".js") || /[\\/]pm2[\\/]bin[\\/]pm2$/.test(path13);
+function probeShellTooling(cwd, env) {
+  logLine("--- shell \u5DE5\u5177\u63A2\u6D4B\uFF08\u4E0E runDeployShellCommand \u76F8\u540C env/cwd\uFF09---");
+  probeCommand("node -v", "node -v", cwd, env);
+  probeCommand("npm -v", "npm -v", cwd, env);
+  if (process.platform === "win32") {
+    probeCommand("where node", "where node", cwd, env);
+    probeCommand("where npm", "where npm", cwd, env);
+  } else {
+    probeCommand("which node", "which node", cwd, env);
+    probeCommand("which npm", "which npm", cwd, env);
+  }
+}
+function logExecuteDeployContext(input) {
+  const trigger = input.trigger ?? "cli";
+  const deploymentRunId = process.env[APM_DEPLOYMENT_RUN_ID_ENV]?.trim() || null;
+  const shellEnv = buildDeployShellEnv();
+  const npmGlobalBin = resolveNpmGlobalBin2();
+  const packageJsonPath = join16(input.cwd, "package.json");
+  logLine("========== executeDeploy \u4E0A\u4E0B\u6587 ==========");
+  logLine(`trigger=${trigger} deployEnv=${input.env}`);
+  logLine(`cwd(input)=${input.cwdInput}`);
+  logLine(`cwd(resolved)=${input.cwd}`);
+  logLine(`process.cwd()=${input.processCwd}`);
+  logLine(
+    `cwdMatchProcess=${input.cwd === input.processCwd ? "yes" : "no"} (connect \u901A\u5E38\u4E3A no)`
+  );
+  logLine(
+    `apm.config=${input.apmConfigPath} exists=${existsSync14(
+      input.apmConfigPath
+    )}`
+  );
+  logLine(
+    `package.json=${packageJsonPath} exists=${existsSync14(packageJsonPath)}`
+  );
+  logLine(
+    `flags captureOutput=${input.captureOutput} packOnly=${Boolean(
+      input.packOnly
+    )} archiveDeployArtifact=${Boolean(input.archiveDeployArtifact)}`
+  );
+  logLine(`configPathOption=${input.configPathOption ?? "(default)"}`);
+  logLine(`${APM_DEPLOYMENT_RUN_ID_ENV}=${deploymentRunId ?? "(unset)"}`);
+  logLine(
+    `process execPath=${process.execPath} pid=${process.pid} platform=${process.platform} arch=${process.arch}`
+  );
+  logLine(`process argv=${process.argv.join(" ")}`);
+  logLine(`npmGlobalBin=${npmGlobalBin ?? "(resolve failed)"}`);
+  logLine(`nodeDir=${dirname5(process.execPath)}`);
+  logLine("--- process.env\uFF08\u8282\u9009\uFF09---");
+  for (const [key, value] of Object.entries(
+    collectInterestingEnv(process.env)
+  )) {
+    logLine(`  ${key}=${value}`);
+  }
+  logLine(`process.env.PATH=${summarizePath(process.env.PATH)}`);
+  logLine("--- buildDeployShellEnv()\uFF08\u5B50\u8FDB\u7A0B\u5B9E\u9645 env\uFF09---");
+  logLine(describePathDelta(process.env.PATH, shellEnv.PATH));
+  logLine(`shellEnv.PATH=${summarizePath(shellEnv.PATH)}`);
+  for (const [key, value] of Object.entries(
+    pickEnvKeys(shellEnv, [APM_DEPLOYMENT_RUN_ID_ENV, "NODE_ENV"])
+  )) {
+    logLine(`  shellEnv.${key}=${value}`);
+  }
+  probeShellTooling(input.cwd, shellEnv);
+  logLine("==========================================");
+}
+function logRunDeployShellContext(input) {
+  const shellEnv = buildDeployShellEnv();
+  logLine("---------- runDeployShellCommand ----------");
+  logLine(`command=${input.command}`);
+  logLine(`cwd=${input.cwd}`);
+  logLine(`captureOutput=${input.captureOutput}`);
+  logLine(
+    `stdio=${input.captureOutput ? "stdin=inherit stdout=pipe stderr=pipe" : "inherit"}`
+  );
+  logLine(`shell=true maxBuffer=${50 * 1024 * 1024}`);
+  logLine(`shellEnv.PATH(head)=${summarizePath(shellEnv.PATH, 8)}`);
+  logLine("--------------------------------------------");
 }
-function buildPm2SpawnTarget(binPath) {
-  if (isPm2NodeScript(binPath)) {
-    return {
-      command: process.execPath,
-      prefixArgs: [binPath],
-      displayPath: binPath
-    };
-  }
-  return {
-    command: binPath,
-    prefixArgs: [],
-    displayPath: binPath
-  };
+function logRunDeployShellResult(input) {
+  logLine(
+    `runDeployShellCommand done command=${input.command} exit=${input.exitCode ?? "null"} signal=${input.signal ?? "null"} capturedBytes=${input.outputBytes}${input.errorMessage ? ` error=${input.errorMessage}` : ""}`
+  );
 }
-function spawnPm2Target(target, args, options = {}) {
-  const useShell = useNpmShell2 && target.prefixArgs.length === 0;
-  return spawnSync3(target.command, [...target.prefixArgs, ...args], {
+function logWisdomFrontendDeployContext(input) {
+  logLine("--- wisdom Vue \u524D\u7AEF ---");
+  logLine(
+    `buildKey=build:${input.env} buildCmd=${input.buildCmd ?? "(missing)"}`
+  );
+  logLine(`distDir=${input.distDir} exists=${existsSync14(input.distDir)}`);
+  logLine(
+    `packOnly=${input.packOnly} archiveDeployArtifact=${input.archiveDeployArtifact}`
+  );
+}
+
+// src/commands/deploy/internal/wisdom-deploy.ts
+import { existsSync as existsSync16, readFileSync as readFileSync13, statSync as statSync7 } from "node:fs";
+import path4 from "node:path";
+
+// src/commands/deploy/deploy-shell-run.ts
+import { spawnSync as spawnSync5 } from "node:child_process";
+function runDeployShellCommand(command, cwd, captureOutput) {
+  logRunDeployShellContext({ command, cwd, captureOutput });
+  const shellEnv = buildDeployShellEnv();
+  const result = spawnSync5(command, {
+    cwd,
+    shell: true,
+    env: shellEnv,
     encoding: "utf8",
-    env: process.env,
-    shell: useShell,
-    windowsHide: useNpmShell2,
-    ...options
+    maxBuffer: DEPLOY_SPAWN_MAX_BUFFER_BYTES,
+    stdio: captureOutput ? ["inherit", "pipe", "pipe"] : "inherit"
   });
-}
-function spawnPm2At(binPath, args, options = {}) {
-  return spawnPm2Target(buildPm2SpawnTarget(binPath), args, options);
-}
-function verifyPm2Bin(pm2Bin) {
-  if (!pm2Bin.trim() || !existsSync14(pm2Bin)) {
-    return false;
-  }
-  const result = spawnPm2At(pm2Bin, ["--version"], {
-    stdio: ["ignore", "pipe", "pipe"]
+  const stdout = captureOutput ? String(result.stdout ?? "") : "";
+  const stderr = captureOutput ? String(result.stderr ?? "") : "";
+  const output = [stdout, stderr].filter(Boolean).join("\n");
+  logRunDeployShellResult({
+    command,
+    exitCode: result.status,
+    signal: result.signal,
+    errorMessage: result.error?.message,
+    outputBytes: Buffer.byteLength(output, "utf8")
   });
-  return !result.error && result.status === 0;
+  if (captureOutput) {
+    if (stdout) process.stdout.write(stdout);
+    if (stderr) process.stderr.write(stderr);
+  }
+  if (result.error) {
+    throw new DeployExecutionError(
+      `\u90E8\u7F72\u547D\u4EE4\u6267\u884C\u5931\u8D25: ${result.error.message}`,
+      1,
+      output
+    );
+  }
+  if (result.status !== 0) {
+    throw new DeployExecutionError(
+      `\u90E8\u7F72\u547D\u4EE4\u9000\u51FA\u7801 ${result.status ?? "unknown"}: ${command}`,
+      result.status ?? 1,
+      output
+    );
+  }
+  return output;
 }
-function collectPm2Candidates() {
-  const candidates = [];
-  const globalBin = resolveNpmGlobalBin();
-  if (globalBin) {
-    if (useNpmShell2) {
-      candidates.push(join15(globalBin, "pm2.cmd"));
-      candidates.push(join15(globalBin, "pm2"));
+
+// src/commands/deploy/internal/wisdom-backend-deploy.ts
+import {
+  existsSync as existsSync15,
+  mkdirSync as mkdirSync7,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync12,
+  statSync as statSync6,
+  writeFileSync as writeFileSync12
+} from "node:fs";
+import { spawnSync as spawnSync6 } from "node:child_process";
+import path3 from "node:path";
+import { Client as Client2 } from "ssh2";
+import JSZip2 from "jszip";
+import SftpClient2 from "ssh2-sftp-client";
+
+// src/commands/deploy/internal/wisdom-sftp.ts
+import { readdir as readdir2, readFile as readFile3, unlink, writeFile } from "node:fs/promises";
+import path2 from "node:path";
+import JSZip from "jszip";
+import SftpClient from "ssh2-sftp-client";
+async function addDirToZip(dir, zipFolder) {
+  const entries = await readdir2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const folder = zipFolder.folder(entry.name);
+      if (folder) {
+        await addDirToZip(fullPath, folder);
+      }
     } else {
-      candidates.push(join15(globalBin, "pm2"));
+      const content = await readFile3(fullPath);
+      zipFolder.file(entry.name, content);
     }
   }
-  const fromRoot = resolvePm2FromNpmRoot();
-  if (fromRoot) {
-    candidates.push(fromRoot);
-  }
-  const whichResult = spawnSync3(useNpmShell2 ? "where" : "which", ["pm2"], {
-    encoding: "utf8",
-    shell: useNpmShell2,
-    env: process.env,
-    stdio: ["ignore", "pipe", "pipe"]
+}
+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 }
   });
-  if (whichResult.status === 0) {
-    const fromPath = whichResult.stdout?.toString().trim().split(/\r?\n/).map((line) => line.trim()).filter(Boolean) ?? [];
-    if (useNpmShell2) {
-      fromPath.sort((a, b) => {
-        const aCmd = a.toLowerCase().endsWith(".cmd") ? 0 : 1;
-        const bCmd = b.toLowerCase().endsWith(".cmd") ? 0 : 1;
-        return aCmd - bCmd;
-      });
+  await writeFile(zipPath, content);
+  const sizeMb = (content.length / 1024 / 1024).toFixed(2);
+  console.error(`\u5DF2\u751F\u6210: ${zipPath} (${sizeMb} MB)`);
+  return content.length;
+}
+var SFTP_UPLOAD_MAX_ATTEMPTS = 3;
+var SFTP_FAST_PUT_OPTIONS = {
+  chunkSize: 64 * 1024,
+  concurrency: 4
+};
+function buildSftpConnectOptions(settings) {
+  return {
+    host: settings.host,
+    port: settings.port,
+    username: settings.username,
+    password: settings.password,
+    readyTimeout: 3e4,
+    tryKeyboard: true,
+    keepaliveInterval: 1e4,
+    keepaliveCountMax: 3
+  };
+}
+async function sleep(ms) {
+  await new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+async function uploadZipWithRetry(settings, localZip, remoteZipPath) {
+  let lastError;
+  for (let attempt = 1; attempt <= SFTP_UPLOAD_MAX_ATTEMPTS; attempt++) {
+    const sftp = new SftpClient();
+    try {
+      if (attempt > 1) {
+        console.error(
+          `SFTP \u4E0A\u4F20\u91CD\u8BD5 (${attempt}/${SFTP_UPLOAD_MAX_ATTEMPTS})...`
+        );
+      }
+      await sftp.connect(buildSftpConnectOptions(settings));
+      await ensureRemoteDir(sftp, settings.remotePath);
+      await sftp.fastPut(localZip, remoteZipPath, SFTP_FAST_PUT_OPTIONS);
+      return sftp;
+    } catch (err) {
+      lastError = err;
+      try {
+        await sftp.end();
+      } catch {
+      }
+      if (attempt < SFTP_UPLOAD_MAX_ATTEMPTS) {
+        const message = err instanceof Error ? err.message : String(err);
+        const delaySec = attempt * 2;
+        console.error(`SFTP \u4E0A\u4F20\u5931\u8D25 (${message})\uFF0C${delaySec}s \u540E\u91CD\u8BD5...`);
+        await sleep(delaySec * 1e3);
+      }
     }
-    candidates.push(...fromPath);
   }
-  return candidates;
+  throw lastError;
 }
-function findGlobalPm2() {
-  const seen = /* @__PURE__ */ new Set();
-  for (const candidate of collectPm2Candidates()) {
-    const key = useNpmShell2 ? candidate.toLowerCase() : candidate;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    if (verifyPm2Bin(candidate)) {
-      return candidate;
+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 {
     }
   }
-  return null;
 }
-function installGlobalPm2() {
-  console.log("[apm] \u672A\u68C0\u6D4B\u5230\u5168\u5C40 pm2\uFF0C\u6B63\u5728\u5B89\u88C5 npm install -g pm2 \u2026");
-  const result = runNpm2(["install", "-g", "pm2"], {
-    encoding: "utf8",
-    stdio: "inherit"
+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();
+      });
+    });
   });
-  if (result.status !== 0) {
-    console.error("[apm] \u5B89\u88C5 pm2 \u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u6267\u884C: npm install -g pm2");
-    process.exit(result.status ?? 1);
-  }
 }
-function readPm2Version(pm2Bin) {
-  const result = spawnPm2At(pm2Bin, ["--version"], {
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  if (result.error || result.status !== 0) {
-    return null;
-  }
-  return result.stdout?.toString().trim() || null;
+function shellSingleQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
-function logPm2Ready(pm2Bin, installed2) {
-  const version = readPm2Version(pm2Bin);
-  const versionSuffix = version ? ` ${version}` : "";
-  if (installed2) {
-    console.log(`[apm] \u5168\u5C40 pm2 \u5DF2\u5B89\u88C5${versionSuffix}: ${pm2Bin}`);
-  } else {
-    console.log(`[apm] \u5DF2\u68C0\u6D4B\u5230\u5168\u5C40 pm2${versionSuffix}: ${pm2Bin}`);
-  }
+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)}`;
 }
-function isPm2DaemonOutOfDate(output) {
-  return /In-memory PM2 is out-of-date/i.test(output);
+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 = await uploadZipWithRetry(settings, localZip, remoteZipPath);
+  try {
+    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();
+  }
 }
-function ensurePm2DaemonUpdated(pm2Bin) {
-  const probe = spawnPm2At(pm2Bin, ["jlist"], {
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  const combined = `${probe.stdout ?? ""}
-${probe.stderr ?? ""}`;
-  if (!isPm2DaemonOutOfDate(combined)) {
-    return;
+function resolveDeployArtifactUpload(input) {
+  const { packOnly, archiveDeployArtifact, deploymentRunId } = input;
+  if (deploymentRunId) {
+    return { upload: true, uploadWithoutRunId: false };
   }
-  console.log("[apm] \u68C0\u6D4B\u5230 PM2 \u5185\u5B58\u7248\u672C\u4E0E\u672C\u5730\u4E0D\u4E00\u81F4\uFF0C\u6B63\u5728\u6267\u884C pm2 update \u2026");
-  const update = spawnPm2At(pm2Bin, ["update"], {
-    stdio: "inherit"
-  });
-  if (update.error || update.status !== 0) {
-    console.error("[apm] pm2 update \u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u6267\u884C: pm2 update");
+  if (archiveDeployArtifact || packOnly) {
+    return { upload: true, uploadWithoutRunId: true };
   }
+  return { upload: false, uploadWithoutRunId: false };
 }
-function ensureGlobalPm2(options) {
-  const existing = findGlobalPm2();
-  if (existing) {
-    ensurePm2DaemonUpdated(existing);
-    if (!options?.quiet) {
-      logPm2Ready(existing, false);
+async function runWisdomSftpDeploy(params) {
+  const zipPath = path2.join(params.localDir, "..", ".deploy-sftp-dist.zip");
+  const resolvedZipPath = path2.resolve(zipPath);
+  const packOnly = Boolean(params.packOnly);
+  const archiveDeployArtifact = Boolean(params.archiveDeployArtifact);
+  const deploymentRunId = resolveDeploymentRunIdFromEnv();
+  const artifactUpload = resolveDeployArtifactUpload({
+    packOnly,
+    archiveDeployArtifact,
+    deploymentRunId
+  });
+  let zipSizeBytes = 0;
+  let artifactUploaded = false;
+  try {
+    zipSizeBytes = await zipDirectory(params.localDir, resolvedZipPath);
+    if (!packOnly) {
+      await uploadAndMaybeExtract(
+        params.settings,
+        resolvedZipPath,
+        params.extract
+      );
+    } else {
+      console.error("[apm] \u4EC5\u6253\u5305\u6A21\u5F0F\uFF1A\u8DF3\u8FC7 SFTP \u8FDC\u7A0B\u4E0A\u4F20");
     }
-    return existing;
-  }
-  installGlobalPm2();
-  const installed2 = findGlobalPm2();
-  if (!installed2) {
-    const globalBin = resolveNpmGlobalBin();
-    const moduleEntry = resolvePm2FromNpmRoot();
-    console.error(
-      "[apm] \u5B89\u88C5 pm2 \u540E\u4ECD\u65E0\u6CD5\u627E\u5230\u53EF\u6267\u884C\u6587\u4EF6\uFF0C\u8BF7\u624B\u52A8\u6267\u884C: npm install -g pm2"
-    );
-    if (globalBin) {
-      console.error(`[apm] npm \u5168\u5C40 bin: ${globalBin}`);
+    if (artifactUpload.upload) {
+      const artifact = await uploadDeployArtifactZip({
+        zipPath: resolvedZipPath,
+        projectName: params.projectName,
+        kind: "frontend",
+        uploadWithoutRunId: artifactUpload.uploadWithoutRunId
+      });
+      artifactUploaded = artifact !== null;
     }
-    if (moduleEntry) {
-      console.error(`[apm] \u5DF2\u68C0\u6D4B\u5230 pm2 \u6A21\u5757: ${moduleEntry}`);
-      console.error(
-        "[apm] \u82E5 pm2 --version \u53EF\u7528\uFF0C\u8BF7\u68C0\u67E5 Node/npm \u5168\u5C40\u5B89\u88C5\u6743\u9650\u6216 PATH"
-      );
+    if (artifactUploaded) {
+      if (packOnly) {
+        console.error("\u6253\u5305\u5E76\u4E0A\u4F20 MinIO \u5B8C\u6210\uFF08\u672A\u4E0A\u4F20\u8FDC\u7A0B\u670D\u52A1\u5668\uFF09");
+      } else {
+        console.error("[apm] SFTP \u90E8\u7F72\u5B8C\u6210\uFF0C\u90E8\u7F72\u4EA7\u7269\u5DF2\u5F52\u6863 MinIO");
+      }
+    }
+  } finally {
+    try {
+      await unlink(resolvedZipPath);
+      console.error(`\u5DF2\u6E05\u7406\u672C\u5730\u4E34\u65F6\u6587\u4EF6: ${resolvedZipPath}`);
+    } catch {
     }
-    process.exit(1);
-  }
-  ensurePm2DaemonUpdated(installed2);
-  if (!options?.quiet) {
-    logPm2Ready(installed2, true);
   }
-  return installed2;
+  return {
+    ok: true,
+    localDir: params.localDir,
+    host: params.settings.host,
+    remotePath: params.settings.remotePath,
+    zipSizeBytes,
+    extracted: packOnly ? false : params.extract,
+    packOnly,
+    artifactUploaded
+  };
 }
-function resolveApmEntryPath(entryArg = process.argv[1]) {
-  const fromArgv = entryArg?.trim();
-  if (fromArgv && existsSync14(fromArgv)) {
-    return fromArgv;
+
+// src/commands/deploy/internal/wisdom-backend-deploy.ts
+var SPRINGBOOT_JAVA_OPTS = "-XX:+UseG1GC -XX:+HeapDumpOnOutOfMemoryError -Xms512M -Xmx1G";
+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) {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  return path3.resolve(pathStr.replace(/^~(?=\/|\\|$)/, home));
+}
+function quoteForShell(value) {
+  if (process.platform === "win32") {
+    return `"${value.replace(/"/g, '""')}"`;
   }
-  const npmResult = spawnSync3(useNpmShell2 ? "npm.cmd" : "npm", ["root", "-g"], {
-    encoding: "utf8",
-    shell: useNpmShell2,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  if (npmResult.status === 0) {
-    const globalRoot = npmResult.stdout?.toString().trim();
-    if (globalRoot) {
-      const candidate = join15(globalRoot, CLI_PACKAGE_NAME, "dist", "index.js");
-      if (existsSync14(candidate)) {
-        return candidate;
-      }
-    }
+  return shellSingleQuote(value);
+}
+function formatMavenLocalRepoArg(repoPath) {
+  if (process.platform === "win32") {
+    return `-Dmaven.repo.local=${quoteForShell(repoPath)}`;
   }
-  if (fromArgv) {
-    return fromArgv;
+  return `-Dmaven.repo.local=${repoPath}`;
+}
+function deployCacheDir() {
+  return path3.join(workspaceApmDir(), "deploy", ".deploy_cache");
+}
+function manifestFilePath() {
+  return path3.join(deployCacheDir(), "manifest.json");
+}
+function getTargetDir(projectRoot) {
+  return path3.join(projectRoot, MAVEN_MODULE, "target");
+}
+function relativeKey(projectRoot, filePath) {
+  return path3.relative(projectRoot, filePath).split(path3.sep).join("/");
+}
+function fileSignature(filePath) {
+  const stat2 = statSync6(filePath);
+  return { size: stat2.size, mtime: stat2.mtimeMs / 1e3 };
+}
+function loadManifest3() {
+  const manifestPath2 = manifestFilePath();
+  if (!existsSync15(manifestPath2)) {
+    return {};
   }
-  console.error("[apm] \u65E0\u6CD5\u89E3\u6790 apm \u5165\u53E3\u8DEF\u5F84");
-  process.exit(1);
+  return JSON.parse(readFileSync12(manifestPath2, "utf8"));
 }
-function isRunningUnderPm2() {
-  if (process.env.APM_CONNECT_UNDER_PM2 === "1") {
-    return true;
+function saveManifest3(manifest) {
+  const dir = deployCacheDir();
+  mkdirSync7(dir, { recursive: true });
+  writeFileSync12(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"];
   }
-  if (process.env.pm_id === void 0) {
-    return false;
+  const localSize = statSync6(localPath).size;
+  const remoteSize = remoteAttr.size;
+  if (localSize !== remoteSize) {
+    return [true, `\u5927\u5C0F\u53D8\u5316 ${remoteSize} -> ${localSize}`];
   }
-  const name = process.env.name;
-  return name === PM2_APP_NAME || name !== void 0 && LEGACY_PM2_APP_NAMES.includes(name);
-}
-function isConnectPm2Process(app) {
-  if (app.name === PM2_APP_NAME) {
-    return true;
+  if (isProjectLibJar(path3.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 app.name !== void 0 && LEGACY_PM2_APP_NAMES.includes(app.name);
+  return [false, "\u5927\u5C0F\u4E00\u81F4\uFF0C\u8DF3\u8FC7"];
 }
-function listPm2Processes() {
-  try {
-    const raw = runPm2Json(["jlist"]);
-    return JSON.parse(raw);
-  } catch {
-    return [];
+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 = path3.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 findPm2ConnectProcess() {
-  return listPm2Processes().find(isConnectPm2Process) ?? null;
-}
-function resolvePm2ConnectName(app) {
-  return app?.name ?? PM2_APP_NAME;
+function updateManifestEntries(manifest, entries, projectRoot) {
+  for (const entry of entries) {
+    manifest[relativeKey(projectRoot, entry.path)] = fileSignature(entry.path);
+  }
+  return manifest;
 }
-function deletePm2AppIfExists(name) {
-  const pm2Bin = findGlobalPm2();
-  if (!pm2Bin) {
-    return;
+async function createUpdatePackage(entries, packageName) {
+  const dir = deployCacheDir();
+  mkdirSync7(dir, { recursive: true });
+  const zipPath = path3.join(dir, packageName);
+  log(`\u521B\u5EFA\u66F4\u65B0\u5305: ${path3.basename(zipPath)}\uFF08${entries.length} \u4E2A\u6587\u4EF6\uFF09`);
+  const zip = new JSZip2();
+  for (const entry of entries) {
+    const content = readFileSync12(entry.path);
+    zip.file(entry.arcname, content);
+    log(`  \u6253\u5305: ${entry.arcname} (${entry.reason})`);
   }
-  ensurePm2DaemonUpdated(pm2Bin);
-  spawnPm2At(pm2Bin, ["delete", name], {
-    stdio: "ignore"
+  const buffer = await zip.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    compressionOptions: { level: 6 }
   });
+  writeFileSync12(zipPath, buffer);
+  return zipPath;
 }
-function removePm2ConnectProcesses() {
-  const seen = /* @__PURE__ */ new Set();
-  for (const app of listPm2Processes()) {
-    if (!isConnectPm2Process(app) || !app.name || seen.has(app.name)) {
-      continue;
+function getMvnExecutable() {
+  const isWin = process.platform === "win32";
+  const candidates = isWin ? ["mvn.cmd", "mvn.bat", "mvn"] : ["mvn"];
+  for (const name of candidates) {
+    const result = spawnSync6(isWin ? `where ${name}` : `which ${name}`, {
+      encoding: "utf8",
+      shell: true
+    });
+    if (result.status === 0 && result.stdout.trim()) {
+      return result.stdout.trim().split(/\r?\n/)[0].trim();
     }
-    seen.add(app.name);
-    deletePm2AppIfExists(app.name);
-  }
-  for (const legacyName of LEGACY_PM2_APP_NAMES) {
-    deletePm2AppIfExists(legacyName);
   }
-  deletePm2AppIfExists(PM2_APP_NAME);
+  fail("\u672A\u627E\u5230 mvn \u547D\u4EE4\uFF0C\u8BF7\u786E\u8BA4 Maven \u5DF2\u5B89\u88C5\u5E76\u52A0\u5165 PATH");
 }
-function runPm2(args, options) {
-  const pm2Bin = ensureGlobalPm2({ quiet: true });
-  const result = spawnPm2At(pm2Bin, args, {
-    stdio: options?.inherit ? "inherit" : ["ignore", "pipe", "pipe"]
-  });
-  if (result.error) {
-    console.error("[apm] \u6267\u884C pm2 \u5931\u8D25:", result.error.message);
-    process.exit(1);
+function runMavenBuild(projectRoot, mavenLocalRepo, repoSource) {
+  const mavenRepo = expandPath(mavenLocalRepo);
+  const mvn = getMvnExecutable();
+  const command = [
+    quoteForShell(mvn),
+    "clean",
+    "package",
+    `-P${MAVEN_PROFILE}`,
+    formatMavenLocalRepoArg(mavenRepo),
+    "-DskipTests"
+  ].join(" ");
+  log("\u5F00\u59CB Maven \u6784\u5EFA...");
+  if (repoSource) {
+    log(
+      `Maven \u672C\u5730\u4ED3\u5E93: ${mavenRepo} (\u6765\u6E90: ${repoSource.source}/${repoSource.sourceDetail})`
+    );
+  } else {
+    log(`Maven \u672C\u5730\u4ED3\u5E93: ${mavenRepo}`);
   }
+  log(`\u6784\u5EFA\u76EE\u5F55: ${projectRoot}`);
+  const result = spawnSync6(command, {
+    cwd: projectRoot,
+    stdio: "inherit",
+    shell: true,
+    env: process.env
+  });
   if (result.status !== 0) {
-    const stderr = result.stderr?.toString().trim();
-    const stdout = result.stdout?.toString().trim();
-    const detail = stderr || stdout || `exit code ${result.status}`;
-    console.error(`[apm] pm2 ${args.join(" ")} \u5931\u8D25: ${detail}`);
-    process.exit(result.status ?? 1);
+    fail(`Maven \u6784\u5EFA\u5931\u8D25\uFF0C\u9000\u51FA\u7801: ${result.status ?? 1}`);
   }
 }
-function runPm2Json(args) {
-  const pm2Bin = findGlobalPm2();
-  if (!pm2Bin) {
-    return "[]";
+function locateLibDir(projectRoot) {
+  const targetDir = getTargetDir(projectRoot);
+  if (!existsSync15(targetDir)) {
+    fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
   }
-  ensurePm2DaemonUpdated(pm2Bin);
-  const result = spawnPm2At(pm2Bin, args, {
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  if (result.status !== 0) return "[]";
-  return result.stdout?.toString() ?? "[]";
-}
-function isPm2ConnectOnline() {
-  const app = findPm2ConnectProcess();
-  if (!app) return false;
-  const status = app.pm2_env?.status;
-  return status === "online" || status === "launching";
-}
-function printConnectNotRunningHint() {
-  console.log(`[apm] ${PM2_APP_NAME} \u672A\u5728\u8FD0\u884C`);
-  console.log("[apm] \u542F\u52A8\u5B88\u62A4: apm connect --daemon");
+  const libDir = path3.join(targetDir, "lib");
+  if (!existsSync15(libDir) || !statSync6(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;
 }
-function assertConnectNotRunning() {
-  pruneStaleConnectLock();
-  const lock = readConnectLock();
-  if (lock && isProcessAlive(lock.pid) && lock.pid !== process.pid) {
-    console.error(
-      `[apm] \u5DF2\u6709 apm connect \u5728\u8FD0\u884C (pid=${lock.pid}, mode=${lock.mode})\uFF0C\u8BF7\u5148\u505C\u6B62\u540E\u518D\u542F\u52A8`
-    );
-    process.exit(1);
+function locateMainJar(projectRoot) {
+  const targetDir = getTargetDir(projectRoot);
+  if (!existsSync15(targetDir)) {
+    fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
   }
-  if (!isRunningUnderPm2() && isPm2ConnectOnline()) {
-    console.error(
-      "[apm] \u5DF2\u6709 apm connect \u5B88\u62A4\u8FDB\u7A0B\u5728\u8FD0\u884C\uFF0C\u8BF7\u5148\u6267\u884C apm daemon stop"
-    );
-    process.exit(1);
+  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: ${path3.basename(mainJar)}`);
+  return mainJar;
 }
-function resolveRuntimePaths() {
-  return {
-    apmScript: resolveApmEntryPath(),
-    nodePath: process.execPath
-  };
+async function connectSsh(config) {
+  const client = new Client2();
+  log(`\u8FDE\u63A5\u670D\u52A1\u5668 ${config.username}@${config.host}:${config.port}`);
+  await new Promise((resolve5, reject) => {
+    client.on("ready", () => resolve5()).on("error", (err) => reject(err)).connect({
+      host: config.host,
+      port: config.port,
+      username: config.username,
+      password: config.password,
+      readyTimeout: 3e4,
+      tryKeyboard: true
+    });
+  });
+  const sftp = new SftpClient2();
+  await sftp.connect({
+    host: config.host,
+    port: config.port,
+    username: config.username,
+    password: config.password,
+    readyTimeout: 3e4,
+    tryKeyboard: true
+  });
+  return { client, sftp };
 }
-function reexecConnectWithResolvedPath(options) {
-  const apmScript = resolveApmEntryPath();
-  const args = [apmScript, "connect"];
-  const server = options.server?.trim();
-  if (server) {
-    args.push("--server", server);
-  }
-  const result = spawnSync3(process.execPath, args, { stdio: "inherit" });
-  if (result.error) {
-    console.error("[apm] \u91CD\u542F connect \u5931\u8D25:", result.error.message);
-    process.exit(1);
+async function closeSsh(conn) {
+  try {
+    await conn.sftp.end();
+  } catch {
   }
-  process.exit(result.status ?? 0);
+  conn.client.end();
 }
-async function handleConnectAfterUpdate(options) {
-  console.log("[apm] \u66F4\u65B0\u5B8C\u6210\uFF0C\u6B63\u5728\u4EE5\u65B0\u7248\u672C\u91CD\u65B0\u8FDE\u63A5\u2026");
-  await prepareEcosystem(options.server);
-  if (isRunningUnderPm2()) {
-    runPm2(["reload", PM2_ECOSYSTEM_PATH, "--update-env"], { inherit: true });
-    console.log("[apm] \u5DF2\u901A\u77E5 PM2 \u4F7F\u7528\u65B0\u7248\u672C\u91CD\u65B0\u52A0\u8F7D connect");
-    process.exit(0);
+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 {
   }
-  reexecConnectWithResolvedPath(options);
+  return stats;
 }
-async function resolveBaseUrl(server) {
-  if (server?.trim()) {
-    return server.trim().replace(/\/+$/, "");
+async function uploadUpdatePackage(sftp, zipPath, config) {
+  const remoteDir = config.remoteVueDistDir.replace(/\/$/, "");
+  const remotePath = `${remoteDir}/${path3.basename(zipPath)}`;
+  log(`\u4E0A\u4F20\u66F4\u65B0\u5305 -> ${remotePath}`);
+  try {
+    await sftp.fastPut(zipPath, remotePath);
+    log("\u66F4\u65B0\u5305\u4E0A\u4F20\u6210\u529F");
+  } catch (err) {
+    fail(`\u66F4\u65B0\u5305\u4E0A\u4F20\u5931\u8D25: ${err instanceof Error ? err.message : err}`);
   }
-  const cfg = await tryReadApmConfig();
-  return cfg?.baseUrl;
+  return remotePath;
 }
-function writeConnectLaunchFiles(options) {
-  mkdirSync7(APM_CONFIG_DIR, { recursive: true });
-  writeFileSync12(PM2_CONNECT_ENTRY_PATH, CONNECT_ENTRY_SCRIPT, "utf8");
-  const env = {
-    ...collectPm2LaunchEnv()
-  };
-  const baseUrl = options.baseUrl?.trim().replace(/\/+$/, "");
-  if (baseUrl) {
-    env.AI_PM_SERVER = baseUrl;
+async function uploadFullJar(sftp, localJarPath, config) {
+  const remoteDir = config.remoteAppDir.replace(/\/$/, "");
+  const remotePath = `${remoteDir}/${config.startupJar}`;
+  log(`\u4E0A\u4F20\u5168\u91CF JAR (${path3.basename(localJarPath)}) -> ${remotePath}`);
+  try {
+    await sftp.mkdir(remoteDir, true);
+    await sftp.fastPut(localJarPath, remotePath);
+    log("\u5168\u91CF JAR \u4E0A\u4F20\u6210\u529F");
+  } catch (err) {
+    fail(`\u5168\u91CF JAR \u4E0A\u4F20\u5931\u8D25: ${err instanceof Error ? err.message : err}`);
   }
-  const launch = {
-    nodePath: options.nodePath,
-    apmScript: options.apmScript,
-    connectArgs: options.connectArgs,
-    cwd: options.cwd,
-    env
-  };
-  writeFileSync12(
-    PM2_CONNECT_LAUNCH_PATH,
-    JSON.stringify(launch, null, 2) + "\n",
-    "utf8"
-  );
 }
-function writeEcosystemFile(options) {
-  writeConnectLaunchFiles(options);
-  const ecosystem = buildConnectPm2Ecosystem({
-    entryScript: PM2_CONNECT_ENTRY_PATH,
-    baseUrl: options.baseUrl
+async function runRemoteCommand(client, command, options) {
+  const check = options?.check ?? true;
+  const stream = options?.stream ?? false;
+  const label = options?.label ?? "\u8FDC\u7A0B\u547D\u4EE4";
+  return new Promise((resolve5, reject) => {
+    client.exec(command, (err, execStream) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      let out = "";
+      let errText = "";
+      execStream.on("data", (data) => {
+        const text = data.toString();
+        out += text;
+        if (stream) {
+          process.stdout.write(text);
+        }
+      });
+      execStream.stderr.on("data", (data) => {
+        errText += data.toString();
+      });
+      execStream.on("close", (code) => {
+        if (stream && out && !out.endsWith("\n")) {
+          process.stdout.write("\n");
+        }
+        if (check && code !== 0) {
+          const combined = `${out}
+${errText}`.trim();
+          fail(
+            `${label}\u5931\u8D25 (exit ${code})` + (combined ? `
+\u8F93\u51FA: ${combined}` : "")
+          );
+        }
+        resolve5({ exitCode: code, out: out.trim(), err: errText.trim() });
+      });
+    });
   });
-  writeFileSync12(
-    PM2_ECOSYSTEM_PATH,
-    formatConnectPm2EcosystemFile(ecosystem),
-    "utf8"
-  );
-  if (existsSync14(LEGACY_PM2_ECOSYSTEM_PATH)) {
-    try {
-      unlinkSync2(LEGACY_PM2_ECOSYSTEM_PATH);
-    } catch {
-    }
-  }
 }
-async function prepareEcosystem(server) {
-  await ensureLoggedConfig();
-  const cfg = await ensureApmConfig();
-  const { apmScript, nodePath } = resolveRuntimePaths();
-  const connectArgs = resolveConnectArgs(server);
-  const baseUrl = await resolveBaseUrl(server);
-  writeEcosystemFile({
-    apmScript,
-    nodePath,
-    connectArgs,
-    baseUrl,
-    cwd: process.cwd()
+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, {
+    label: "\u8FDC\u7A0B\u89E3\u538B"
   });
-  return cfg;
+  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;
 }
-async function runDaemonStart(options) {
-  assertConnectNotRunning();
-  await runUpdate();
-  ensureGlobalPm2();
-  const cfg = await prepareEcosystem(options.server);
-  removePm2ConnectProcesses();
-  runPm2(["start", PM2_ECOSYSTEM_PATH, "--update-env"], { inherit: true });
-  await delay(1e3);
-  if (!isPm2ConnectOnline()) {
-    console.error(
-      `[apm] ${PM2_APP_NAME} \u542F\u52A8\u540E\u672A\u5904\u4E8E online \u72B6\u6001\uFF0C\u8BF7\u6267\u884C: apm daemon logs -n 200`
-    );
+function springbootOutputIndicatesSuccess(action, combined) {
+  const lower = combined.toLowerCase();
+  if (action === "health") {
+    return combined.includes("\u5065\u5EB7\u68C0\u67E5\u901A\u8FC7");
   }
-  console.log(
-    `[apm] ${PM2_APP_NAME} \u5DF2\u7531 PM2 \u542F\u52A8\uFF08server=${options.server?.trim() || cfg.baseUrl}\uFF09`
-  );
-  if (options.follow) {
-    console.log(
-      "[apm] \u6B63\u5728\u8DDF\u8E2A\u65E5\u5FD7\uFF08Ctrl+C \u4EC5\u9000\u51FA\u65E5\u5FD7\u67E5\u770B\uFF0C\u5B88\u62A4\u8FDB\u7A0B\u7EE7\u7EED\u8FD0\u884C\uFF09"
-    );
-    runDaemonLogs({ follow: true });
-    return;
+  if (action === "start" || action === "restart") {
+    return combined.includes("is starting") || lower.includes("is running");
   }
-  console.log("[apm] \u67E5\u770B\u72B6\u6001: apm daemon status");
-  console.log("[apm] \u67E5\u770B\u65E5\u5FD7: apm daemon logs -f");
-  console.log("[apm] \u505C\u6B62: apm daemon stop");
+  if (action === "stop") {
+    return combined.includes("is stopping") || lower.includes("not running") || lower.includes("please check it");
+  }
+  if (action === "status") {
+    return lower.includes("running") || lower.includes("not running");
+  }
+  return true;
+}
+function buildRemoteStatusScript(remoteAppDir, appName) {
+  const dir = shellSingleQuote(remoteAppDir);
+  const jar = shellSingleQuote(appName);
+  return `
+set -e
+cd ${dir}
+appName=${jar}
+appIds=$(ps -ef | grep java | grep "$appName" | awk '{print $2}')
+if [ -z "$appIds" ]; then
+  echo -e "\\033[31m Not running \\033[0m"
+else
+  echo -e "\\033[32m Running [$appIds] \\033[0m"
+fi
+`.trim();
+}
+function buildRemoteRestartScript(remoteAppDir) {
+  const dir = shellSingleQuote(remoteAppDir);
+  const javaOpts = shellSingleQuote(SPRINGBOOT_JAVA_OPTS);
+  return `
+set -e
+cd ${dir}
+releaseApp=$(ls -t | grep '.jar$' | head -n1)
+lastVersionApp=$(ls -t | grep '.jar$' | head -n2 | tail -n1)
+appName=$lastVersionApp
+appIds=$(ps -ef | grep java | grep "$appName" | awk '{print $2}')
+if [ -z "$appIds" ]; then
+  echo "Maybe $appName not running, please check it..."
+else
+  echo "The $appName is stopping..."
+  echo "$appIds" | xargs kill
+fi
+for i in $(seq 15 -1 1); do
+  echo -n "$i "
+  sleep 1
+done
+echo 0
+if [ ! -d "backup" ]; then
+  mkdir backup
+fi
+for i in $(ls | grep '.jar$' | grep -vFx "$releaseApp"); do
+  echo "backup $i"
+  mv "$i" backup/
+done
+appName=$releaseApp
+count=$(ps -ef | grep java | grep "$appName" | wc -l)
+if [ "$count" != "0" ]; then
+  echo "Maybe $appName is running, please check it..."
+else
+  echo "The $appName is starting..."
+  nohup java -jar "./$appName" ${javaOpts} > nohup.out 2>&1 &
+fi
+`.trim();
 }
-async function runDaemonStop() {
-  pruneStaleConnectLock();
-  if (!isPm2ConnectOnline()) {
-    killConnectLockProcessIfAlive();
-    forceReleaseConnectLock();
-    console.log(`[apm] ${PM2_APP_NAME} \u672A\u5728\u8FD0\u884C`);
-    return;
-  }
-  runPm2(["stop", resolvePm2ConnectName(findPm2ConnectProcess())], {
-    inherit: true
-  });
-  for (let i = 0; i < 10; i += 1) {
-    if (!isPm2ConnectOnline()) break;
-    await delay(500);
+function normalizeHealthContext(context) {
+  let normalized = context.trim() || "/";
+  if (!normalized.startsWith("/")) {
+    normalized = `/${normalized}`;
   }
-  if (isPm2ConnectOnline()) {
-    console.log(`[apm] \u4F18\u96C5\u505C\u6B62\u8D85\u65F6\uFF0C\u5F3A\u5236\u79FB\u9664 ${PM2_APP_NAME}\u2026`);
-    runPm2(["delete", resolvePm2ConnectName(findPm2ConnectProcess())], {
-      inherit: true
-    });
+  if (!normalized.endsWith("/")) {
+    normalized = `${normalized}/`;
   }
-  killConnectLockProcessIfAlive();
-  forceReleaseConnectLock();
-  console.log(`[apm] ${PM2_APP_NAME} \u5DF2\u505C\u6B62`);
+  return normalized;
 }
-function killConnectLockProcessIfAlive() {
-  pruneStaleConnectLock();
-  const lock = readConnectLock();
-  if (!lock || !isProcessAlive(lock.pid)) return;
-  try {
-    process.kill(lock.pid, "SIGTERM");
-  } catch {
-    forceReleaseConnectLock();
-    return;
-  }
-  if (isProcessAlive(lock.pid)) {
-    try {
-      process.kill(lock.pid, "SIGKILL");
-    } catch {
+function buildRemoteHealthScript(port, context, timeoutSecs) {
+  const normalizedContext = normalizeHealthContext(context);
+  const portStr = String(port);
+  const timeoutStr = String(timeoutSecs);
+  return `
+set -e
+port=${shellSingleQuote(portStr)}
+context=${shellSingleQuote(normalizedContext)}
+timeout=${shellSingleQuote(timeoutStr)}
+check_url="http://127.0.0.1:${portStr}${normalizedContext}"
+echo "\u5065\u5EB7\u68C0\u67E5: \${check_url} (\u8D85\u65F6 \${timeout}s)"
+deadline=$(($(date +%s) + timeout))
+attempt=0
+while [ $(date +%s) -lt $deadline ]; do
+  attempt=$((attempt + 1))
+  code=$(curl -s -o /dev/null -w "%{http_code}" "$check_url" 2>/dev/null || echo "000")
+  code=$(echo "$code" | tail -n1 | tr -d '[:space:]')
+  if [ \${#code} -ge 3 ]; then
+    status=\${code:0:3}
+    if echo "$status" | grep -qE '^[0-9]+$' && [ "$status" -ge 200 ] && [ "$status" -lt 500 ]; then
+      echo -e "\\033[32m\u5065\u5EB7\u68C0\u67E5\u901A\u8FC7 (HTTP \${status})\\033[0m"
+      exit 0
+    fi
+  fi
+  remaining=$((deadline - $(date +%s)))
+  if [ $remaining -lt 0 ]; then
+    remaining=0
+  fi
+  echo "\u7B49\u5F85\u670D\u52A1\u542F\u52A8... \u7B2C \${attempt} \u6B21\uFF0C\u5269\u4F59 \${remaining}s"
+  sleep 5
+done
+echo -e "\\033[31m\u5065\u5EB7\u68C0\u67E5\u8D85\u65F6 (\${timeout}s): \${check_url}\\033[0m"
+exit 1
+`.trim();
+}
+async function runRemoteServiceScript(client, script, action) {
+  const { exitCode, out, err } = await runRemoteCommand(client, script, {
+    check: false,
+    label: action === "status" ? "\u8FDC\u7A0B status" : action === "restart" ? "\u8FDC\u7A0B restart" : "\u5065\u5EB7\u68C0\u67E5"
+  });
+  const combined = `${out}
+${err}`.trim();
+  const outputOk = springbootOutputIndicatesSuccess(action, combined);
+  if (action === "health") {
+    if (exitCode !== 0 || !outputOk) {
+      fail(`\u5065\u5EB7\u68C0\u67E5\u5931\u8D25
+\u8F93\u51FA: ${combined || "(\u7A7A)"}`);
     }
+    return combined;
   }
-  forceReleaseConnectLock();
-}
-async function runDaemonRestart(options) {
-  pruneStaleConnectLock();
-  const lock = readConnectLock();
-  if (lock && isProcessAlive(lock.pid) && !isPm2ConnectOnline()) {
-    console.error(
-      `[apm] \u5DF2\u6709\u524D\u53F0 apm connect \u5728\u8FD0\u884C (pid=${lock.pid})\uFF0C\u8BF7\u5148\u505C\u6B62\u540E\u518D\u542F\u52A8\u5B88\u62A4\u8FDB\u7A0B`
-    );
-    process.exit(1);
+  if (exitCode !== 0 && !outputOk) {
+    fail(`\u8FDC\u7A0B ${action} \u5931\u8D25
+${combined}`);
   }
-  await runUpdate();
-  await prepareEcosystem(options.server);
-  removePm2ConnectProcesses();
-  runPm2(["start", PM2_ECOSYSTEM_PATH, "--update-env"], { inherit: true });
-  console.log(`[apm] ${PM2_APP_NAME} \u5DF2\u91CD\u542F`);
-}
-async function runDaemonDelete() {
-  ensureGlobalPm2();
-  const app = findPm2ConnectProcess();
-  if (!app?.name) {
-    console.log(`[apm] ${PM2_APP_NAME} \u672A\u5728 PM2 \u4E2D\u6CE8\u518C`);
-    return;
+  if (action === "restart" && !outputOk) {
+    fail(`\u8FDC\u7A0B restart \u672A\u6210\u529F
+\u8F93\u51FA: ${combined || "(\u7A7A)"}`);
   }
-  runPm2(["delete", app.name], { inherit: true });
-  forceReleaseConnectLock();
-  console.log(`[apm] ${app.name} \u5DF2\u4ECE PM2 \u79FB\u9664`);
+  return combined;
 }
-async function runDaemonStatus() {
-  ensureGlobalPm2();
-  const app = findPm2ConnectProcess();
-  if (!app?.name) {
-    printConnectNotRunningHint();
-    return;
-  }
-  runPm2(["describe", app.name], { inherit: true });
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "");
 }
-async function runDaemonLogs(options) {
-  ensureGlobalPm2();
-  const app = findPm2ConnectProcess();
-  if (!app?.name) {
-    printConnectNotRunningHint();
-    return;
+async function getRunningJar(client, config) {
+  const script = buildRemoteStatusScript(
+    config.remoteAppDir,
+    config.startupJar
+  );
+  const combined = await runRemoteServiceScript(client, script, "status");
+  const text = stripAnsi(combined).trim().toLowerCase();
+  if (text.includes("not running")) {
+    return null;
   }
-  const args = ["logs", app.name, "--lines", String(options.lines ?? 100)];
-  if (!options.follow) {
-    args.push("--nostream");
+  if (text.includes("running")) {
+    return config.startupJar;
   }
-  runPm2(args, { inherit: true });
+  return null;
 }
-
-// src/commands/deploy/internal/deploy-shell-env.ts
-var PATH_SEP = process.platform === "win32" ? ";" : ":";
-var useNpmShell3 = process.platform === "win32";
-function resolveNpmGlobalBin2() {
-  const result = spawnSync4(useNpmShell3 ? "npm.cmd" : "npm", ["bin", "-g"], {
-    encoding: "utf8",
-    shell: useNpmShell3,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  if (result.status !== 0) {
-    return null;
-  }
-  const bin = result.stdout?.toString().trim();
-  return bin || null;
+async function healthCheckService(client, config) {
+  log("\u5065\u5EB7\u68C0\u67E5...");
+  const script = buildRemoteHealthScript(
+    config.healthCheckPort,
+    config.healthCheckContext,
+    config.healthCheckTimeout
+  );
+  await runRemoteServiceScript(client, script, "health");
 }
-function prependPath(pathValue, segment) {
-  if (!segment) {
-    return pathValue ?? "";
-  }
-  if (!pathValue) {
-    return segment;
-  }
-  const segments = pathValue.split(PATH_SEP);
-  if (segments.includes(segment)) {
-    return pathValue;
-  }
-  return `${segment}${PATH_SEP}${pathValue}`;
+async function restartRemoteService(client, config) {
+  const script = buildRemoteRestartScript(config.remoteAppDir);
+  await runRemoteServiceScript(client, script, "restart");
 }
-function buildDeployShellEnv(extra) {
-  const env = { ...process.env, ...extra };
-  const pathSegments = [dirname4(process.execPath)];
-  const globalBin = resolveNpmGlobalBin2();
-  if (globalBin) {
-    pathSegments.push(globalBin);
+function listAllLibFilesForArchive(libDir) {
+  return readdirSync5(libDir).filter((name) => name.endsWith(".jar")).sort().map((jarName) => ({
+    path: path3.join(libDir, jarName),
+    arcname: jarName,
+    reason: "\u4EC5\u6253\u5305\u5F52\u6863"
+  }));
+}
+async function runWisdomBackendDeploy(options) {
+  const projectRoot = path3.resolve(options.projectRoot ?? process.cwd());
+  const config = options.config;
+  const packOnly = Boolean(options.packOnly);
+  log(`=== \u81EA\u52A8\u90E8\u7F72: ${config.projectName} ===`);
+  log(`\u914D\u7F6E\u6587\u4EF6: ${path3.join(workspaceApmDir(), "apm.config.json")}`);
+  log(`\u9879\u76EE\u6839\u76EE\u5F55: ${projectRoot}`);
+  log(
+    `\u90E8\u7F72\u6A21\u5F0F: ${config.mode}${config.mode === "full" ? "\uFF08\u5168\u91CF JAR\uFF0C\u8DF3\u8FC7 lib \u68C0\u67E5\uFF09" : "\uFF08\u589E\u91CF lib \u66F4\u65B0\uFF09"}${packOnly ? "\uFF1B\u4EC5\u6253\u5305\uFF08\u4E0D\u4E0A\u4F20\u8FDC\u7A0B\uFF09" : ""}`
+  );
+  runMavenBuild(projectRoot, config.mavenLocalRepo, {
+    source: config.mavenLocalRepoSource,
+    sourceDetail: config.mavenLocalRepoSourceDetail
+  });
+  if (packOnly) {
+    const uploadWithoutRunId = !resolveDeploymentRunIdFromEnv();
+    if (config.mode === "full") {
+      const mainJar = locateMainJar(projectRoot);
+      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",
+        uploadWithoutRunId
+      });
+    } else {
+      const libDir = locateLibDir(projectRoot);
+      const entries = listAllLibFilesForArchive(libDir);
+      if (entries.length === 0) {
+        fail("lib \u76EE\u5F55\u4E0B\u6CA1\u6709\u53EF\u5F52\u6863\u7684 JAR");
+      }
+      const zipPath = await createUpdatePackage(entries, config.packageName);
+      await uploadDeployArtifactZip({
+        zipPath,
+        projectName: config.projectName,
+        kind: "backend",
+        uploadWithoutRunId
+      });
+    }
+    log("\u4EC5\u6253\u5305\u5B8C\u6210\uFF08\u672A\u4E0A\u4F20\u8FDC\u7A0B\u670D\u52A1\u5668\uFF09");
+    return;
   }
+  const conn = await connectSsh(config);
   try {
-    resolveApmEntryPath();
-  } catch {
-  }
-  for (const segment of pathSegments) {
-    env.PATH = prependPath(env.PATH, segment);
+    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);
+      log("\u90E8\u7F72\u5B8C\u6210");
+      return;
+    }
+    const libDir = locateLibDir(projectRoot);
+    let manifest = loadManifest3();
+    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
+      );
+      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,
+        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 restartRemoteService(conn.client, config);
+    }
+    await healthCheckService(conn.client, config);
+    if (libUploadEntries.length > 0) {
+      manifest = updateManifestEntries(manifest, libUploadEntries, projectRoot);
+      saveManifest3(manifest);
+    }
+  } finally {
+    await closeSsh(conn);
   }
-  return env;
+  log("\u90E8\u7F72\u5B8C\u6210");
 }
 
-// src/commands/deploy/internal/wisdom-auto-deploy.ts
-function isWisdomLegacyDeploy(cfg) {
+// src/commands/deploy/internal/wisdom-deploy.ts
+function isWisdomDeployConfigured(cfg) {
   const w = cfg.wisdomDeploy;
-  if (!w?.host?.trim() || !w.remotePath?.trim()) {
-    return false;
-  }
-  const hasNewFrontend = Boolean(cfg.frontendDeploy?.endpoint?.trim());
-  const hasNewBackend = Boolean(cfg.backendDeploy?.registryHost?.trim());
-  return !hasNewFrontend && !hasNewBackend;
+  return Boolean(w?.host?.trim() && w?.remotePath?.trim());
 }
 function detectWisdomProjectType(cwd) {
-  return existsSync15(path4.join(cwd, "package.json")) ? "frontend" : "backend";
+  return existsSync16(path4.join(cwd, "package.json")) ? "frontend" : "backend";
 }
 function readPackageScripts(cwd) {
   const pkgPath = path4.join(cwd, "package.json");
-  if (!existsSync15(pkgPath)) {
+  if (!existsSync16(pkgPath)) {
     return {};
   }
   try {
@@ -4850,14 +5135,6 @@ function readPackageScripts(cwd) {
     return {};
   }
 }
-function resolveFrontendDeployCommand(env, cwd) {
-  const scripts = readPackageScripts(cwd);
-  const deployKey = `deploy:${env}`;
-  if (scripts[deployKey]?.trim()) {
-    return `npm run deploy:${env}`;
-  }
-  return null;
-}
 function resolveFrontendBuildCommand(env, cwd) {
   const scripts = readPackageScripts(cwd);
   const buildKey = `build:${env}`;
@@ -4866,36 +5143,12 @@ function resolveFrontendBuildCommand(env, cwd) {
   }
   return null;
 }
-function runShellCommand(command, cwd, captureOutput) {
-  const result = spawnSync5(command, {
-    cwd,
-    shell: true,
-    env: buildDeployShellEnv(),
-    encoding: "utf8",
-    stdio: captureOutput ? ["inherit", "pipe", "pipe"] : "inherit"
-  });
-  const stdout = captureOutput ? String(result.stdout ?? "") : "";
-  const stderr = captureOutput ? String(result.stderr ?? "") : "";
-  const output = [stdout, stderr].filter(Boolean).join("\n");
-  if (captureOutput) {
-    if (stdout) process.stdout.write(stdout);
-    if (stderr) process.stderr.write(stderr);
-  }
-  if (result.status !== 0) {
-    throw new DeployExecutionError(
-      `\u90E8\u7F72\u547D\u4EE4\u9000\u51FA\u7801 ${result.status ?? "unknown"}: ${command}`,
-      result.status ?? 1,
-      output
-    );
-  }
-  return output;
-}
 function resolveFrontendDistDir(cwd) {
   const candidates = ["dist", "apps/web/dist"];
   for (const rel of candidates) {
     const full = path4.join(cwd, rel);
     try {
-      if (existsSync15(full) && statSync7(full).isDirectory()) {
+      if (existsSync16(full) && statSync7(full).isDirectory()) {
         return full;
       }
     } catch {
@@ -4903,62 +5156,57 @@ function resolveFrontendDistDir(cwd) {
   }
   return path4.join(cwd, "dist");
 }
-async function runWisdomAutoDeploy(options) {
-  const cwd = path4.resolve(options.cwd ?? process.cwd());
-  const captureOutput = options.captureOutput ?? false;
-  const packOnly = Boolean(options.packOnly);
-  const projectType = detectWisdomProjectType(cwd);
-  const configPath = options.configPath ?? path4.join(workspaceApmDir(cwd), "apm.config.json");
-  const cfg = loadApmConfig({ configPath });
+async function executeWisdomFrontendDeploy(options) {
+  const { cwd, cfg, captureOutput, packOnly, archiveDeployArtifact } = options;
+  const buildCmd = resolveFrontendBuildCommand(options.env, cwd);
+  const distDir = resolveFrontendDistDir(cwd);
+  logWisdomFrontendDeployContext({
+    env: options.env,
+    cwd,
+    buildCmd,
+    distDir,
+    packOnly,
+    archiveDeployArtifact
+  });
+  if (!buildCmd) {
+    const lines = formatWisdomFrontendBuildNotConfiguredLines(
+      options.env,
+      path4.join(cwd, "package.json")
+    );
+    throw new DeployExecutionError(lines.join("\n"), 1, lines.join("\n"));
+  }
   console.error(
-    `[apm] \u533B\u52A1\u5B58\u91CF\u9879\u76EE\u81EA\u52A8\u8BC6\u522B: ${projectType === "frontend" ? "\u524D\u7AEF Vue" : "\u540E\u7AEF Java"}${packOnly ? "\uFF08\u4EC5\u6253\u5305\u6A21\u5F0F\uFF09" : ""}`
+    `[apm] Vue\uFF1A${buildCmd}` + (packOnly ? "\uFF08\u4EC5\u6253\u5305\uFF0C\u8DF3\u8FC7 SFTP\uFF09" : " \u2192 SFTP \u4E0A\u4F20\u5E76\u8FDC\u7A0B\u89E3\u538B" + (archiveDeployArtifact ? " \u2192 \u5E73\u53F0\u90E8\u7F72\u4EA7\u7269\u5F52\u6863" : ""))
   );
-  if (projectType === "frontend") {
-    if (packOnly) {
-      const buildCmd = resolveFrontendBuildCommand(options.env, cwd);
-      if (!buildCmd) {
-        const lines = formatWisdomFrontendBuildNotConfiguredLines(
-          options.env,
-          path4.join(cwd, "package.json")
-        );
-        throw new DeployExecutionError(lines.join("\n"), 1, lines.join("\n"));
-      }
-      console.error(`[apm] \u524D\u7AEF\u4EC5\u6253\u5305\u6A21\u5F0F\uFF1A\u6267\u884C ${buildCmd}`);
-      runShellCommand(buildCmd, cwd, captureOutput);
-      const projectName = (cfg.name ?? "").trim();
-      if (!projectName) {
-        throw new DeployExecutionError(
-          "\u8BF7\u5728 .apm/apm.config.json \u9876\u5C42\u914D\u7F6E name\uFF08\u4F5C\u4E3A\u90E8\u7F72\u4EA7\u7269\u9879\u76EE\u540D\uFF09",
-          1
-        );
-      }
-      const settings2 = resolveWisdomDeployFromApmConfig(cfg);
-      await runWisdomSftpDeploy({
-        localDir: resolveFrontendDistDir(cwd),
-        settings: settings2,
-        extract: false,
-        projectName,
-        packOnly: true
-      });
-      return { projectType };
-    }
-    const deployCmd = resolveFrontendDeployCommand(options.env, cwd);
-    if (!deployCmd) {
-      const lines = formatWisdomFrontendDeployNotConfiguredLines(
-        options.env,
-        path4.join(cwd, "package.json")
-      );
-      throw new DeployExecutionError(lines.join("\n"), 1, lines.join("\n"));
-    }
-    runShellCommand(deployCmd, cwd, captureOutput);
-    return { projectType };
+  runDeployShellCommand(buildCmd, cwd, captureOutput);
+  let projectName = (cfg.name ?? "").trim();
+  if ((packOnly || archiveDeployArtifact) && !projectName) {
+    throw new DeployExecutionError(
+      "\u8BF7\u5728 .apm/apm.config.json \u9876\u5C42\u914D\u7F6E name\uFF08\u4F5C\u4E3A\u90E8\u7F72\u4EA7\u7269\u9879\u76EE\u540D\uFF09",
+      1
+    );
+  }
+  if (!projectName) {
+    projectName = path4.basename(cwd);
   }
+  const settings = resolveWisdomDeployFromApmConfig(cfg);
+  await runWisdomSftpDeploy({
+    localDir: distDir,
+    settings,
+    extract: !packOnly,
+    projectName,
+    packOnly,
+    archiveDeployArtifact
+  });
+}
+async function executeWisdomBackendDeployFlow(options) {
+  const { cwd, cfg, packOnly } = options;
   const settings = resolveWisdomBackendDeployFromApmConfig(cfg);
   if (packOnly) {
-    console.error(`[apm] \u540E\u7AEF\u4EC5\u6253\u5305\u6A21\u5F0F\uFF0C\u5FFD\u7565\u73AF\u5883\u53C2\u6570: ${options.env}`);
+    console.error(`[apm] Java\uFF1AMaven \u6784\u5EFA\uFF08\u4EC5\u6253\u5305\uFF0C\u5FFD\u7565\u73AF\u5883 ${options.env}\uFF09`);
   } else {
     console.error(
-      `[apm] \u540E\u7AEF\u90E8\u7F72\u4E0D\u533A\u5206 test/online\uFF0C\u5FFD\u7565\u73AF\u5883\u53C2\u6570: ${options.env}`
+      `[apm] Java\uFF1AMaven \u6784\u5EFA\u5E76\u90E8\u7F72\uFF08\u4E0D\u533A\u5206 test/online\uFF0C\u5FFD\u7565\u73AF\u5883 ${options.env}\uFF09`
     );
   }
   await runWisdomBackendDeploy({
@@ -4966,11 +5214,40 @@ async function runWisdomAutoDeploy(options) {
     projectRoot: cwd,
     packOnly
   });
+}
+async function executeWisdomDeploy(options) {
+  const cwd = path4.resolve(options.cwd);
+  const captureOutput = options.captureOutput ?? false;
+  const packOnly = Boolean(options.packOnly);
+  const archiveDeployArtifact = Boolean(options.archiveDeployArtifact);
+  const projectType = detectWisdomProjectType(cwd);
+  const configPath = options.configPath ?? path4.join(workspaceApmDir(cwd), "apm.config.json");
+  const cfg = loadApmConfig({ configPath });
+  console.error(
+    `[apm] ${projectType === "frontend" ? "Vue \u524D\u7AEF" : "Java \u540E\u7AEF"}${packOnly ? "\uFF08\u4EC5\u6253\u5305\uFF09" : ""}`
+  );
+  if (projectType === "frontend") {
+    await executeWisdomFrontendDeploy({
+      ...options,
+      cwd,
+      cfg,
+      captureOutput,
+      packOnly,
+      archiveDeployArtifact
+    });
+    return { projectType };
+  }
+  await executeWisdomBackendDeployFlow({
+    ...options,
+    cwd,
+    cfg,
+    packOnly
+  });
   return { projectType };
 }
 
 // src/commands/deploy/internal/deploy-baseline-sync.ts
-var LOG_PREFIX = "[apm] \u90E8\u7F72\u524D\u57FA\u7EBF\u540C\u6B65:";
+var LOG_PREFIX2 = "[apm] \u90E8\u7F72\u524D\u57FA\u7EBF\u540C\u6B65:";
 function formatGitError(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -5006,20 +5283,20 @@ async function restoreWorkingTree(cwd) {
 }
 async function mergeBaselineBranch(cwd, baselineBranch, currentBranch, note) {
   const mergeTarget = `origin/${baselineBranch}`;
-  note(`${LOG_PREFIX} \u5F00\u59CB\u5408\u5E76 ${mergeTarget} \u5230\u5F53\u524D\u5206\u652F ${currentBranch}`);
+  note(`${LOG_PREFIX2} \u5F00\u59CB\u5408\u5E76 ${mergeTarget} \u5230\u5F53\u524D\u5206\u652F ${currentBranch}`);
   try {
     if (currentBranch === baselineBranch) {
       await execGit(cwd, ["merge", "--ff-only", mergeTarget]);
     } else {
       await execGit(cwd, ["merge", mergeTarget, "--no-edit"]);
     }
-    note(`${LOG_PREFIX} \u5DF2\u5408\u5E76 ${mergeTarget} \u6700\u65B0\u4EE3\u7801`);
+    note(`${LOG_PREFIX2} \u5DF2\u5408\u5E76 ${mergeTarget} \u6700\u65B0\u4EE3\u7801`);
     return { merged: true, conflictRollback: false };
   } catch (error) {
     await abortMergeIfNeeded(cwd);
-    note(`${LOG_PREFIX} \u5408\u5E76 ${mergeTarget} \u5931\u8D25: ${formatGitError(error)}`);
-    note(`${LOG_PREFIX} \u5DF2\u6267\u884C git merge --abort \u56DE\u9000\u5230\u5408\u5E76\u524D\u72B6\u6001`);
-    note(`${LOG_PREFIX} \u5C06\u4F7F\u7528\u56DE\u9000\u540E\u7684\u4EE3\u7801\u7EE7\u7EED\u90E8\u7F72`);
+    note(`${LOG_PREFIX2} \u5408\u5E76 ${mergeTarget} \u5931\u8D25: ${formatGitError(error)}`);
+    note(`${LOG_PREFIX2} \u5DF2\u6267\u884C git merge --abort \u56DE\u9000\u5230\u5408\u5E76\u524D\u72B6\u6001`);
+    note(`${LOG_PREFIX2} \u5C06\u4F7F\u7528\u56DE\u9000\u540E\u7684\u4EE3\u7801\u7EE7\u7EED\u90E8\u7F72`);
     return { merged: false, conflictRollback: true };
   }
 }
@@ -5027,17 +5304,17 @@ async function restoreStashIfNeeded(cwd, stashed, note) {
   if (!stashed) {
     return false;
   }
-  note(`${LOG_PREFIX} \u6B63\u5728\u6062\u590D stash \u4E2D\u7684\u672A\u63D0\u4EA4\u6539\u52A8`);
+  note(`${LOG_PREFIX2} \u6B63\u5728\u6062\u590D stash \u4E2D\u7684\u672A\u63D0\u4EA4\u6539\u52A8`);
   try {
     await execGit(cwd, ["stash", "pop"], true);
-    note(`${LOG_PREFIX} \u5DF2\u6062\u590D stash \u4E2D\u7684\u672A\u63D0\u4EA4\u6539\u52A8`);
+    note(`${LOG_PREFIX2} \u5DF2\u6062\u590D stash \u4E2D\u7684\u672A\u63D0\u4EA4\u6539\u52A8`);
     return false;
   } catch (error) {
     await abortMergeIfNeeded(cwd);
     await restoreWorkingTree(cwd);
-    note(`${LOG_PREFIX} \u6062\u590D stash \u5931\u8D25: ${formatGitError(error)}`);
-    note(`${LOG_PREFIX} \u5DF2\u56DE\u9000\u5DE5\u4F5C\u533A\uFF08git reset --hard HEAD\uFF09\uFF0Cstash \u4ECD\u4FDD\u7559`);
-    note(`${LOG_PREFIX} \u5C06\u4F7F\u7528\u56DE\u9000\u540E\u7684\u4EE3\u7801\u7EE7\u7EED\u90E8\u7F72`);
+    note(`${LOG_PREFIX2} \u6062\u590D stash \u5931\u8D25: ${formatGitError(error)}`);
+    note(`${LOG_PREFIX2} \u5DF2\u56DE\u9000\u5DE5\u4F5C\u533A\uFF08git reset --hard HEAD\uFF09\uFF0Cstash \u4ECD\u4FDD\u7559`);
+    note(`${LOG_PREFIX2} \u5C06\u4F7F\u7528\u56DE\u9000\u540E\u7684\u4EE3\u7801\u7EE7\u7EED\u90E8\u7F72`);
     return true;
   }
 }
@@ -5056,30 +5333,30 @@ async function syncDeployBaselineBeforeDeploy(cwd) {
     ...partial
   });
   if (!await isGitRepo(cwd)) {
-    note(`${LOG_PREFIX} \u5F53\u524D\u76EE\u5F55\u4E0D\u662F git \u4ED3\u5E93\uFF0C\u8DF3\u8FC7`);
+    note(`${LOG_PREFIX2} \u5F53\u524D\u76EE\u5F55\u4E0D\u662F git \u4ED3\u5E93\uFF0C\u8DF3\u8FC7`);
     return emptyResult();
   }
   const cfg = await tryReadApmConfig();
   if (!cfg || !resolveApiKey(cfg)) {
-    note(`${LOG_PREFIX} \u672A\u767B\u5F55\uFF0C\u8DF3\u8FC7`);
+    note(`${LOG_PREFIX2} \u672A\u767B\u5F55\uFF0C\u8DF3\u8FC7`);
     return emptyResult();
   }
   await ensureGitRepo(cwd);
   const api = createApmApiClient(cfg);
   const baselineBranch = await resolveBaselineBranch2(cwd, api);
-  note(`${LOG_PREFIX} \u57FA\u7EBF\u5206\u652F ${baselineBranch}`);
-  note(`${LOG_PREFIX} \u6B63\u5728 fetch origin ${baselineBranch}`);
+  note(`${LOG_PREFIX2} \u57FA\u7EBF\u5206\u652F ${baselineBranch}`);
+  note(`${LOG_PREFIX2} \u6B63\u5728 fetch origin ${baselineBranch}`);
   await execGit(cwd, ["fetch", "origin", baselineBranch], true);
   if (!await remoteBranchExists(cwd, baselineBranch)) {
     throw new Error(
       `\u8FDC\u7A0B\u4E0D\u5B58\u5728\u57FA\u7EBF\u5206\u652F origin/${baselineBranch}\uFF0C\u8BF7\u786E\u8BA4\u4ED3\u5E93\u9ED8\u8BA4\u5206\u652F\u5DF2\u63A8\u9001\u5230 origin`
     );
   }
-  note(`${LOG_PREFIX} fetch \u5B8C\u6210`);
+  note(`${LOG_PREFIX2} fetch \u5B8C\u6210`);
   const currentBranch = await getCurrentBranch(cwd);
   let stashed = false;
   if (await isWorkingTreeDirty(cwd)) {
-    note(`${LOG_PREFIX} \u68C0\u6D4B\u5230\u672A\u63D0\u4EA4\u6539\u52A8\uFF0C\u5148 stash`);
+    note(`${LOG_PREFIX2} \u68C0\u6D4B\u5230\u672A\u63D0\u4EA4\u6539\u52A8\uFF0C\u5148 stash`);
     await execGit(cwd, [
       "stash",
       "push",
@@ -5088,7 +5365,7 @@ async function syncDeployBaselineBeforeDeploy(cwd) {
       "apm: deploy baseline sync"
     ]);
     stashed = true;
-    note(`${LOG_PREFIX} \u5DF2 stash \u672A\u63D0\u4EA4\u6539\u52A8`);
+    note(`${LOG_PREFIX2} \u5DF2 stash \u672A\u63D0\u4EA4\u6539\u52A8`);
   }
   const { merged, conflictRollback } = await mergeBaselineBranch(
     cwd,
@@ -5098,10 +5375,10 @@ async function syncDeployBaselineBeforeDeploy(cwd) {
   );
   const stashConflict = await restoreStashIfNeeded(cwd, stashed, note);
   if (conflictRollback || stashConflict) {
-    note(`${LOG_PREFIX} \u57FA\u7EBF\u540C\u6B65\u672A\u5B8C\u6210\uFF08\u5B58\u5728\u51B2\u7A81\u5E76\u5DF2\u56DE\u9000\uFF09\uFF0C\u7EE7\u7EED\u6267\u884C\u90E8\u7F72`);
+    note(`${LOG_PREFIX2} \u57FA\u7EBF\u540C\u6B65\u672A\u5B8C\u6210\uFF08\u5B58\u5728\u51B2\u7A81\u5E76\u5DF2\u56DE\u9000\uFF09\uFF0C\u7EE7\u7EED\u6267\u884C\u90E8\u7F72`);
   } else if (merged) {
     note(
-      `${LOG_PREFIX} \u5B8C\u6210\uFF08\u5F53\u524D\u5206\u652F ${currentBranch} \u5DF2\u5305\u542B ${baselineBranch} \u6700\u65B0\u4EE3\u7801\uFF09`
+      `${LOG_PREFIX2} \u5B8C\u6210\uFF08\u5F53\u524D\u5206\u652F ${currentBranch} \u5DF2\u5305\u542B ${baselineBranch} \u6700\u65B0\u4EE3\u7801\uFF09`
     );
   }
   return {
@@ -5114,35 +5391,27 @@ async function syncDeployBaselineBeforeDeploy(cwd) {
 }
 
 // src/commands/deploy/deploy-execute.ts
-function runShellCommand2(command, cwd, captureOutput) {
-  const result = spawnSync6(command, {
-    cwd,
-    shell: true,
-    env: buildDeployShellEnv(),
-    encoding: "utf8",
-    stdio: captureOutput ? ["inherit", "pipe", "pipe"] : "inherit"
-  });
-  const stdout = captureOutput ? String(result.stdout ?? "") : "";
-  const stderr = captureOutput ? String(result.stderr ?? "") : "";
-  const output = [stdout, stderr].filter(Boolean).join("\n");
-  if (captureOutput) {
-    if (stdout) process.stdout.write(stdout);
-    if (stderr) process.stderr.write(stderr);
-  }
-  if (result.status !== 0) {
-    throw new DeployExecutionError(
-      `\u90E8\u7F72\u547D\u4EE4\u9000\u51FA\u7801 ${result.status ?? "unknown"}: ${command}`,
-      result.status ?? 1,
-      output
-    );
-  }
-  return output;
-}
 async function executeDeploy(options) {
-  const cwd = resolveWorkdirPath(options.cwd ?? process.cwd());
+  const cwdInput = options.cwd.trim();
+  if (!cwdInput) {
+    throw new DeployExecutionError("[apm] executeDeploy \u7F3A\u5C11\u5DE5\u4F5C\u76EE\u5F55 cwd", 1);
+  }
+  const cwd = resolveWorkdirPath(cwdInput);
   const apmConfigPath = options.configPath ?? path5.join(workspaceApmDir(cwd), "apm.config.json");
   const captureOutput = options.captureOutput ?? false;
   const outputParts = [];
+  logExecuteDeployContext({
+    trigger: options.deployTrigger,
+    env: options.env,
+    cwd,
+    cwdInput,
+    processCwd: process.cwd(),
+    apmConfigPath,
+    captureOutput,
+    packOnly: options.packOnly,
+    archiveDeployArtifact: options.archiveDeployArtifact,
+    configPathOption: options.configPath
+  });
   try {
     const configSyncResult = await syncRemoteDeploymentConfig(
       cwd,
@@ -5165,36 +5434,29 @@ async function executeDeploy(options) {
       detail
     );
   }
+  const preDeployLog = outputParts.join("\n");
   const cfg = loadApmConfig({ configPath: apmConfigPath });
-  if (isWisdomLegacyDeploy(cfg)) {
-    try {
-      await runWisdomAutoDeploy({
-        env: options.env,
-        cwd,
-        configPath: apmConfigPath,
-        captureOutput,
-        packOnly: options.packOnly
-      });
-      return outputParts.join("\n");
-    } catch (error) {
-      if (error instanceof DeployExecutionError) {
-        throw error;
-      }
-      const detail = error instanceof Error ? error.message : String(error);
-      throw new DeployExecutionError(detail, 1);
-    }
-  }
-  const deployCommands = cfg.deploy ?? {};
-  const command = deployCommands[options.env]?.trim();
-  if (!command) {
-    const lines = formatDeployNotConfiguredLines(options.env, deployCommands);
+  if (!isWisdomDeployConfigured(cfg)) {
+    const lines = formatMissingWisdomDeployLines();
     throw new DeployExecutionError(lines.join("\n"), 1, lines.join("\n"));
   }
-  const commandOutput = runShellCommand2(command, cwd, captureOutput);
-  if (commandOutput.trim()) {
-    outputParts.push(commandOutput);
+  try {
+    await executeWisdomDeploy({
+      env: options.env,
+      cwd,
+      configPath: apmConfigPath,
+      captureOutput,
+      packOnly: options.packOnly,
+      archiveDeployArtifact: options.archiveDeployArtifact
+    });
+    return preDeployLog;
+  } catch (error) {
+    if (error instanceof DeployExecutionError) {
+      throw error;
+    }
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new DeployExecutionError(detail, 1);
   }
-  return outputParts.join("\n");
 }
 function printDeployExecutionError(error) {
   if (error.output.trim()) {
@@ -5209,9 +5471,32 @@ var DEPLOY_LOG_SYNC_INTERVAL_MS = 3e4;
 function resolveDeployCommand(environment, packOnly) {
   return packOnly ? `apm deploy ${environment} --pack-only` : `apm deploy ${environment}`;
 }
+function logDeploySyncFailure(error) {
+  console.error(
+    "[apm] deploy log sync failed:",
+    error instanceof Error ? error.message : String(error)
+  );
+}
 function createDeployLogSyncer(api, deploymentRunId) {
   let lastSyncedLog = "";
   let latestLog = "";
+  let timer = null;
+  const syncDelta = async (delta, append) => {
+    const chunks = splitUtf8StringByMaxBytes(
+      delta,
+      DEPLOY_LOG_SYNC_MAX_CHUNK_BYTES
+    );
+    for (let index = 0; index < chunks.length; index += 1) {
+      const chunk = chunks[index];
+      await retryDeployLogSync(
+        () => api.cli.syncTaskDeploymentLog({
+          id: deploymentRunId,
+          log: chunk,
+          append: append || index > 0
+        })
+      );
+    }
+  };
   const syncIfChanged = async () => {
     if (!latestLog || latestLog === lastSyncedLog) {
       return;
@@ -5220,34 +5505,58 @@ function createDeployLogSyncer(api, deploymentRunId) {
     if (!delta) {
       return;
     }
-    await api.cli.syncTaskDeploymentLog({
-      id: deploymentRunId,
-      log: delta,
-      append: lastSyncedLog.length > 0
-    });
+    await syncDelta(delta, lastSyncedLog.length > 0);
     lastSyncedLog = latestLog;
   };
-  const timer = setInterval(() => {
-    void syncIfChanged().catch((error) => {
-      console.error(
-        "[apm] deploy log sync failed:",
-        error instanceof Error ? error.message : String(error)
-      );
-    });
+  timer = setInterval(() => {
+    void syncIfChanged().catch(logDeploySyncFailure);
   }, DEPLOY_LOG_SYNC_INTERVAL_MS);
   return {
     updateLog(log2) {
       latestLog = log2;
     },
     async flush() {
-      clearInterval(timer);
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
       await syncIfChanged();
     },
+    async flushSafe() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      try {
+        await syncIfChanged();
+        return true;
+      } catch (error) {
+        logDeploySyncFailure(error);
+        return false;
+      }
+    },
     dispose() {
-      clearInterval(timer);
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
     }
   };
 }
+async function finalizeTaskDeployment(api, deploymentRunId, logSyncer, input) {
+  const synced = await logSyncer.flushSafe();
+  const payload = {
+    id: deploymentRunId,
+    status: input.status
+  };
+  if (input.error) {
+    payload.error = input.error;
+  }
+  if (!synced) {
+    payload.log = truncateDeployLogForComplete(input.fullLog).log;
+  }
+  await retryDeployLogSync(() => api.cli.completeTaskDeployment(payload));
+}
 function captureDeployConsole(logSyncer) {
   const chunks = [];
   const appendLog = (line) => {
@@ -5296,7 +5605,9 @@ async function handleInboundDeploy(cfg, msg, signal) {
     env: msg.environment,
     cwd: workdir,
     packOnly: msg.packOnly,
-    captureOutput: true
+    captureOutput: true,
+    archiveDeployArtifact: true,
+    deployTrigger: "connect"
   };
   try {
     if (signal.aborted) return;
@@ -5304,11 +5615,9 @@ async function handleInboundDeploy(cfg, msg, signal) {
     if (output.trim()) {
       capture.appendLog(output);
     }
-    await logSyncer.flush();
-    await api.cli.completeTaskDeployment({
-      id: deploymentRunId,
+    await finalizeTaskDeployment(api, deploymentRunId, logSyncer, {
       status: "SUCCESS",
-      log: capture.getLog()
+      fullLog: capture.getLog()
     });
     console.log(`[apm] deploy success id=${deploymentRunId}`);
   } catch (error) {
@@ -5321,13 +5630,18 @@ async function handleInboundDeploy(cfg, msg, signal) {
     } else {
       capture.appendLog(deployError.message);
     }
-    await logSyncer.flush();
-    await api.cli.completeTaskDeployment({
-      id: deploymentRunId,
-      status: "FAILED",
-      error: deployError.message,
-      log: capture.getLog()
-    });
+    try {
+      await finalizeTaskDeployment(api, deploymentRunId, logSyncer, {
+        status: "FAILED",
+        fullLog: capture.getLog(),
+        error: deployError.message
+      });
+    } catch (finalizeError) {
+      console.error(
+        `[apm] deploy finalize failed id=${deploymentRunId}:`,
+        finalizeError instanceof Error ? finalizeError.message : String(finalizeError)
+      );
+    }
     console.error(
       `[apm] deploy failed id=${deploymentRunId}: ${deployError.message}`
     );
@@ -5609,13 +5923,13 @@ ${JSON.stringify(event, null, 2)}
 }
 
 // src/commands/connect/agent-session-registry.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname5, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync13 } from "node:fs";
+import { dirname as dirname6, resolve as resolve4 } from "node:path";
 function registryPath(workdir, sessionId) {
   return resolve4(workdir, ".apm", "sessions", sessionId, "cursor-agents.json");
 }
 function readRegistry(path13) {
-  if (!existsSync16(path13)) {
+  if (!existsSync17(path13)) {
     return {};
   }
   try {
@@ -5636,7 +5950,7 @@ function readRegistry(path13) {
   return {};
 }
 function writeRegistry(path13, registry) {
-  mkdirSync8(dirname5(path13), { recursive: true });
+  mkdirSync8(dirname6(path13), { recursive: true });
   writeFileSync13(path13, `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
@@ -6087,15 +6401,15 @@ async function ensureMessageHasReply(cfg, sessionId, messageId, fallback) {
 }
 
 // src/commands/connect/cli-version-sync.ts
-import { existsSync as existsSync17, readFileSync as readFileSync15, writeFileSync as writeFileSync14 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync15, writeFileSync as writeFileSync14 } from "fs";
+import { join as join17 } from "path";
 var CLI_VERSION_FILE = ".cli-version.json";
 function manifestPath(apmDir) {
-  return join16(apmDir, CLI_VERSION_FILE);
+  return join17(apmDir, CLI_VERSION_FILE);
 }
 function loadManifest4(apmDir) {
   const path13 = toFsPath(manifestPath(apmDir));
-  if (!existsSync17(path13)) {
+  if (!existsSync18(path13)) {
     return null;
   }
   try {
@@ -6163,23 +6477,53 @@ function markPullDone(sessionId, workdir) {
 
 // src/commands/connect/run-slot-pool.ts
 var DEFAULT_MAX_CONCURRENT = 5;
-function createRunSlotPool(maxConcurrent = DEFAULT_MAX_CONCURRENT) {
+function createRunSlotPool(maxConcurrent = DEFAULT_MAX_CONCURRENT, options = {}) {
+  const label = options.label ?? "task";
+  const isDeployPool = label === "deploy";
   let active = 0;
   const waiters = [];
-  const acquire = () => {
+  const logDeploy = (message) => {
+    if (isDeployPool) {
+      console.error(`[apm] deploy \u4E32\u884C\u9650\u6D41\uFF1A${message}`);
+    }
+  };
+  const acquire = (meta) => {
     if (active < maxConcurrent) {
       active += 1;
+      if (isDeployPool) {
+        logDeploy(
+          `\u5F00\u59CB\u6267\u884C${meta ? `\uFF08${meta}\uFF09` : ""}\uFF0C\u5F53\u524D\u5360\u7528 ${active}/${maxConcurrent}`
+        );
+      }
       return Promise.resolve();
     }
+    const queueIndex = waiters.length + 1;
+    if (isDeployPool) {
+      logDeploy(
+        `\u5E76\u53D1\u5DF2\u6EE1\uFF08${maxConcurrent}/${maxConcurrent}\uFF09\uFF0C${meta ? `${meta} ` : ""}\u8FDB\u5165\u6392\u961F\uFF0C\u524D\u65B9 ${queueIndex} \u4E2A`
+      );
+    }
+    const queuedAt = Date.now();
     return new Promise((resolve5) => {
       waiters.push(() => {
         active += 1;
+        const waitedMs = Date.now() - queuedAt;
+        if (isDeployPool) {
+          logDeploy(
+            `\u6392\u961F\u7ED3\u675F\uFF0C\u5F00\u59CB\u6267\u884C${meta ? `\uFF08${meta}\uFF09` : ""}\uFF0C\u7B49\u5F85 ${Math.ceil(
+              waitedMs / 1e3
+            )}s\uFF0C\u5F53\u524D\u5360\u7528 ${active}/${maxConcurrent}`
+          );
+        }
         resolve5();
       });
     });
   };
   const release = () => {
     active = Math.max(0, active - 1);
+    if (isDeployPool) {
+      logDeploy(`\u6267\u884C\u69FD\u91CA\u653E\uFF0C\u5F53\u524D\u5360\u7528 ${active}/${maxConcurrent}`);
+    }
     const next = waiters.shift();
     if (next) {
       next();
@@ -6376,6 +6720,7 @@ function attachWsHandlers(ws, ctx, onOpen) {
     clientMachineId,
     shutdownAbort,
     runSlots,
+    deployRunSlots,
     activeTasks,
     activeRuns,
     pendingCancels,
@@ -6414,12 +6759,13 @@ function attachWsHandlers(ws, ctx, onOpen) {
         shutdownAbort.signal,
         perDeployController.signal
       ]);
+      const deploySlotMeta = `deploymentRunId=${msg2.deploymentRunId} env=${msg2.environment} workdir=${msg2.workdir}`;
       const task2 = (async () => {
-        await runSlots.acquire();
+        await deployRunSlots.acquire(deploySlotMeta);
         try {
           await handleInboundDeploy(cfg, msg2, signal2);
         } finally {
-          runSlots.release();
+          deployRunSlots.release();
         }
       })();
       activeTasks.add(task2);
@@ -6577,6 +6923,7 @@ async function runConnect(options) {
   const lifecycleAbort = new AbortController();
   const shutdownAbort = new AbortController();
   const runSlots = createRunSlotPool();
+  const deployRunSlots = createRunSlotPool(1, { label: "deploy" });
   const activeTasks = /* @__PURE__ */ new Set();
   const activeRuns = /* @__PURE__ */ new Map();
   const pendingCancels = /* @__PURE__ */ new Set();
@@ -6586,6 +6933,7 @@ async function runConnect(options) {
     clientMachineId,
     shutdownAbort,
     runSlots,
+    deployRunSlots,
     activeTasks,
     activeRuns,
     pendingCancels,
@@ -6599,7 +6947,7 @@ async function runConnect(options) {
     shutdownAbort.abort();
     logAbortSignalStats(shutdownAbort.signal, "connect:shutdown-after-abort");
     try {
-      await Promise.race([Promise.all(activeTasks), delay2(drainMs)]);
+      await Promise.race([Promise.all(activeTasks), delay3(drainMs)]);
     } catch {
     }
     releaseConnectLock();
@@ -6797,10 +7145,9 @@ function normalizeDeployEnvironment(env) {
 }
 async function completeTrackedDeploy(api, deploymentRunId, logSyncer, input) {
   logSyncer.updateLog(input.log);
-  await logSyncer.flush();
-  await api.cli.completeTaskDeployment({
-    id: deploymentRunId,
+  await finalizeTaskDeployment(api, deploymentRunId, logSyncer, {
     status: input.status,
+    fullLog: input.log,
     error: input.error
   });
 }
@@ -6825,7 +7172,7 @@ async function runDeployWithBackendTracking(options) {
     const run = await api.cli.createTaskDeployment({
       sessionId: options.sessionId,
       environment,
-      workdirPath: options.cwd ?? process.cwd()
+      workdirPath: options.cwd
     });
     deploymentRunId = run.id;
     console.log(
@@ -6861,7 +7208,11 @@ async function runDeployWithBackendTracking(options) {
     originalError.apply(console, args);
   };
   try {
-    const output = await executeDeploy({ ...options, captureOutput: true });
+    const output = await executeDeploy({
+      ...options,
+      captureOutput: true,
+      archiveDeployArtifact: true
+    });
     if (output.trim()) {
       appendLog(output);
     }
@@ -6904,8 +7255,8 @@ async function runDeployWithBackendTracking(options) {
 // src/commands/deploy/deploy.ts
 function registerDeployMainCommand(program) {
   program.command("deploy").description(
-    "\u7EDF\u4E00\u90E8\u7F72\uFF08\u6267\u884C\u524D\u81EA\u52A8\u540C\u6B65\u90E8\u7F72\u914D\u7F6E\u5E76\u5408\u5E76\u57FA\u7EBF\u5206\u652F\uFF09\uFF1A\u533B\u52A1\u5B58\u91CF\u81EA\u52A8\u8BC6\u522B\u524D\u540E\u7AEF\uFF1B\u5176\u4ED6\u9879\u76EE\u6309 deploy.<\u73AF\u5883> \u6267\u884C shell \u547D\u4EE4"
-  ).argument("<env>", "\u90E8\u7F72\u73AF\u5883\u540D\uFF08\u5982 test\u3001online\uFF09").option(
+    "\u533B\u52A1\u90E8\u7F72\uFF1AVue build + SFTP / Java Maven + SSH\uFF08\u9700 apm.config.json wisdomDeploy\uFF09"
+  ).argument("<env>", "\u90E8\u7F72\u73AF\u5883\u540D\uFF08\u5982 test\u3001online\uFF1BVue \u5BF9\u5E94 build:<env>\uFF09").option(
     "--config <path>",
     "apm.config.json \u8DEF\u5F84\uFF08\u9ED8\u8BA4 .apm/apm.config.json\uFF09"
   ).option(
@@ -6913,7 +7264,7 @@ function registerDeployMainCommand(program) {
     "\u6C9F\u901A\u7FA4 ID\uFF1B\u4F20\u5165\u65F6\u5728\u5E73\u53F0\u521B\u5EFA\u90E8\u7F72\u8BB0\u5F55\u5E76\u540C\u6B65\u65E5\u5FD7"
   ).option(
     "--pack-only",
-    "\u4EC5\u6784\u5EFA/\u6253\u5305\u5E76\u4E0A\u4F20 MinIO \u5F52\u6863\uFF0C\u4E0D\u4E0A\u4F20\u8FDC\u7A0B\u670D\u52A1\u5668\uFF08\u524D\u7AEF build:<env>\uFF0C\u540E\u7AEF Maven \u6784\u5EFA\uFF09"
+    "\u4EC5\u6784\u5EFA/\u6253\u5305\uFF0C\u4E0D\u4E0A\u4F20\u8FDC\u7A0B SFTP/SSH\uFF1B\u53EF\u5F52\u6863\u5E73\u53F0\u90E8\u7F72\u4EA7\u7269"
   ).action(
     async (env, opts) => {
       const cwd = process.cwd();
@@ -6926,11 +7277,18 @@ function registerDeployMainCommand(program) {
             cwd,
             configPath: opts.config,
             sessionId,
-            packOnly
+            packOnly,
+            deployTrigger: "session"
           });
           return;
         }
-        await executeDeploy({ env, cwd, configPath: opts.config, packOnly });
+        await executeDeploy({
+          env,
+          cwd,
+          configPath: opts.config,
+          packOnly,
+          deployTrigger: "cli"
+        });
       } catch (error) {
         if (error instanceof DeployExecutionError) {
           printDeployExecutionError(error);
@@ -6952,7 +7310,7 @@ import path9 from "node:path";
 import Docker from "dockerode";
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/connection-options.ts
-import { existsSync as existsSync18, readFileSync as readFileSync16 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync16 } from "node:fs";
 import path6 from "node:path";
 function asOptionalTlsBuffer(value) {
   if (typeof value !== "string") {
@@ -6964,7 +7322,7 @@ function asOptionalTlsBuffer(value) {
   if (normalized === "") {
     return void 0;
   }
-  if (existsSync18(normalized)) {
+  if (existsSync19(normalized)) {
     return readFileSync16(normalized);
   }
   const looksLikePath = /[\\/]/.test(normalized) || normalized.endsWith(".pem");
@@ -7175,7 +7533,7 @@ var DockerodeClient = class {
 var createDockerodeClient = (config) => new DockerodeClient(config);
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/env.ts
-import { existsSync as existsSync19, readFileSync as readFileSync17, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync20, readFileSync as readFileSync17, statSync as statSync8 } from "node:fs";
 import path7 from "node:path";
 function stripSurroundingQuotes(value) {
   const t = value.trim();
@@ -7192,7 +7550,7 @@ function loadEnvFromFile(envFilePath) {
     return {};
   }
   const targetPath = path7.resolve(envFilePath);
-  if (!existsSync19(targetPath) || !statSync8(targetPath).isFile()) {
+  if (!existsSync20(targetPath) || !statSync8(targetPath).isFile()) {
     return {};
   }
   const raw = readFileSync17(targetPath, "utf-8");
@@ -7366,12 +7724,12 @@ function dockerPushImage(params, cwd) {
 }
 
 // src/commands/deploy/internal/backend-deploy/resolve-dockerfile.ts
-import { existsSync as existsSync20 } from "node:fs";
+import { existsSync as existsSync21 } from "node:fs";
 import path8 from "node:path";
 function resolveDockerBuildPaths(cwd) {
   const dockerfilePath = path8.join(cwd, "Dockerfile");
   Logger.info(`\u67E5\u627EDockerfile\u6587\u4EF6\uFF0C\u8DEF\u5F84: ${dockerfilePath}`);
-  if (!existsSync20(dockerfilePath)) {
+  if (!existsSync21(dockerfilePath)) {
     throw new Error(`Dockerfile \u4E0D\u5B58\u5728\uFF1A${dockerfilePath}`);
   }
   Logger.info("\u2713 Dockerfile \u5B58\u5728");