ai-project-manage-cli 7.1.17 → 7.1.19

package/dist/index.js

@@ -333,13 +333,13 @@ var init_client = __esm({
 });
 
 // src/commands/deploy/internal/minio.ts
-import { statSync as statSync5 } from "node:fs";
+import { statSync as statSync6 } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import * as Minio from "minio";
 async function isDirectoryPath(dir) {
   try {
-    const st = statSync5(dir);
+    const st = statSync6(dir);
     return st.isDirectory();
   } catch {
     return false;
@@ -369,7 +369,7 @@ async function collectFiles(root) {
       if (e.isDirectory()) {
         await walk(abs, rel);
       } else if (e.isFile()) {
-        const st = statSync5(abs);
+        const st = statSync6(abs);
         out.push({
           absPath: abs,
           relativePath: rel.replace(/\\/g, "/"),
@@ -436,14 +436,14 @@ var init_minio = __esm({
       async deleteObjectsByPrefix(bucket, prefix) {
         const objectsStream = this.inner.listObjectsV2(bucket, prefix, true);
         const keys = [];
-        await new Promise((resolve7, reject) => {
+        await new Promise((resolve8, reject) => {
           objectsStream.on("data", (obj) => {
             if (obj.name) {
               keys.push(obj.name);
             }
           });
           objectsStream.on("error", reject);
-          objectsStream.on("end", resolve7);
+          objectsStream.on("end", resolve8);
         });
         const chunkSize = 500;
         for (let i = 0; i < keys.length; i += chunkSize) {
@@ -1099,8 +1099,8 @@ import { Command } from "commander";
 init_config();
 
 // src/commands/init.ts
-import { join as join5 } from "path";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
+import { join as join6 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "fs";
 
 // src/command-utils.ts
 init_config();
@@ -1388,13 +1388,43 @@ async function copyTemplateFiles(targetDir, workdir = resolveWorkdirPath()) {
 
 // src/deployment-config-sync.ts
 init_client();
-import { join as join3 } from "path";
-import { writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
+import { writeFileSync as writeFileSync4 } from "fs";
 
 // src/git-remote.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
+function toHttpsGitRemoteUrl(raw) {
+  let s = raw.trim();
+  if (!s) return null;
+  const sshScp = /^git@([^:]+):(.+)$/.exec(s);
+  if (sshScp) {
+    s = `https://${sshScp[1]}/${sshScp[2]}`;
+  } else {
+    const sshUri = /^ssh:\/\/(?:git@)?([^/]+)\/(.+)$/i.exec(s);
+    if (sshUri) {
+      s = `https://${sshUri[1]}/${sshUri[2]}`;
+    } else if (/^http:\/\//i.test(s)) {
+      s = `https://${s.slice("http://".length)}`;
+    } else if (!/^https:\/\//i.test(s)) {
+      const scpLike = /^([^/:]+):(.+)$/.exec(s);
+      if (scpLike && !scpLike[1].includes(".")) {
+        return null;
+      }
+      if (scpLike) {
+        s = `https://${scpLike[1]}/${scpLike[2]}`;
+      } else if (s.includes("/")) {
+        s = `https://${s}`;
+      } else {
+        return null;
+      }
+    }
+  }
+  s = s.replace(/\/+$/, "");
+  if (!/^https:\/\//i.test(s)) return null;
+  return s;
+}
 async function tryReadGitOriginUrl(cwd) {
   try {
     const { stdout } = await execFileAsync(
@@ -1408,6 +1438,11 @@ async function tryReadGitOriginUrl(cwd) {
     return null;
   }
 }
+async function tryReadHttpsGitOriginUrl(cwd) {
+  const raw = await tryReadGitOriginUrl(cwd);
+  if (!raw) return null;
+  return toHttpsGitRemoteUrl(raw);
+}
 
 // src/git-utils.ts
 import { execFile as execFile2 } from "child_process";
@@ -1470,6 +1505,24 @@ async function ensureRemoteBaselineBranch(cwd, baselineBranch) {
     `[apm] \u8FDC\u7A0B\u4E0D\u5B58\u5728\u57FA\u7EBF\u5206\u652F origin/${baselineBranch}\uFF0C\u8BF7\u786E\u8BA4\u4ED3\u5E93\u9ED8\u8BA4\u5206\u652F\u5DF2\u63A8\u9001\u5230 origin`
   );
 }
+async function resolveDefaultRemoteBranch(cwd) {
+  try {
+    const ref = (await execGit(cwd, ["symbolic-ref", "refs/remotes/origin/HEAD"], true)).trim();
+    const match = ref.match(/^refs\/remotes\/origin\/(.+)$/);
+    if (match?.[1]) {
+      return match[1];
+    }
+  } catch {
+  }
+  for (const candidate of ["main", "master"]) {
+    if (await remoteBranchExists(cwd, candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    "[apm] \u65E0\u6CD5\u786E\u5B9A\u8FDC\u7A0B\u9ED8\u8BA4\u5206\u652F\uFF08origin/HEAD\u3001main\u3001master \u5747\u4E0D\u53EF\u7528\uFF09"
+  );
+}
 async function hasUpstream(cwd) {
   try {
     await execGit(cwd, ["rev-parse", "--abbrev-ref", "@{upstream}"], true);
@@ -1596,6 +1649,162 @@ async function resolveBranchBaseline(api, sessionId, workdirPath) {
 
 // src/deployment-config-sync.ts
 init_config();
+
+// src/workspace-repos.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync2,
+  statSync as statSync2,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { basename as basename2, dirname as dirname2, join as join3, relative, resolve as resolve3 } from "path";
+var WORKSPACE_REPOS_MANIFEST = "workspace-repos.json";
+var WORKSPACE_REPOS_VERSION = 1;
+function manifestPath(workdir) {
+  return join3(workspaceApmDir(workdir), WORKSPACE_REPOS_MANIFEST);
+}
+function absoluteRepoPath(workdir, entry) {
+  if (entry.path === "." || entry.path === "") {
+    return workdir;
+  }
+  return resolve3(workdir, entry.path);
+}
+function normalizeRepoEntry(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const o = raw;
+  if (typeof o.path !== "string" || !o.path.trim()) return null;
+  const entry = {
+    path: o.path.trim().replace(/\\/g, "/")
+  };
+  if (typeof o.remoteUrl === "string" && o.remoteUrl.trim()) {
+    entry.remoteUrl = o.remoteUrl.trim();
+  } else if (o.remoteUrl === null) {
+    entry.remoteUrl = null;
+  }
+  return entry;
+}
+function readManifest(workdir) {
+  const path19 = toFsPath(manifestPath(workdir));
+  if (!existsSync2(path19)) {
+    return null;
+  }
+  try {
+    const raw = JSON.parse(
+      readFileSync3(path19, "utf8")
+    );
+    if (raw?.version !== WORKSPACE_REPOS_VERSION) {
+      return null;
+    }
+    if (raw.kind !== "single" && raw.kind !== "multi") {
+      return null;
+    }
+    if (!Array.isArray(raw.repos) || raw.repos.length === 0) {
+      return null;
+    }
+    if (typeof raw.workdir !== "string" || !raw.workdir.trim()) {
+      return null;
+    }
+    const repos = raw.repos.map((item) => normalizeRepoEntry(item)).filter((item) => item != null);
+    if (repos.length === 0) {
+      return null;
+    }
+    return {
+      version: WORKSPACE_REPOS_VERSION,
+      kind: raw.kind,
+      workdir: raw.workdir,
+      repos,
+      scannedAt: typeof raw.scannedAt === "string" && raw.scannedAt.trim() ? raw.scannedAt : (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch {
+    return null;
+  }
+}
+function writeManifest(workdir, manifest) {
+  const apmDir = toFsPath(workspaceApmDir(workdir));
+  mkdirSync3(apmDir, { recursive: true });
+  const path19 = toFsPath(manifestPath(workdir));
+  writeFileSync3(path19, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+function isPathInsideOrEqual(parentAbs, childAbs) {
+  const parent = normalizeWorkdirPath(parentAbs);
+  const child = normalizeWorkdirPath(childAbs);
+  if (child === parent) return true;
+  const prefix = parent.endsWith("/") ? parent : `${parent}/`;
+  return child.startsWith(prefix);
+}
+function findWorkspaceReposManifestNearPath(startDirInput) {
+  let current = resolve3(startDirInput);
+  for (; ; ) {
+    const candidates = /* @__PURE__ */ new Set([normalizeWorkdirPath(current)]);
+    try {
+      if (existsSync2(toFsPath(current))) {
+        candidates.add(resolveWorkdirPath(current));
+      }
+    } catch {
+    }
+    for (const candidate of candidates) {
+      const cached = readManifest(candidate);
+      if (!cached) continue;
+      const cachedWorkdir = resolveWorkdirPath(cached.workdir);
+      const candidateNorm = resolveWorkdirPath(candidate);
+      if (cachedWorkdir === candidateNorm) {
+        return { ...cached, workdir: cachedWorkdir };
+      }
+    }
+    const parent = dirname2(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function matchWorkspaceRepoEntryForPath(manifest, pathInput) {
+  const target = resolveWorkdirPath(pathInput);
+  const workdir = resolveWorkdirPath(manifest.workdir);
+  let best = null;
+  let bestLen = -1;
+  for (const entry of manifest.repos) {
+    const abs = resolveWorkdirPath(absoluteRepoPath(workdir, entry));
+    if (!isPathInsideOrEqual(abs, target)) {
+      continue;
+    }
+    if (abs.length > bestLen) {
+      best = entry;
+      bestLen = abs.length;
+    }
+  }
+  return best;
+}
+async function enrichWorkspaceReposRemoteUrls(manifest) {
+  let changed = false;
+  const repos = [];
+  for (const entry of manifest.repos) {
+    const abs = absoluteRepoPath(manifest.workdir, entry);
+    const remoteUrl = await tryReadHttpsGitOriginUrl(abs);
+    const next = {
+      path: entry.path,
+      remoteUrl: remoteUrl || null
+    };
+    if ((entry.remoteUrl ?? null) !== next.remoteUrl) {
+      changed = true;
+    }
+    repos.push(next);
+  }
+  const nextManifest = {
+    ...manifest,
+    repos,
+    scannedAt: changed ? (/* @__PURE__ */ new Date()).toISOString() : manifest.scannedAt
+  };
+  if (changed) {
+    writeManifest(manifest.workdir, nextManifest);
+  }
+  return nextManifest;
+}
+
+// src/deployment-config-sync.ts
 var TEMPLATE_HINT = "\u4FDD\u7559\u6A21\u677F .apm/apm.config.json";
 var SYNC_HINT = "\u767B\u8BB0\u5DE5\u4F5C\u7A7A\u95F4\u8DEF\u5F84\u3001\u7ED1\u5B9A\u4ED3\u5E93\u540E\uFF0C\u53EF\u6267\u884C: apm sync-deploy-config";
 async function resolveRepositoryIdForSync(api, workdirPath) {
@@ -1610,7 +1819,73 @@ async function resolveRepositoryIdForSync(api, workdirPath) {
     };
   }
 }
-async function syncRemoteDeploymentConfig(workdirPath, apmDir) {
+async function resolveDeployCwdForRepository(workspaceRoot, repositoryId, api) {
+  const start = resolveWorkdirPath(workspaceRoot);
+  let manifest = findWorkspaceReposManifestNearPath(start);
+  if (!manifest) {
+    return null;
+  }
+  try {
+    manifest = await enrichWorkspaceReposRemoteUrls(manifest);
+  } catch {
+    return null;
+  }
+  let client = api;
+  if (!client) {
+    const cfg = await tryReadApmConfig();
+    if (!cfg || !resolveApiKey(cfg)) {
+      return null;
+    }
+    client = createApmApiClient(cfg);
+  }
+  for (const entry of manifest.repos) {
+    const abs = absoluteRepoPath(manifest.workdir, entry);
+    const remoteUrl = toHttpsGitRemoteUrl(entry.remoteUrl ?? "");
+    if (!remoteUrl) {
+      continue;
+    }
+    let baseBranch = "";
+    try {
+      const gitRoot = await resolveGitRepoRoot(abs);
+      baseBranch = (await resolveDefaultRemoteBranch(gitRoot)).trim();
+    } catch {
+      continue;
+    }
+    if (!baseBranch) {
+      continue;
+    }
+    try {
+      const matched = await client.cli.matchRepository({
+        url: remoteUrl,
+        baseBranch
+      });
+      if (matched.repositoryId?.trim() === repositoryId) {
+        return abs;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function writeDeploymentConfigContent(apmDir, content, configName) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    console.warn(
+      `[apm] \u8FDC\u7A0B\u90E8\u7F72\u914D\u7F6E\u300C${configName}\u300DJSON \u65E0\u6548\uFF08${TEMPLATE_HINT}\uFF09`
+    );
+    return false;
+  }
+  const apmConfigPath = toFsPath(join4(apmDir, "apm.config.json"));
+  writeFileSync4(apmConfigPath, `${JSON.stringify(parsed, null, 2)}
+`, "utf8");
+  console.log(`[apm] \u5DF2\u540C\u6B65\u5E73\u53F0\u90E8\u7F72\u914D\u7F6E: ${configName}`);
+  console.log("[apm] \u5DF2\u5199\u5165 .apm/apm.config.json");
+  return true;
+}
+async function syncRemoteDeploymentConfig(workdirPath, apmDir, options) {
   const cfg = await tryReadApmConfig();
   if (!cfg || !resolveApiKey(cfg)) {
     console.log(
@@ -1620,10 +1895,14 @@ async function syncRemoteDeploymentConfig(workdirPath, apmDir) {
     return { synced: false, repositoryId: null };
   }
   const api = createApmApiClient(cfg);
-  const { repositoryId, diagnostic } = await resolveRepositoryIdForSync(
-    api,
-    workdirPath
-  );
+  const preferredId = options?.repositoryId?.trim() || "";
+  let repositoryId = preferredId || null;
+  let diagnostic = null;
+  if (!repositoryId) {
+    const resolved = await resolveRepositoryIdForSync(api, workdirPath);
+    repositoryId = resolved.repositoryId;
+    diagnostic = resolved.diagnostic;
+  }
   if (!repositoryId) {
     console.log(
       `[apm] \u672A\u80FD\u540C\u6B65\u5E73\u53F0\u90E8\u7F72\u914D\u7F6E\uFF08${TEMPLATE_HINT}\uFF09\u3002
@@ -1640,21 +1919,15 @@ ${diagnostic ?? ""}
     );
     return { synced: false, repositoryId };
   }
-  let parsed;
-  try {
-    parsed = JSON.parse(config.content);
-  } catch {
-    console.warn(
-      `[apm] \u8FDC\u7A0B\u90E8\u7F72\u914D\u7F6E\u300C${config.name}\u300DJSON \u65E0\u6548\uFF08${TEMPLATE_HINT}\uFF09`
-    );
+  const targetApmDir = apmDir ?? workspaceApmDir(workdirPath);
+  const wrote = await writeDeploymentConfigContent(
+    targetApmDir,
+    config.content,
+    config.name
+  );
+  if (!wrote) {
     return { synced: false, repositoryId };
   }
-  const targetApmDir = apmDir ?? workspaceApmDir(workdirPath);
-  const apmConfigPath = toFsPath(join3(targetApmDir, "apm.config.json"));
-  writeFileSync3(apmConfigPath, `${JSON.stringify(parsed, null, 2)}
-`, "utf8");
-  console.log(`[apm] \u5DF2\u540C\u6B65\u5E73\u53F0\u90E8\u7F72\u914D\u7F6E: ${config.name}`);
-  console.log("[apm] \u5DF2\u5199\u5165 .apm/apm.config.json");
   return { synced: true, repositoryId, configName: config.name };
 }
 
@@ -1662,14 +1935,14 @@ ${diagnostic ?? ""}
 init_client();
 init_config();
 import {
-  existsSync as existsSync2,
-  readdirSync as readdirSync2,
-  readFileSync as readFileSync3,
+  existsSync as existsSync3,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync4,
   rmSync,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "fs";
 import { createHash } from "crypto";
-import { dirname as dirname2, join as join4, relative, sep } from "path";
+import { dirname as dirname3, join as join5, relative as relative2, sep } from "path";
 var MANIFEST_FILE = "manifest.json";
 function normalizeProjectIdForPath(projectId) {
   const id = projectId.trim();
@@ -1683,11 +1956,11 @@ function normalizeProjectIdForPath(projectId) {
 }
 function projectDocumentsDir(apmRoot, projectId) {
   const id = normalizeProjectIdForPath(projectId);
-  return join4(apmRoot ?? workspaceApmDir(), "project", id);
+  return join5(apmRoot ?? workspaceApmDir(), "project", id);
 }
 function projectDocumentLocalPath(apmRoot, projectId, documentPath) {
   const normalized = normalizeLocalDocumentPath(documentPath);
-  return join4(
+  return join5(
     projectDocumentsDir(apmRoot, projectId),
     ...normalized.split("/")
   );
@@ -1707,16 +1980,16 @@ function hashLocalFileContent(content) {
   return createHash("sha256").update(content, "utf8").digest("hex");
 }
 function readLocalManifest(apmRoot, projectId) {
-  const manifestPath2 = join4(
+  const manifestPath3 = join5(
     projectDocumentsDir(apmRoot, projectId),
     MANIFEST_FILE
   );
-  if (!existsSync2(manifestPath2)) {
+  if (!existsSync3(manifestPath3)) {
     return null;
   }
   try {
     return JSON.parse(
-      readFileSync3(manifestPath2, "utf8")
+      readFileSync4(manifestPath3, "utf8")
     );
   } catch {
     return null;
@@ -1724,13 +1997,13 @@ function readLocalManifest(apmRoot, projectId) {
 }
 function listLocalDocumentPaths(apmRoot, projectId) {
   const root = projectDocumentsDir(apmRoot, projectId);
-  if (!existsSync2(root)) {
+  if (!existsSync3(root)) {
     return [];
   }
   const paths = [];
   const walk = (dir) => {
-    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-      const abs = join4(dir, entry.name);
+    for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+      const abs = join5(dir, entry.name);
       if (entry.isDirectory()) {
         walk(abs);
         continue;
@@ -1738,7 +2011,7 @@ function listLocalDocumentPaths(apmRoot, projectId) {
       if (entry.isFile() && entry.name === MANIFEST_FILE) {
         continue;
       }
-      const rel = relative(root, abs).split(sep).join("/");
+      const rel = relative2(root, abs).split(sep).join("/");
       paths.push(rel);
     }
   };
@@ -1848,8 +2121,8 @@ ${diagnostic ?? ""}`);
       const absPath = toFsPath(
         projectDocumentLocalPath(targetApmDir, projectId, doc.path)
       );
-      await ensureDirExists(dirname2(absPath));
-      writeFileSync4(absPath, doc.content, "utf8");
+      await ensureDirExists(dirname3(absPath));
+      writeFileSync5(absPath, doc.content, "utf8");
       downloaded += 1;
     }
   }
@@ -1858,13 +2131,13 @@ ${diagnostic ?? ""}`);
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path19)
     );
-    if (existsSync2(absPath)) {
+    if (existsSync3(absPath)) {
       rmSync(absPath, { force: true });
       deleted += 1;
     }
   }
-  writeFileSync4(
-    toFsPath(join4(docsDir, MANIFEST_FILE)),
+  writeFileSync5(
+    toFsPath(join5(docsDir, MANIFEST_FILE)),
     `${JSON.stringify(remoteManifest, null, 2)}
 `,
     "utf8"
@@ -1907,7 +2180,7 @@ async function syncProjectDocumentsPush(cfg, workdirPath, apmRoot, options) {
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path19)
     );
-    const content = readFileSync3(absPath, "utf8");
+    const content = readFileSync4(absPath, "utf8");
     const contentHash = hashLocalFileContent(content);
     if (remoteHashByPath.get(path19) === contentHash) {
       continue;
@@ -1946,11 +2219,11 @@ async function ensureWorkspaceInitialized(workdir, options) {
   await syncProjectDocumentsPull(workdir, apmDir);
   const trimmedName = options?.name?.trim();
   if (trimmedName) {
-    const apmConfigPath = toFsPath(join5(apmDir, "apm.config.json"));
-    const config = readFileSync4(apmConfigPath, "utf8");
+    const apmConfigPath = toFsPath(join6(apmDir, "apm.config.json"));
+    const config = readFileSync5(apmConfigPath, "utf8");
     const configJson = JSON.parse(config);
     configJson.name = trimmedName;
-    writeFileSync5(
+    writeFileSync6(
       apmConfigPath,
       `${JSON.stringify(configJson, null, 2)}
 `,
@@ -1983,7 +2256,7 @@ async function runInit(name) {
 // src/commands/login.ts
 init_config();
 init_client();
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { ApiError } from "listpage-http";
 async function runLogin(opts) {
   const baseUrl = (opts.server?.trim() || process.env.AI_PM_SERVER?.trim() || DEFAULT_BASE_URL).replace(/\/+$/, "");
@@ -2038,7 +2311,7 @@ async function runLogin(opts) {
   );
   const workdir = resolveWorkdirPath();
   const apmDir = workspaceApmDir(workdir);
-  if (existsSync3(apmDir)) {
+  if (existsSync4(apmDir)) {
     await syncRemoteDeploymentConfig(workdir, apmDir);
   }
 }
@@ -2494,8 +2767,8 @@ async function runCleanBranches(options = {}) {
 
 // src/commands/pull.ts
 init_client();
-import { writeFileSync as writeFileSync9 } from "fs";
-import { join as join9 } from "path";
+import { writeFileSync as writeFileSync10 } from "fs";
+import { join as join10 } from "path";
 import { stringify as yamlStringify } from "yaml";
 
 // src/session-messages-xml.ts
@@ -2528,8 +2801,8 @@ function formatSessionMessagesXml(sessionId, messages) {
 }
 
 // src/commands/sync-session-attachments.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync6 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "fs";
+import { join as join7 } from "path";
 var MANIFEST_FILE2 = ".sync-manifest.json";
 async function downloadAttachment(cfg, attachmentId) {
   const base = cfg.baseUrl.trim().replace(/\/+$/, "");
@@ -2545,13 +2818,13 @@ async function downloadAttachment(cfg, attachmentId) {
   return Buffer.from(await res.arrayBuffer());
 }
 function loadManifest(dir) {
-  const path19 = join6(dir, MANIFEST_FILE2);
-  if (!existsSync4(path19)) {
+  const path19 = join7(dir, MANIFEST_FILE2);
+  if (!existsSync5(path19)) {
     return { version: 1, attachments: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync5(path19, "utf8")
+      readFileSync6(path19, "utf8")
     );
     if (parsed?.version === 1 && parsed.attachments && typeof parsed.attachments === "object") {
       return parsed;
@@ -2561,15 +2834,15 @@ function loadManifest(dir) {
   return { version: 1, attachments: {} };
 }
 function saveManifest(dir, manifest) {
-  writeFileSync6(
-    join6(dir, MANIFEST_FILE2),
+  writeFileSync7(
+    join7(dir, MANIFEST_FILE2),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
   );
 }
 function isAttachmentUpToDate(entry, item, dest) {
-  if (!entry || !existsSync4(dest)) return false;
+  if (!entry || !existsSync5(dest)) return false;
   if (entry.name !== item.name) return false;
   const createdAt = item.createdAt ?? "";
   return entry.createdAt === createdAt;
@@ -2584,7 +2857,7 @@ async function syncAttachmentsToDirectory(cfg, attachments, dir, logLabel) {
   const nextManifest = { version: 1, attachments: {} };
   const names = [];
   for (const item of attachments) {
-    const dest = join6(dir, item.name);
+    const dest = join7(dir, item.name);
     const entry = manifest.attachments[item.id];
     const createdAt = item.createdAt ?? "";
     names.push(item.name);
@@ -2594,7 +2867,7 @@ async function syncAttachmentsToDirectory(cfg, attachments, dir, logLabel) {
       continue;
     }
     const buffer = await downloadAttachment(cfg, item.id);
-    writeFileSync6(dest, buffer);
+    writeFileSync7(dest, buffer);
     nextManifest.attachments[item.id] = {
       name: item.name,
       createdAt
@@ -2605,7 +2878,7 @@ async function syncAttachmentsToDirectory(cfg, attachments, dir, logLabel) {
   return names;
 }
 async function syncSessionAttachments(cfg, sessionId, attachments, apmRoot) {
-  const dir = join6(sessionDir(sessionId, apmRoot), SESSION_ATTACHMENTS_SUBDIR);
+  const dir = join7(sessionDir(sessionId, apmRoot), SESSION_ATTACHMENTS_SUBDIR);
   return syncAttachmentsToDirectory(
     cfg,
     attachments,
@@ -2616,65 +2889,65 @@ async function syncSessionAttachments(cfg, sessionId, attachments, apmRoot) {
 
 // src/rules-sync.ts
 init_client();
-import { basename as basename2, extname as extname2, join as join8 } from "path";
-import { existsSync as existsSync6, readFileSync as readFileSync6, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "fs";
+import { basename as basename3, extname as extname2, join as join9 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync7, rmSync as rmSync3, writeFileSync as writeFileSync9 } from "fs";
 
 // src/skills-sync.ts
 import {
   copyFileSync as copyFileSync2,
   cpSync,
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync3,
-  readdirSync as readdirSync3,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync4,
   rmSync as rmSync2,
-  statSync as statSync2,
-  writeFileSync as writeFileSync7
+  statSync as statSync3,
+  writeFileSync as writeFileSync8
 } from "fs";
-import { join as join7 } from "path";
-var AGENTS_TEMPLATE_PATH = join7(CLI_TEMPLATE_DIR, "AGENTS.md");
-var BASE_SKILLS_TEMPLATE_DIR = join7(CLI_TEMPLATE_DIR, "skills");
-var BASE_RULES_TEMPLATE_DIR = join7(CLI_TEMPLATE_DIR, "rules");
+import { join as join8 } from "path";
+var AGENTS_TEMPLATE_PATH = join8(CLI_TEMPLATE_DIR, "AGENTS.md");
+var BASE_SKILLS_TEMPLATE_DIR = join8(CLI_TEMPLATE_DIR, "skills");
+var BASE_RULES_TEMPLATE_DIR = join8(CLI_TEMPLATE_DIR, "rules");
 function sanitizeSkillDirName(name) {
   const trimmed = name.trim();
   if (!trimmed) return "skill";
   return trimmed.replace(/[/\\:*?"<>|]/g, "_");
 }
 function listBaseSkillDirNames() {
-  if (!existsSync5(BASE_SKILLS_TEMPLATE_DIR)) return [];
-  return readdirSync3(BASE_SKILLS_TEMPLATE_DIR).filter((name) => {
-    const path19 = join7(BASE_SKILLS_TEMPLATE_DIR, name);
-    return statSync2(path19).isDirectory();
+  if (!existsSync6(BASE_SKILLS_TEMPLATE_DIR)) return [];
+  return readdirSync4(BASE_SKILLS_TEMPLATE_DIR).filter((name) => {
+    const path19 = join8(BASE_SKILLS_TEMPLATE_DIR, name);
+    return statSync3(path19).isDirectory();
   });
 }
 function syncAgentsGuide(apmDir) {
-  if (!existsSync5(AGENTS_TEMPLATE_PATH)) return false;
-  mkdirSync3(apmDir, { recursive: true });
-  copyFileSync2(AGENTS_TEMPLATE_PATH, join7(apmDir, "AGENTS.md"));
+  if (!existsSync6(AGENTS_TEMPLATE_PATH)) return false;
+  mkdirSync4(apmDir, { recursive: true });
+  copyFileSync2(AGENTS_TEMPLATE_PATH, join8(apmDir, "AGENTS.md"));
   return true;
 }
 function listBaseRuleFileNames() {
-  if (!existsSync5(BASE_RULES_TEMPLATE_DIR)) return [];
-  return readdirSync3(BASE_RULES_TEMPLATE_DIR).filter((name) => {
-    const path19 = join7(BASE_RULES_TEMPLATE_DIR, name);
-    return statSync2(path19).isFile();
+  if (!existsSync6(BASE_RULES_TEMPLATE_DIR)) return [];
+  return readdirSync4(BASE_RULES_TEMPLATE_DIR).filter((name) => {
+    const path19 = join8(BASE_RULES_TEMPLATE_DIR, name);
+    return statSync3(path19).isFile();
   });
 }
 function syncBaseRules(rulesDir) {
-  mkdirSync3(rulesDir, { recursive: true });
+  mkdirSync4(rulesDir, { recursive: true });
   const names = listBaseRuleFileNames();
   for (const name of names) {
-    const src = join7(BASE_RULES_TEMPLATE_DIR, name);
-    const dest = join7(rulesDir, name);
+    const src = join8(BASE_RULES_TEMPLATE_DIR, name);
+    const dest = join8(rulesDir, name);
     copyFileSync2(src, dest);
   }
   return names;
 }
 function syncBaseSkills(skillsDir) {
-  mkdirSync3(skillsDir, { recursive: true });
+  mkdirSync4(skillsDir, { recursive: true });
   const names = listBaseSkillDirNames();
   for (const name of names) {
-    const src = join7(BASE_SKILLS_TEMPLATE_DIR, name);
-    const dest = join7(skillsDir, name);
+    const src = join8(BASE_SKILLS_TEMPLATE_DIR, name);
+    const dest = join8(skillsDir, name);
     cpSync(src, dest, { recursive: true, force: true });
   }
   return names;
@@ -2691,16 +2964,16 @@ function syncSupplementarySkills(skillsDir, list) {
       skipped.push(dirName);
       continue;
     }
-    const skillDir = join7(skillsDir, dirName);
-    mkdirSync3(skillDir, { recursive: true });
-    writeFileSync7(join7(skillDir, "SKILL.md"), skill.content ?? "", "utf8");
+    const skillDir = join8(skillsDir, dirName);
+    mkdirSync4(skillDir, { recursive: true });
+    writeFileSync8(join8(skillDir, "SKILL.md"), skill.content ?? "", "utf8");
     written.push(dirName);
   }
   const removed = [];
-  if (!existsSync5(skillsDir)) return { written, skipped, removed };
-  for (const entry of readdirSync3(skillsDir)) {
-    const full = join7(skillsDir, entry);
-    if (!statSync2(full).isDirectory()) continue;
+  if (!existsSync6(skillsDir)) return { written, skipped, removed };
+  for (const entry of readdirSync4(skillsDir)) {
+    const full = join8(skillsDir, entry);
+    if (!statSync3(full).isDirectory()) continue;
     if (baseNames.has(entry)) continue;
     if (apiDirNames.has(entry)) continue;
     rmSync2(full, { recursive: true, force: true });
@@ -2719,13 +2992,13 @@ function ruleLocalFileName(ruleName) {
   return `${sanitized}.md`;
 }
 function loadManifest2(rulesDir) {
-  const path19 = join8(rulesDir, MANIFEST_FILE3);
-  if (!existsSync6(toFsPath(path19))) {
+  const path19 = join9(rulesDir, MANIFEST_FILE3);
+  if (!existsSync7(toFsPath(path19))) {
     return { version: 1, rules: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync6(toFsPath(path19), "utf8")
+      readFileSync7(toFsPath(path19), "utf8")
     );
     if (parsed?.version === 1 && parsed.rules && typeof parsed.rules === "object") {
       return parsed;
@@ -2735,29 +3008,29 @@ function loadManifest2(rulesDir) {
   return { version: 1, rules: {} };
 }
 function saveManifest2(rulesDir, manifest) {
-  writeFileSync8(
-    toFsPath(join8(rulesDir, MANIFEST_FILE3)),
+  writeFileSync9(
+    toFsPath(join9(rulesDir, MANIFEST_FILE3)),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
   );
 }
 function isBaseRuleFileName(fileName) {
-  return listBaseRuleFileNames().includes(basename2(fileName));
+  return listBaseRuleFileNames().includes(basename3(fileName));
 }
 function isRuleUpToDate(entry, rule, dest) {
-  if (!entry || !existsSync6(toFsPath(dest))) return false;
+  if (!entry || !existsSync7(toFsPath(dest))) return false;
   if (entry.fileName !== ruleLocalFileName(rule.name)) return false;
   const updatedAt = rule.updatedAt ?? "";
   if (entry.updatedAt !== updatedAt) return false;
-  const localContent = readFileSync6(toFsPath(dest), "utf8");
+  const localContent = readFileSync7(toFsPath(dest), "utf8");
   return localContent === (rule.content ?? "");
 }
 async function syncPlatformRules(cfg, sessionId, workdirPath, apmRoot) {
   const api = createApmApiClient(cfg);
   const baseline = await resolveBranchBaseline(api, sessionId, workdirPath);
   const repositoryId = baseline.repositoryId;
-  const rulesDir = join8(apmRoot ?? workspaceApmDir(workdirPath), "rules");
+  const rulesDir = join9(apmRoot ?? workspaceApmDir(workdirPath), "rules");
   await ensureDirExists(rulesDir);
   if (!repositoryId) {
     console.log(
@@ -2774,7 +3047,7 @@ async function syncPlatformRules(cfg, sessionId, workdirPath, apmRoot) {
   for (const rule of list) {
     remoteIds.add(rule.id);
     const fileName = ruleLocalFileName(rule.name);
-    const dest = join8(rulesDir, fileName);
+    const dest = join9(rulesDir, fileName);
     const entry = manifest.rules[rule.id];
     const updatedAt = rule.updatedAt ?? "";
     if (isRuleUpToDate(entry, rule, dest)) {
@@ -2783,7 +3056,7 @@ async function syncPlatformRules(cfg, sessionId, workdirPath, apmRoot) {
       console.log(`[apm] \u89C4\u5219\u65E0\u53D8\u5316\uFF0C\u5DF2\u8DF3\u8FC7: rules/${fileName}`);
       continue;
     }
-    writeFileSync8(toFsPath(dest), rule.content ?? "", "utf8");
+    writeFileSync9(toFsPath(dest), rule.content ?? "", "utf8");
     nextManifest.rules[rule.id] = { fileName, updatedAt };
     written.push(fileName);
     console.log(`[apm] \u5DF2\u540C\u6B65\u5E73\u53F0\u89C4\u5219: rules/${fileName}`);
@@ -2792,8 +3065,8 @@ async function syncPlatformRules(cfg, sessionId, workdirPath, apmRoot) {
   for (const [ruleId, entry] of Object.entries(manifest.rules)) {
     if (remoteIds.has(ruleId)) continue;
     if (isBaseRuleFileName(entry.fileName)) continue;
-    const dest = join8(rulesDir, entry.fileName);
-    if (existsSync6(toFsPath(dest))) {
+    const dest = join9(rulesDir, entry.fileName);
+    if (existsSync7(toFsPath(dest))) {
       rmSync3(toFsPath(dest), { force: true });
     }
     removed.push(entry.fileName);
@@ -2824,20 +3097,20 @@ async function runPull(sessionId, remoteWorkdir) {
   const dir = sessionDir(trimmedId, apmRoot);
   const docsDir = sessionDocsDir(trimmedId, apmRoot);
   await ensureDirExists(docsDir);
-  writeFileSync9(
+  writeFileSync10(
     sessionRulePath(trimmedId, apmRoot),
     detail.description ?? "",
     "utf8"
   );
-  writeFileSync9(
+  writeFileSync10(
     sessionTaskPath(trimmedId, apmRoot),
     detail.task.description ?? "",
     "utf8"
   );
-  writeFileSync9(sessionTodoPath(trimmedId, apmRoot), detail.todo ?? "", "utf8");
+  writeFileSync10(sessionTodoPath(trimmedId, apmRoot), detail.todo ?? "", "utf8");
   for (const doc of documents) {
     const fileName = documentLocalFileName(doc.name);
-    writeFileSync9(join9(docsDir, fileName), doc.content ?? "", "utf8");
+    writeFileSync10(join10(docsDir, fileName), doc.content ?? "", "utf8");
   }
   const sessionYaml = yamlStringify(
     {
@@ -2854,13 +3127,13 @@ async function runPull(sessionId, remoteWorkdir) {
     },
     { lineWidth: 0 }
   );
-  writeFileSync9(
+  writeFileSync10(
     sessionYamlPath(trimmedId, apmRoot),
     sessionYaml.endsWith("\n") ? sessionYaml : `${sessionYaml}
 `,
     "utf8"
   );
-  writeFileSync9(
+  writeFileSync10(
     sessionMessagesXmlPath(trimmedId, apmRoot),
     formatSessionMessagesXml(trimmedId, messages),
     "utf8"
@@ -2877,15 +3150,15 @@ async function runPull(sessionId, remoteWorkdir) {
 import { spawnSync } from "child_process";
 
 // src/version.ts
-import { readFileSync as readFileSync7 } from "fs";
-import { dirname as dirname3, join as join10 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname4, join as join11 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var CLI_PACKAGE_NAME = "ai-project-manage-cli";
 function readCliVersion() {
   try {
-    const dir = dirname3(fileURLToPath2(import.meta.url));
-    const pkgPath = join10(dir, "..", "package.json");
-    const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
+    const dir = dirname4(fileURLToPath2(import.meta.url));
+    const pkgPath = join11(dir, "..", "package.json");
+    const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -3039,15 +3312,15 @@ async function runUpdate(options = {}) {
 
 // src/commands/update-skills.ts
 init_client();
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, statSync as statSync3 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, statSync as statSync4 } from "fs";
+import { join as join12 } from "path";
 async function syncWorkspaceSkills(cfg, workdir) {
   const apmDir = workspaceApmDir(workdir);
   const fsApmDir = toFsPath(apmDir);
-  if (!existsSync7(fsApmDir)) {
+  if (!existsSync8(fsApmDir)) {
     throw new Error("[apm] \u672A\u627E\u5230 .apm \u76EE\u5F55\uFF0C\u8BF7\u5148\u6267\u884C apm init");
   }
-  const apmStat = statSync3(fsApmDir);
+  const apmStat = statSync4(fsApmDir);
   if (!apmStat.isDirectory()) {
     throw new Error(`[apm] \u8DEF\u5F84\u5DF2\u5B58\u5728\u4F46\u4E0D\u662F\u76EE\u5F55: ${apmDir}`);
   }
@@ -3056,13 +3329,13 @@ async function syncWorkspaceSkills(cfg, workdir) {
   if (syncAgentsGuide(apmDir)) {
     console.log("[apm] \u5DF2\u540C\u6B65 APM \u6307\u5357: .apm/AGENTS.md");
   }
-  const rulesDir = join11(apmDir, "rules");
+  const rulesDir = join12(apmDir, "rules");
   const ruleNames = syncBaseRules(rulesDir);
   for (const name of ruleNames) {
     console.log(`[apm] \u5DF2\u540C\u6B65\u57FA\u7840\u89C4\u5219: rules/${name}`);
   }
-  const skillsDir = join11(apmDir, "skills");
-  mkdirSync4(toFsPath(skillsDir), { recursive: true });
+  const skillsDir = join12(apmDir, "skills");
+  mkdirSync5(toFsPath(skillsDir), { recursive: true });
   const baseNames = syncBaseSkills(skillsDir);
   for (const name of baseNames) {
     console.log(`[apm] \u5DF2\u540C\u6B65\u57FA\u7840\u6280\u80FD: skills/${name}/`);
@@ -3088,11 +3361,11 @@ async function syncWorkspaceSkills(cfg, workdir) {
 }
 async function runUpdateSkills() {
   const apmDir = workspaceApmDir();
-  if (!existsSync7(apmDir)) {
+  if (!existsSync8(apmDir)) {
     console.error("[apm] \u672A\u627E\u5230 .apm \u76EE\u5F55\uFF0C\u8BF7\u5148\u6267\u884C apm init");
     process.exit(1);
   }
-  const apmStat = statSync3(apmDir);
+  const apmStat = statSync4(apmDir);
   if (!apmStat.isDirectory()) {
     throw new Error(`[apm] \u8DEF\u5F84\u5DF2\u5B58\u5728\u4F46\u4E0D\u662F\u76EE\u5F55: ${apmDir}`);
   }
@@ -3101,15 +3374,15 @@ async function runUpdateSkills() {
 }
 
 // src/commands/sync-deploy-config.ts
-import { existsSync as existsSync8, statSync as statSync4 } from "fs";
+import { existsSync as existsSync9, statSync as statSync5 } from "fs";
 async function runSyncDeployConfig() {
   const workdir = resolveWorkdirPath();
   const apmDir = workspaceApmDir(workdir);
-  if (!existsSync8(apmDir)) {
+  if (!existsSync9(apmDir)) {
     console.error("[apm] \u672A\u627E\u5230 .apm \u76EE\u5F55\uFF0C\u8BF7\u5148\u6267\u884C apm init");
     process.exit(1);
   }
-  const apmStat = statSync4(apmDir);
+  const apmStat = statSync5(apmDir);
   if (!apmStat.isDirectory()) {
     throw new Error(`[apm] \u8DEF\u5F84\u5DF2\u5B58\u5728\u4F46\u4E0D\u662F\u76EE\u5F55: ${apmDir}`);
   }
@@ -3140,8 +3413,8 @@ async function runSyncProjectDocuments(options) {
 }
 
 // src/commands/sync-document.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
-import { basename as basename3 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
+import { basename as basename4 } from "path";
 
 // src/assumptions/local-validate.ts
 var NO_ASSUMPTIONS_RE = /无[，,]?\s*口径均有依据/;
@@ -3311,13 +3584,13 @@ init_client();
 
 // src/commands/sync-session-documents.ts
 init_client();
-import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync8 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync9 } from "fs";
+import { join as join13 } from "path";
 function listLocalMarkdownFiles(docsDir) {
-  if (!existsSync9(docsDir)) {
+  if (!existsSync10(docsDir)) {
     return [];
   }
-  return readdirSync4(docsDir).filter(
+  return readdirSync5(docsDir).filter(
     (name) => name.toLowerCase().endsWith(".md")
   );
 }
@@ -3329,8 +3602,8 @@ function remoteDocumentByLocalName(remoteDocuments, localFileName) {
   });
 }
 async function upsertLocalDocumentFile(api, sessionId, docsDir, fileName) {
-  const absPath = join12(docsDir, fileName);
-  const content = readFileSync8(absPath, "utf8");
+  const absPath = join13(docsDir, fileName);
+  const content = readFileSync9(absPath, "utf8");
   const name = documentPlatformName(absPath);
   return api.cli.upsertDocument({
     sessionId,
@@ -3352,8 +3625,8 @@ async function syncSessionDocuments(cfg, sessionId, apmRoot, options) {
   const remoteDocuments = options?.remoteDocuments ?? await api.cli.listDocuments({ sessionId: trimmedSessionId });
   let synced = 0;
   for (const fileName of localFiles) {
-    const absPath = join12(docsDir, fileName);
-    const content = readFileSync8(absPath, "utf8");
+    const absPath = join13(docsDir, fileName);
+    const content = readFileSync9(absPath, "utf8");
     const remote = remoteDocumentByLocalName(remoteDocuments, fileName);
     if (remote && remote.content === content) {
       continue;
@@ -3386,7 +3659,7 @@ async function runSyncDocument(sessionId, options) {
     process.exit(1);
   }
   const absPath = resolveSessionDocumentPath(trimmedSessionId, fileArg);
-  if (!existsSync10(absPath)) {
+  if (!existsSync11(absPath)) {
     const docsDir2 = sessionDocsDir(trimmedSessionId);
     console.error(
       `[apm] \u6587\u6863\u4E0D\u5B58\u5728: ${absPath}
@@ -3394,10 +3667,10 @@ async function runSyncDocument(sessionId, options) {
     );
     process.exit(1);
   }
-  const fileName = basename3(absPath);
+  const fileName = basename4(absPath);
   const assumptionSource = resolveAssumptionSourceFromFileName(fileName);
   if (assumptionSource) {
-    const content = readFileSync9(absPath, "utf8");
+    const content = readFileSync10(absPath, "utf8");
     const validation = validateAssumptionsMarkdown(content, assumptionSource);
     if (!validation.ok) {
       printAssumptionValidationResult(validation);
@@ -3414,7 +3687,7 @@ async function runSyncDocument(sessionId, options) {
     api,
     trimmedSessionId,
     docsDir,
-    basename3(absPath)
+    basename4(absPath)
   );
   console.log(`[apm] \u5DF2\u540C\u6B65\u6587\u6863: ${doc.name} (id=${doc.id})`);
   const assumptionSync = doc.assumptionSync;
@@ -3652,6 +3925,7 @@ function validateDeployPush(o) {
       deploymentRunId: o.deploymentRunId.trim(),
       workdir: o.workdir.trim(),
       environment,
+      ...typeof o.repositoryId === "string" && o.repositoryId.trim() ? { repositoryId: o.repositoryId.trim() } : {},
       ...o.packOnly === true ? { packOnly: true } : {}
     }
   };
@@ -3759,8 +4033,8 @@ init_client();
 import path11 from "node:path";
 
 // src/commands/deploy/internal/apm-config.ts
-import { existsSync as existsSync12, readFileSync as readFileSync11 } from "node:fs";
-import { resolve as resolve4 } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync12 } from "node:fs";
+import { resolve as resolve5 } from "node:path";
 
 // src/commands/deploy/internal/config/config-validation.ts
 function req(v, field, section) {
@@ -3852,9 +4126,9 @@ function resolveFrontendDeployFromApmConfig(cfg) {
 }
 
 // src/commands/deploy/internal/config/maven-repo.ts
-import { existsSync as existsSync11, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync11 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join13, resolve as resolve3 } from "node:path";
+import { join as join14, resolve as resolve4 } from "node:path";
 var MAVEN_REPO_ENV_KEYS = [
   "MAVEN_LOCAL_REPO",
   "M2_REPO",
@@ -3887,7 +4161,7 @@ function expandUserPath(pathStr, env = process.env) {
   if (/^[a-zA-Z]:[/\\]/.test(expanded)) {
     return expanded;
   }
-  return resolve3(expanded);
+  return resolve4(expanded);
 }
 function readMavenLocalRepoFromMavenOpts(mavenOpts, env = process.env) {
   const match = mavenOpts.match(/-Dmaven\.repo\.local=(?:"([^"]+)"|(\S+))/);
@@ -3911,12 +4185,12 @@ function readMavenLocalRepoFromEnv(env = process.env) {
   return null;
 }
 function readMavenLocalRepoFromSettings() {
-  const settingsPath = join13(homedir2(), ".m2", "settings.xml");
-  if (!existsSync11(settingsPath)) {
+  const settingsPath = join14(homedir2(), ".m2", "settings.xml");
+  if (!existsSync12(settingsPath)) {
     return null;
   }
   try {
-    const xml = readFileSync10(settingsPath, "utf8");
+    const xml = readFileSync11(settingsPath, "utf8");
     const match = xml.match(
       /<localRepository>\s*([^<]+?)\s*<\/localRepository>/
     );
@@ -3947,7 +4221,7 @@ function resolveMavenLocalRepoWithSource() {
     };
   }
   return {
-    path: join13(homedir2(), ".m2", "repository"),
+    path: join14(homedir2(), ".m2", "repository"),
     source: "default",
     sourceDetail: "~/.m2/repository"
   };
@@ -4043,16 +4317,16 @@ function resolveWisdomBackendDeployFromApmConfig(cfg) {
 
 // src/commands/deploy/internal/apm-config.ts
 function loadApmConfig(options) {
-  const p = resolve4(
+  const p = resolve5(
     process.cwd(),
-    options?.configPath ?? resolve4(workspaceApmDir(), "apm.config.json")
+    options?.configPath ?? resolve5(workspaceApmDir(), "apm.config.json")
   );
-  if (!existsSync12(p)) {
+  if (!existsSync13(p)) {
     console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
     process.exit(1);
   }
   try {
-    const raw = readFileSync11(p, "utf8");
+    const raw = readFileSync12(p, "utf8");
     return JSON.parse(raw);
   } catch (e) {
     console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
@@ -4098,32 +4372,32 @@ var DeployExecutionError = class extends Error {
 // src/commands/deploy/deploy-debug-log.ts
 init_deploy_artifact_minio();
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync16 } from "node:fs";
-import { dirname as dirname5, join as join17 } from "node:path";
+import { existsSync as existsSync17 } from "node:fs";
+import { dirname as dirname6, join as join18 } from "node:path";
 
 // src/commands/deploy/internal/deploy-shell-env.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync15 } from "node:fs";
-import { dirname as dirname4, join as join16 } from "node:path";
+import { existsSync as existsSync16 } from "node:fs";
+import { dirname as dirname5, join as join17 } from "node:path";
 
 // src/commands/daemon.ts
 init_config();
 import { spawnSync as spawnSync2 } from "child_process";
 import { setTimeout as delay } from "node:timers/promises";
-import { existsSync as existsSync14, mkdirSync as mkdirSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, unlinkSync as unlinkSync2, writeFileSync as writeFileSync12 } from "fs";
+import { join as join16 } from "path";
 
 // src/commands/connect-lock.ts
 init_config();
 import {
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync12,
+  existsSync as existsSync14,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync13,
   unlinkSync,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "fs";
-import { join as join14 } from "path";
-var CONNECT_LOCK_PATH = join14(APM_CONFIG_DIR, "connect.lock");
+import { join as join15 } from "path";
+var CONNECT_LOCK_PATH = join15(APM_CONFIG_DIR, "connect.lock");
 function isProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
@@ -4150,9 +4424,9 @@ function waitForPm2LockHandoff(timeoutMs = 5e3) {
   }
 }
 function readConnectLock() {
-  if (!existsSync13(CONNECT_LOCK_PATH)) return null;
+  if (!existsSync14(CONNECT_LOCK_PATH)) return null;
   try {
-    const raw = readFileSync12(CONNECT_LOCK_PATH, "utf8");
+    const raw = readFileSync13(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;
@@ -4187,13 +4461,13 @@ function acquireConnectLock(mode) {
       process.exit(1);
     }
   }
-  mkdirSync5(APM_CONFIG_DIR, { recursive: true });
+  mkdirSync6(APM_CONFIG_DIR, { recursive: true });
   const lock = {
     pid: process.pid,
     mode,
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync10(
+  writeFileSync11(
     CONNECT_LOCK_PATH,
     JSON.stringify(lock, null, 2) + "\n",
     "utf8"
@@ -4209,7 +4483,7 @@ function releaseConnectLock() {
 }
 function forceReleaseConnectLock() {
   try {
-    if (existsSync13(CONNECT_LOCK_PATH)) {
+    if (existsSync14(CONNECT_LOCK_PATH)) {
       unlinkSync(CONNECT_LOCK_PATH);
     }
   } catch {
@@ -4218,16 +4492,16 @@ function forceReleaseConnectLock() {
 
 // src/commands/daemon.ts
 var PM2_APP_NAME = "apm-connect";
-var PM2_ECOSYSTEM_PATH = join15(
+var PM2_ECOSYSTEM_PATH = join16(
   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(
+var PM2_CONNECT_ENTRY_PATH = join16(APM_CONFIG_DIR, "connect.entry.cjs");
+var PM2_CONNECT_LAUNCH_PATH = join16(
   APM_CONFIG_DIR,
   "connect.launch.json"
 );
-var LEGACY_PM2_ECOSYSTEM_PATH = join15(
+var LEGACY_PM2_ECOSYSTEM_PATH = join16(
   APM_CONFIG_DIR,
   "connect.ecosystem.cjs"
 );
@@ -4358,8 +4632,8 @@ function resolvePm2FromNpmRoot() {
   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)) {
+    const candidate = join16(root, ...rel.split("/"));
+    if (existsSync15(candidate)) {
       return candidate;
     }
   }
@@ -4396,7 +4670,7 @@ function spawnPm2At(binPath, args, options = {}) {
   return spawnPm2Target(buildPm2SpawnTarget(binPath), args, options);
 }
 function verifyPm2Bin(pm2Bin) {
-  if (!pm2Bin.trim() || !existsSync14(pm2Bin)) {
+  if (!pm2Bin.trim() || !existsSync15(pm2Bin)) {
     return false;
   }
   const result = spawnPm2At(pm2Bin, ["--version"], {
@@ -4409,10 +4683,10 @@ function collectPm2Candidates() {
   const globalBin = resolveNpmGlobalBin();
   if (globalBin) {
     if (useNpmShell2) {
-      candidates.push(join15(globalBin, "pm2.cmd"));
-      candidates.push(join15(globalBin, "pm2"));
+      candidates.push(join16(globalBin, "pm2.cmd"));
+      candidates.push(join16(globalBin, "pm2"));
     } else {
-      candidates.push(join15(globalBin, "pm2"));
+      candidates.push(join16(globalBin, "pm2"));
     }
   }
   const fromRoot = resolvePm2FromNpmRoot();
@@ -4535,7 +4809,7 @@ function ensureGlobalPm2(options) {
 }
 function resolveApmEntryPath(entryArg = process.argv[1]) {
   const fromArgv = entryArg?.trim();
-  if (fromArgv && existsSync14(fromArgv)) {
+  if (fromArgv && existsSync15(fromArgv)) {
     return fromArgv;
   }
   const npmResult = spawnSync2(useNpmShell2 ? "npm.cmd" : "npm", ["root", "-g"], {
@@ -4546,8 +4820,8 @@ function resolveApmEntryPath(entryArg = process.argv[1]) {
   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)) {
+      const candidate = join16(globalRoot, CLI_PACKAGE_NAME, "dist", "index.js");
+      if (existsSync15(candidate)) {
         return candidate;
       }
     }
@@ -4705,8 +4979,8 @@ async function resolveBaseUrl(server) {
   return cfg?.baseUrl;
 }
 function writeConnectLaunchFiles(options) {
-  mkdirSync6(APM_CONFIG_DIR, { recursive: true });
-  writeFileSync11(PM2_CONNECT_ENTRY_PATH, CONNECT_ENTRY_SCRIPT, "utf8");
+  mkdirSync7(APM_CONFIG_DIR, { recursive: true });
+  writeFileSync12(PM2_CONNECT_ENTRY_PATH, CONNECT_ENTRY_SCRIPT, "utf8");
   const env = {
     ...collectPm2LaunchEnv()
   };
@@ -4721,7 +4995,7 @@ function writeConnectLaunchFiles(options) {
     cwd: options.cwd,
     env
   };
-  writeFileSync11(
+  writeFileSync12(
     PM2_CONNECT_LAUNCH_PATH,
     JSON.stringify(launch, null, 2) + "\n",
     "utf8"
@@ -4733,12 +5007,12 @@ function writeEcosystemFile(options) {
     entryScript: PM2_CONNECT_ENTRY_PATH,
     baseUrl: options.baseUrl
   });
-  writeFileSync11(
+  writeFileSync12(
     PM2_ECOSYSTEM_PATH,
     formatConnectPm2EcosystemFile(ecosystem),
     "utf8"
   );
-  if (existsSync14(LEGACY_PM2_ECOSYSTEM_PATH)) {
+  if (existsSync15(LEGACY_PM2_ECOSYSTEM_PATH)) {
     try {
       unlinkSync2(LEGACY_PM2_ECOSYSTEM_PATH);
     } catch {
@@ -4897,14 +5171,14 @@ function writeEnvPath(env, value) {
   env.PATH = value;
 }
 function resolveNodeInstallDir() {
-  return dirname4(process.execPath);
+  return dirname5(process.execPath);
 }
 function resolveNpmCmdPath() {
   if (process.platform !== "win32") {
     return null;
   }
-  const candidate = join16(resolveNodeInstallDir(), "npm.cmd");
-  return existsSync15(candidate) ? candidate : null;
+  const candidate = join17(resolveNodeInstallDir(), "npm.cmd");
+  return existsSync16(candidate) ? candidate : null;
 }
 function formatNpmRunShellCommand(scriptName) {
   const trimmed = scriptName.trim();
@@ -5076,7 +5350,7 @@ function logExecuteDeployContext(input) {
   const deploymentRunId = process.env[APM_DEPLOYMENT_RUN_ID_ENV]?.trim() || null;
   const shellEnv = buildDeployShellEnv();
   const npmGlobalBin = resolveNpmGlobalBin2();
-  const packageJsonPath = join17(input.cwd, "package.json");
+  const packageJsonPath = join18(input.cwd, "package.json");
   logLine("========== executeDeploy \u4E0A\u4E0B\u6587 ==========");
   logLine(`trigger=${trigger} deployEnv=${input.env}`);
   logLine(`cwd(input)=${input.cwdInput}`);
@@ -5086,12 +5360,12 @@ function logExecuteDeployContext(input) {
     `cwdMatchProcess=${input.cwd === input.processCwd ? "yes" : "no"} (connect \u901A\u5E38\u4E3A no)`
   );
   logLine(
-    `apm.config=${input.apmConfigPath} exists=${existsSync16(
+    `apm.config=${input.apmConfigPath} exists=${existsSync17(
       input.apmConfigPath
     )}`
   );
   logLine(
-    `package.json=${packageJsonPath} exists=${existsSync16(packageJsonPath)}`
+    `package.json=${packageJsonPath} exists=${existsSync17(packageJsonPath)}`
   );
   logLine(
     `flags captureOutput=${input.captureOutput} packOnly=${Boolean(
@@ -5105,7 +5379,7 @@ function logExecuteDeployContext(input) {
   );
   logLine(`process argv=${process.argv.join(" ")}`);
   logLine(`npmGlobalBin=${npmGlobalBin ?? "(resolve failed)"}`);
-  logLine(`nodeDir=${dirname5(process.execPath)}`);
+  logLine(`nodeDir=${dirname6(process.execPath)}`);
   logLine("--- process.env\uFF08\u8282\u9009\uFF09---");
   for (const [key, value] of Object.entries(
     collectInterestingEnv(process.env)
@@ -5147,14 +5421,14 @@ function logWisdomFrontendDeployContext(input) {
   logLine(
     `buildKey=build:${input.env} buildCmd=${input.buildCmd ?? "(missing)"}`
   );
-  logLine(`distDir=${input.distDir} exists=${existsSync16(input.distDir)}`);
+  logLine(`distDir=${input.distDir} exists=${existsSync17(input.distDir)}`);
   logLine(
     `packOnly=${input.packOnly} archiveDeployArtifact=${input.archiveDeployArtifact}`
   );
 }
 
 // src/commands/deploy/internal/wisdom-deploy.ts
-import { existsSync as existsSync20, readFileSync as readFileSync15, statSync as statSync9 } from "node:fs";
+import { existsSync as existsSync21, readFileSync as readFileSync16, statSync as statSync10 } from "node:fs";
 import path10 from "node:path";
 
 // src/commands/deploy/deploy-shell-run.ts
@@ -5253,22 +5527,22 @@ init_deploy_artifact_minio();
 
 // src/commands/deploy/internal/wisdom-backend/jar-incremental.ts
 import {
-  mkdirSync as mkdirSync8,
-  readdirSync as readdirSync5,
-  readFileSync as readFileSync14,
-  statSync as statSync7,
-  writeFileSync as writeFileSync13
+  mkdirSync as mkdirSync9,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync15,
+  statSync as statSync8,
+  writeFileSync as writeFileSync14
 } from "node:fs";
 import path6 from "node:path";
 import JSZip2 from "jszip";
 
 // src/commands/deploy/internal/wisdom-backend/manifest.ts
 import {
-  existsSync as existsSync17,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync13,
-  statSync as statSync6,
-  writeFileSync as writeFileSync12
+  existsSync as existsSync18,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync14,
+  statSync as statSync7,
+  writeFileSync as writeFileSync13
 } from "node:fs";
 import path2 from "node:path";
 function deployCacheDir() {
@@ -5281,20 +5555,20 @@ function relativeKey(projectRoot, filePath) {
   return path2.relative(projectRoot, filePath).split(path2.sep).join("/");
 }
 function fileSignature(filePath) {
-  const stat2 = statSync6(filePath);
+  const stat2 = statSync7(filePath);
   return { size: stat2.size, mtime: stat2.mtimeMs / 1e3 };
 }
 function loadManifest3() {
-  const manifestPath2 = manifestFilePath();
-  if (!existsSync17(manifestPath2)) {
+  const manifestPath3 = manifestFilePath();
+  if (!existsSync18(manifestPath3)) {
     return {};
   }
-  return JSON.parse(readFileSync13(manifestPath2, "utf8"));
+  return JSON.parse(readFileSync14(manifestPath3, "utf8"));
 }
 function saveManifest3(manifest) {
   const dir = deployCacheDir();
-  mkdirSync7(dir, { recursive: true });
-  writeFileSync12(manifestFilePath(), JSON.stringify(manifest, null, 2), "utf8");
+  mkdirSync8(dir, { recursive: true });
+  writeFileSync13(manifestFilePath(), JSON.stringify(manifest, null, 2), "utf8");
 }
 function updateManifestEntries(manifest, entries, projectRoot) {
   for (const entry of entries) {
@@ -5427,7 +5701,7 @@ function buildSftpConnectOptions(settings) {
   };
 }
 async function sleep(ms) {
-  await new Promise((resolve7) => setTimeout(resolve7, ms));
+  await new Promise((resolve8) => setTimeout(resolve8, ms));
 }
 async function uploadZipWithRetry(settings, localZip, remoteZipPath) {
   let lastError;
@@ -5471,7 +5745,7 @@ async function ensureRemoteDir(sftp, dir) {
   }
 }
 function execCommand(client, command) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     client.exec(command, (err, stream) => {
       if (err) return reject(err);
       let stdout = "";
@@ -5481,7 +5755,7 @@ function execCommand(client, command) {
           reject(new Error(`\u8FDC\u7A0B\u547D\u4EE4\u5931\u8D25 (${code}): ${stderr || stdout}`));
           return;
         }
-        resolve7(stdout);
+        resolve8(stdout);
       }).on("data", (data) => {
         stdout += data.toString();
       });
@@ -5664,7 +5938,7 @@ function shouldUploadLibFile(localPath, remoteAttr, manifest, projectRoot) {
   if (!remoteAttr) {
     return [false, "\u8FDC\u7A0B\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7"];
   }
-  const localSize = statSync7(localPath).size;
+  const localSize = statSync8(localPath).size;
   const remoteSize = remoteAttr.size;
   if (localSize !== remoteSize) {
     return [true, `\u5927\u5C0F\u53D8\u5316 ${remoteSize} -> ${localSize}`];
@@ -5687,7 +5961,7 @@ function shouldUploadLibFile(localPath, remoteAttr, manifest, projectRoot) {
 }
 function listLibFilesToUpload(localLibDir, remoteStats, projectRoot, manifest = null) {
   const entries = [];
-  const jarFiles = readdirSync5(localLibDir).filter((name) => name.endsWith(".jar")).sort();
+  const jarFiles = readdirSync6(localLibDir).filter((name) => name.endsWith(".jar")).sort();
   for (const jarName of jarFiles) {
     const jarPath = path6.join(localLibDir, jarName);
     const remoteAttr = remoteStats.get(jarName);
@@ -5705,12 +5979,12 @@ function listLibFilesToUpload(localLibDir, remoteStats, projectRoot, manifest =
 }
 async function createUpdatePackage(entries, packageName) {
   const dir = deployCacheDirectory();
-  mkdirSync8(dir, { recursive: true });
+  mkdirSync9(dir, { recursive: true });
   const zipPath = path6.join(dir, packageName);
   log(`\u521B\u5EFA\u66F4\u65B0\u5305: ${path6.basename(zipPath)}\uFF08${entries.length} \u4E2A\u6587\u4EF6\uFF09`);
   const zip = new JSZip2();
   for (const entry of entries) {
-    const content = readFileSync14(entry.path);
+    const content = readFileSync15(entry.path);
     zip.file(entry.arcname, content);
     log(`  \u6253\u5305: ${entry.arcname} (${entry.reason})`);
   }
@@ -5719,11 +5993,11 @@ async function createUpdatePackage(entries, packageName) {
     compression: "DEFLATE",
     compressionOptions: { level: 6 }
   });
-  writeFileSync13(zipPath, buffer);
+  writeFileSync14(zipPath, buffer);
   return zipPath;
 }
 function listAllLibFilesForArchive(libDir) {
-  return readdirSync5(libDir).filter((name) => name.endsWith(".jar")).sort().map((jarName) => ({
+  return readdirSync6(libDir).filter((name) => name.endsWith(".jar")).sort().map((jarName) => ({
     path: path6.join(libDir, jarName),
     arcname: jarName,
     reason: "\u4EC5\u6253\u5305\u5F52\u6863"
@@ -5731,7 +6005,7 @@ function listAllLibFilesForArchive(libDir) {
 }
 
 // src/commands/deploy/internal/wisdom-backend/maven-build.ts
-import { existsSync as existsSync19, readdirSync as readdirSync6, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync20, readdirSync as readdirSync7, statSync as statSync9 } from "node:fs";
 import path7 from "node:path";
 import { spawnSync as spawnSync6 } from "node:child_process";
 function getMvnExecutable() {
@@ -5780,14 +6054,14 @@ function runMavenBuild(projectRoot, mavenLocalRepo, repoSource) {
 }
 function locateLibDir(projectRoot) {
   const targetDir = getTargetDir(projectRoot);
-  if (!existsSync19(targetDir)) {
+  if (!existsSync20(targetDir)) {
     fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
   }
   const libDir = path7.join(targetDir, "lib");
-  if (!existsSync19(libDir) || !statSync8(libDir).isDirectory()) {
+  if (!existsSync20(libDir) || !statSync9(libDir).isDirectory()) {
     fail(`lib \u76EE\u5F55\u4E0D\u5B58\u5728: ${libDir}`);
   }
-  const libJars = readdirSync6(libDir).filter((name) => name.endsWith(".jar"));
+  const libJars = readdirSync7(libDir).filter((name) => name.endsWith(".jar"));
   if (libJars.length === 0) {
     fail(`lib \u76EE\u5F55\u4E0B\u6CA1\u6709\u4F9D\u8D56 JAR: ${libDir}`);
   }
@@ -5796,10 +6070,10 @@ function locateLibDir(projectRoot) {
 }
 function locateMainJar(projectRoot) {
   const targetDir = getTargetDir(projectRoot);
-  if (!existsSync19(targetDir)) {
+  if (!existsSync20(targetDir)) {
     fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
   }
-  const jarFiles = readdirSync6(targetDir).filter((name) => name.endsWith(".jar") && !name.endsWith(".jar.original")).map((name) => path7.join(targetDir, name)).sort((a, b) => statSync8(b).mtimeMs - statSync8(a).mtimeMs);
+  const jarFiles = readdirSync7(targetDir).filter((name) => name.endsWith(".jar") && !name.endsWith(".jar.original")).map((name) => path7.join(targetDir, name)).sort((a, b) => statSync9(b).mtimeMs - statSync9(a).mtimeMs);
   if (jarFiles.length === 0) {
     fail(`target \u76EE\u5F55\u4E0B\u6CA1\u6709\u4E3B JAR: ${targetDir}`);
   }
@@ -5956,8 +6230,8 @@ function springbootOutputIndicatesSuccess(action, combined) {
 async function connectSsh(config) {
   const client = new Client2();
   log(`\u8FDE\u63A5\u670D\u52A1\u5668 ${config.username}@${config.host}:${config.port}`);
-  await new Promise((resolve7, reject) => {
-    client.on("ready", () => resolve7()).on("error", (err) => reject(err)).connect({
+  await new Promise((resolve8, reject) => {
+    client.on("ready", () => resolve8()).on("error", (err) => reject(err)).connect({
       host: config.host,
       port: config.port,
       username: config.username,
@@ -6025,7 +6299,7 @@ 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((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     client.exec(command, (err, execStream) => {
       if (err) {
         reject(err);
@@ -6055,7 +6329,7 @@ ${errText}`.trim();
 \u8F93\u51FA: ${combined}` : "")
           );
         }
-        resolve7({ exitCode: code, out: out.trim(), err: errText.trim() });
+        resolve8({ exitCode: code, out: out.trim(), err: errText.trim() });
       });
     });
   });
@@ -6285,15 +6559,15 @@ function isWisdomDeployConfigured(cfg) {
   return Boolean(w?.host?.trim() && w?.remotePath?.trim());
 }
 function detectWisdomProjectType(cwd) {
-  return existsSync20(path10.join(cwd, "package.json")) ? "frontend" : "backend";
+  return existsSync21(path10.join(cwd, "package.json")) ? "frontend" : "backend";
 }
 function readPackageScripts(cwd) {
   const pkgPath = path10.join(cwd, "package.json");
-  if (!existsSync20(pkgPath)) {
+  if (!existsSync21(pkgPath)) {
     return {};
   }
   try {
-    const raw = readFileSync15(pkgPath, "utf8");
+    const raw = readFileSync16(pkgPath, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.scripts ?? {};
   } catch {
@@ -6316,7 +6590,7 @@ function resolveFrontendDistDir(cwd) {
   for (const rel of candidates) {
     const full = path10.join(cwd, rel);
     try {
-      if (existsSync20(full) && statSync9(full).isDirectory()) {
+      if (existsSync21(full) && statSync10(full).isDirectory()) {
         return full;
       }
     } catch {
@@ -6565,7 +6839,8 @@ async function executeDeploy(options) {
   try {
     const configSyncResult = await syncRemoteDeploymentConfig(
       cwd,
-      workspaceApmDir(cwd)
+      workspaceApmDir(cwd),
+      options.repositoryId ? { repositoryId: options.repositoryId } : void 0
     );
     if (configSyncResult.synced && configSyncResult.configName) {
       outputParts.push(
@@ -6840,6 +7115,7 @@ async function handleInboundDeploy(cfg, msg, signal) {
   if (signal.aborted) return;
   const api = createApmApiClient(cfg);
   const deploymentRunId = msg.deploymentRunId;
+  const repositoryId = msg.repositoryId?.trim() || "";
   await api.cli.updateTaskDeploymentStatus({
     id: deploymentRunId,
     status: "DEPLOYING"
@@ -6848,13 +7124,33 @@ async function handleInboundDeploy(cfg, msg, signal) {
     api,
     deploymentRunId,
     run: async (appendLog) => {
-      const workdir = requireRemoteWorkdir(msg.workdir);
+      const workspaceRoot = requireRemoteWorkdir(msg.workdir);
+      let cwd = workspaceRoot;
+      if (repositoryId) {
+        const resolved = await resolveDeployCwdForRepository(
+          workspaceRoot,
+          repositoryId,
+          api
+        );
+        if (resolved) {
+          cwd = resolved;
+          appendLog(
+            `[apm] \u591A\u4ED3\u90E8\u7F72\uFF1A\u6309 repositoryId=${repositoryId} \u89E3\u6790 cwd=${cwd}
+`
+          );
+        } else {
+          appendLog(
+            `[apm] \u672A\u5728 workspace-repos \u547D\u4E2D repositoryId=${repositoryId}\uFF0C\u4F7F\u7528\u5DE5\u4F5C\u7A7A\u95F4\u76EE\u5F55 cwd=${cwd}
+`
+          );
+        }
+      }
       const displayCommand = resolveDeployCommand(
         msg.environment,
         msg.packOnly
       );
       console.log(
-        `[apm] deploy start id=${deploymentRunId} env=${msg.environment} cwd=${workdir}`
+        `[apm] deploy start id=${deploymentRunId} env=${msg.environment} cwd=${cwd}` + (repositoryId ? ` repositoryId=${repositoryId}` : "")
       );
       console.log(`[apm] deploy command: ${displayCommand}`);
       if (signal.aborted) {
@@ -6862,11 +7158,12 @@ async function handleInboundDeploy(cfg, msg, signal) {
       }
       const deployOptions = {
         env: msg.environment,
-        cwd: workdir,
+        cwd,
         packOnly: msg.packOnly,
         captureOutput: true,
         archiveDeployArtifact: true,
-        deployTrigger: "connect"
+        deployTrigger: "connect",
+        ...repositoryId ? { repositoryId } : {}
       };
       const output = await executeDeploy(deployOptions);
       if (output.trim()) {
@@ -6884,7 +7181,7 @@ async function handleInboundDeploy(cfg, msg, signal) {
 }
 
 // src/commands/clean-session-cache.ts
-import { existsSync as existsSync21, rmSync as rmSync4 } from "node:fs";
+import { existsSync as existsSync22, rmSync as rmSync4 } from "node:fs";
 
 // src/commands/connect/pre-step-cache.ts
 var PULL_TTL_MS = 3e4;
@@ -6926,7 +7223,7 @@ function cleanSessionWorkspaceCache(sessionId, workdir) {
     return;
   }
   const dir = sessionDir(trimmedSessionId, workspaceApmDir(trimmedWorkdir));
-  if (existsSync21(dir)) {
+  if (existsSync22(dir)) {
     rmSync4(dir, { recursive: true, force: true });
     console.log(`[apm] \u5DF2\u6E05\u7406\u4F1A\u8BDD\u7F13\u5B58 ${dir}`);
   } else {
@@ -6936,16 +7233,16 @@ function cleanSessionWorkspaceCache(sessionId, workdir) {
 }
 
 // src/commands/clean-webide-cache.ts
-import { existsSync as existsSync22, rmSync as rmSync5 } from "node:fs";
-import { resolve as resolve5 } from "node:path";
+import { existsSync as existsSync23, rmSync as rmSync5 } from "node:fs";
+import { resolve as resolve6 } from "node:path";
 function cleanWebIdeWorkspaceCache(taskId, workdir) {
   const trimmedTaskId = taskId.trim();
   const trimmedWorkdir = workdir.trim();
   if (!trimmedTaskId || !trimmedWorkdir) {
     return;
   }
-  const dir = resolve5(trimmedWorkdir, ".apm", "webide", trimmedTaskId);
-  if (existsSync22(dir)) {
+  const dir = resolve6(trimmedWorkdir, ".apm", "webide", trimmedTaskId);
+  if (existsSync23(dir)) {
     rmSync5(dir, { recursive: true, force: true });
     console.log(`[apm] \u5DF2\u6E05\u7406 WebIDE \u7F13\u5B58 ${dir}`);
   } else {
@@ -7296,17 +7593,17 @@ ${JSON.stringify(event, null, 2)}
 }
 
 // src/commands/connect/agent-session-registry.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync9, readFileSync as readFileSync16, writeFileSync as writeFileSync14 } from "node:fs";
-import { dirname as dirname6, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync10, readFileSync as readFileSync17, writeFileSync as writeFileSync15 } from "node:fs";
+import { dirname as dirname7, resolve as resolve7 } from "node:path";
 function registryPath(workdir, sessionId) {
-  return resolve6(workdir, ".apm", "sessions", sessionId, "cursor-agents.json");
+  return resolve7(workdir, ".apm", "sessions", sessionId, "cursor-agents.json");
 }
 function readRegistry(path19) {
-  if (!existsSync23(path19)) {
+  if (!existsSync24(path19)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync16(path19, "utf8"));
+    const parsed = JSON.parse(readFileSync17(path19, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const result = {};
       for (const [key, value] of Object.entries(
@@ -7323,8 +7620,8 @@ function readRegistry(path19) {
   return {};
 }
 function writeRegistry(path19, registry) {
-  mkdirSync9(dirname6(path19), { recursive: true });
-  writeFileSync14(path19, `${JSON.stringify(registry, null, 2)}
+  mkdirSync10(dirname7(path19), { recursive: true });
+  writeFileSync15(path19, `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 function loadSessionAgentId(workdir, sessionId, user) {
@@ -7927,12 +8224,12 @@ ${WORKSPACE_BOUNDARY_HINT}`;
 }
 
 // src/commands/connect/local-agent-store.ts
-import { mkdirSync as mkdirSync10 } from "node:fs";
-import { join as join18 } from "node:path";
+import { mkdirSync as mkdirSync11 } from "node:fs";
+import { join as join19 } from "node:path";
 import { JsonlLocalAgentStore } from "@cursor/sdk";
 function createWorkspaceLocalAgentStore(workdir) {
-  const rootDir = join18(workdir, ".apm", "cursor-agent-store");
-  mkdirSync10(rootDir, { recursive: true });
+  const rootDir = join19(workdir, ".apm", "cursor-agent-store");
+  mkdirSync11(rootDir, { recursive: true });
   return new JsonlLocalAgentStore(rootDir);
 }
 
@@ -8212,20 +8509,20 @@ async function ensureMessageHasReply(cfg, sessionId, messageId, fallback) {
 }
 
 // src/commands/connect/cli-version-sync.ts
-import { existsSync as existsSync24, readFileSync as readFileSync17, writeFileSync as writeFileSync15 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync18, writeFileSync as writeFileSync16 } from "fs";
+import { join as join20 } from "path";
 var CLI_VERSION_FILE = ".cli-version.json";
-function manifestPath(apmDir) {
-  return join19(apmDir, CLI_VERSION_FILE);
+function manifestPath2(apmDir) {
+  return join20(apmDir, CLI_VERSION_FILE);
 }
 function loadManifest4(apmDir) {
-  const path19 = toFsPath(manifestPath(apmDir));
-  if (!existsSync24(path19)) {
+  const path19 = toFsPath(manifestPath2(apmDir));
+  if (!existsSync25(path19)) {
     return null;
   }
   try {
     const parsed = JSON.parse(
-      readFileSync17(path19, "utf8")
+      readFileSync18(path19, "utf8")
     );
     if (parsed?.version === 1 && typeof parsed.cliVersion === "string" && parsed.cliVersion.trim()) {
       return parsed;
@@ -8236,8 +8533,8 @@ function loadManifest4(apmDir) {
 }
 function saveManifest4(apmDir, cliVersion) {
   const manifest = { version: 1, cliVersion };
-  writeFileSync15(
-    toFsPath(manifestPath(apmDir)),
+  writeFileSync16(
+    toFsPath(manifestPath2(apmDir)),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
@@ -8290,7 +8587,7 @@ function createRunSlotPool(maxConcurrent = DEFAULT_MAX_CONCURRENT, options = {})
       );
     }
     const queuedAt = Date.now();
-    return new Promise((resolve7) => {
+    return new Promise((resolve8) => {
       waiters.push(() => {
         active += 1;
         const waitedMs = Date.now() - queuedAt;
@@ -8301,7 +8598,7 @@ function createRunSlotPool(maxConcurrent = DEFAULT_MAX_CONCURRENT, options = {})
             )}s\uFF0C\u5F53\u524D\u5360\u7528 ${active}/${maxConcurrent}`
           );
         }
-        resolve7();
+        resolve8();
       });
     });
   };
@@ -8322,9 +8619,9 @@ function createRunSlotPool(maxConcurrent = DEFAULT_MAX_CONCURRENT, options = {})
 init_webide_terminal_registry();
 import { Worker } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { dirname as dirname7, join as join20 } from "node:path";
-var workerFile = join20(
-  dirname7(fileURLToPath3(import.meta.url)),
+import { dirname as dirname8, join as join21 } from "node:path";
+var workerFile = join21(
+  dirname8(fileURLToPath3(import.meta.url)),
   "webide-message-worker.js"
 );
 function spawnWebIdeMessageWorker(cfg, msg) {
@@ -8333,8 +8630,8 @@ function spawnWebIdeMessageWorker(cfg, msg) {
   });
   const registry = getWebIdeTerminalRegistry(cfg);
   let resolveDone;
-  const done = new Promise((resolve7) => {
-    resolveDone = resolve7;
+  const done = new Promise((resolve8) => {
+    resolveDone = resolve8;
   });
   worker.on("message", (m) => {
     if (m?.type === "terminal-rpc") {
@@ -8579,11 +8876,11 @@ async function handleInboundMessage(cfg, msg, signal, ctx) {
 }
 function interruptibleSleep(ms, signal) {
   if (signal.aborted) return Promise.resolve();
-  return new Promise((resolve7) => {
-    const timer = setTimeout(resolve7, ms);
+  return new Promise((resolve8) => {
+    const timer = setTimeout(resolve8, ms);
     const onAbort = () => {
       clearTimeout(timer);
-      resolve7();
+      resolve8();
     };
     signal.addEventListener("abort", onAbort, { once: true });
   });
@@ -8795,7 +9092,7 @@ function attachWsHandlers(ws, ctx, onOpen) {
   });
 }
 function connectOnce(url, ctx, connectionAbort, onConnected) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const ws = new WebSocket(url);
     let stopHeartbeat;
     let settled = false;
@@ -8824,7 +9121,7 @@ function connectOnce(url, ctx, connectionAbort, onConnected) {
         finish(() => reject(new Error("shutdown")));
         return;
       }
-      finish(resolve7);
+      finish(resolve8);
     });
     ws.on("error", (err) => {
       console.error("[apm] WebSocket \u9519\u8BEF:", err.message);
@@ -9110,38 +9407,111 @@ function normalizeDeployEnvironment(env) {
   if (normalized === "online") return "ONLINE";
   return null;
 }
+async function resolveRepositoryIdForWebIdeDeploy(cwd, api) {
+  const start = resolveWorkdirPath(cwd);
+  let manifest = findWorkspaceReposManifestNearPath(start);
+  if (!manifest) {
+    throw new DeployExecutionError(
+      "\u672A\u627E\u5230 .apm/workspace-repos.json\uFF0C\u65E0\u6CD5\u5339\u914D\u5E73\u53F0\u4ED3\u5E93",
+      1
+    );
+  }
+  try {
+    manifest = await enrichWorkspaceReposRemoteUrls(manifest);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new DeployExecutionError(
+      `\u5237\u65B0 workspace-repos remoteUrl \u5931\u8D25: ${detail}`,
+      1
+    );
+  }
+  const entry = matchWorkspaceRepoEntryForPath(manifest, start);
+  if (!entry) {
+    throw new DeployExecutionError(
+      `\u5F53\u524D\u76EE\u5F55\u672A\u547D\u4E2D workspace-repos \u4E2D\u7684\u4ED3\u5E93: ${start}`,
+      1
+    );
+  }
+  const abs = absoluteRepoPath(manifest.workdir, entry);
+  const remoteUrl = toHttpsGitRemoteUrl(entry.remoteUrl ?? "") || await tryReadHttpsGitOriginUrl(abs);
+  if (!remoteUrl) {
+    throw new DeployExecutionError(
+      `\u4ED3 ${entry.path} \u65E0\u53EF\u7528\u7684 https remote\uFF0C\u65E0\u6CD5\u5339\u914D\u5E73\u53F0\u4ED3\u5E93`,
+      1
+    );
+  }
+  let baseBranch = "";
+  try {
+    const gitRoot = await resolveGitRepoRoot(abs);
+    baseBranch = (await resolveDefaultRemoteBranch(gitRoot)).trim();
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new DeployExecutionError(`\u89E3\u6790\u5F53\u524D\u4ED3\u57FA\u7EBF\u5206\u652F\u5931\u8D25: ${detail}`, 1);
+  }
+  if (!baseBranch) {
+    throw new DeployExecutionError(
+      "\u65E0\u6CD5\u786E\u5B9A\u5F53\u524D\u4ED3\u57FA\u7EBF\u5206\u652F\uFF0C\u65E0\u6CD5\u5339\u914D\u5E73\u53F0\u4ED3\u5E93",
+      1
+    );
+  }
+  let matched;
+  try {
+    matched = await api.cli.matchRepository({
+      url: remoteUrl,
+      baseBranch
+    });
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new DeployExecutionError(
+      `\u6309 https remote + \u57FA\u7EBF\u5206\u652F\u5339\u914D\u5E73\u53F0\u4ED3\u5E93\u5931\u8D25: ${detail}`,
+      1
+    );
+  }
+  const repositoryId = matched.repositoryId?.trim() || "";
+  if (!repositoryId) {
+    throw new DeployExecutionError(
+      `\u672A\u5339\u914D\u5230\u5E73\u53F0\u4ED3\u5E93 path=${entry.path} url=${remoteUrl} baseBranch=${baseBranch}`,
+      1
+    );
+  }
+  console.log(
+    `[apm] \u90E8\u7F72\u8BB0\u5F55\u4ED3\u5E93 path=${entry.path} https+baseBranch=${baseBranch} \u2192 repositoryId=${repositoryId}`
+  );
+  return repositoryId;
+}
 async function runDeployWithBackendTracking(options) {
+  const { tracking, ...deployOptions } = options;
   const cfg = await tryReadApmConfig();
   if (!cfg || !resolveApiKey(cfg)) {
-    console.warn("[apm] \u672A\u767B\u5F55\uFF0C\u8DF3\u8FC7\u540E\u7AEF\u90E8\u7F72\u8BB0\u5F55");
-    await executeDeploy(options);
-    return;
+    throw new DeployExecutionError("\u672A\u767B\u5F55\uFF0C\u65E0\u6CD5\u521B\u5EFA\u90E8\u7F72\u8BB0\u5F55", 1);
   }
-  const environment = normalizeDeployEnvironment(options.env);
+  const environment = normalizeDeployEnvironment(deployOptions.env);
   if (!environment) {
-    console.warn(
-      `[apm] \u672A\u77E5\u90E8\u7F72\u73AF\u5883 ${options.env}\uFF0C\u8DF3\u8FC7\u540E\u7AEF\u90E8\u7F72\u8BB0\u5F55\uFF08\u4EC5\u652F\u6301 test/online\uFF09`
+    throw new DeployExecutionError(
+      `\u672A\u77E5\u90E8\u7F72\u73AF\u5883 ${deployOptions.env}\uFF0C\u4EC5\u652F\u6301 test/online`,
+      1
     );
-    await executeDeploy(options);
-    return;
   }
   const api = createApmApiClient(cfg);
+  const repositoryId = tracking.kind === "task" ? await resolveRepositoryIdForWebIdeDeploy(deployOptions.cwd, api) : void 0;
   let deploymentRunId;
   try {
     const run = await api.cli.createTaskDeployment({
-      sessionId: options.sessionId,
+      ...tracking.kind === "session" ? { sessionId: tracking.sessionId } : { taskId: tracking.taskId },
       environment,
-      workdirPath: resolveWorkdirPath(options.cwd)
+      workdirPath: resolveWorkdirPath(deployOptions.cwd),
+      ...repositoryId ? { repositoryId } : {}
     });
     deploymentRunId = run.id;
     console.log(
       `[apm] \u5DF2\u521B\u5EFA\u90E8\u7F72\u8BB0\u5F55 id=${deploymentRunId} env=${environment}`
     );
   } catch (error) {
+    if (error instanceof DeployExecutionError) {
+      throw error;
+    }
     const detail = error instanceof Error ? error.message : String(error);
-    console.warn(`[apm] \u521B\u5EFA\u90E8\u7F72\u8BB0\u5F55\u5931\u8D25\uFF0C\u7EE7\u7EED\u90E8\u7F72: ${detail}`);
-    await executeDeploy(options);
-    return;
+    throw new DeployExecutionError(`\u521B\u5EFA\u90E8\u7F72\u8BB0\u5F55\u5931\u8D25: ${detail}`, 1);
   }
   await api.cli.updateTaskDeploymentStatus({
     id: deploymentRunId,
@@ -9152,7 +9522,7 @@ async function runDeployWithBackendTracking(options) {
     deploymentRunId,
     run: async (appendLog) => {
       const output = await executeDeploy({
-        ...options,
+        ...deployOptions,
         captureOutput: true,
         archiveDeployArtifact: true
       });
@@ -9178,7 +9548,10 @@ function registerDeployMainCommand(program) {
     "apm.config.json \u8DEF\u5F84\uFF08\u9ED8\u8BA4 .apm/apm.config.json\uFF09"
   ).option(
     "--session <sessionId>",
-    "\u6C9F\u901A\u7FA4 ID\uFF1B\u4F20\u5165\u65F6\u5728\u5E73\u53F0\u521B\u5EFA\u90E8\u7F72\u8BB0\u5F55\u5E76\u540C\u6B65\u65E5\u5FD7"
+    "\u6C9F\u901A\u7FA4 ID\uFF1B\u4F20\u5165\u65F6\u5728\u5E73\u53F0\u521B\u5EFA\u90E8\u7F72\u8BB0\u5F55\u5E76\u540C\u6B65\u65E5\u5FD7\uFF08\u4E0E --task \u4E8C\u9009\u4E00\uFF09"
+  ).option(
+    "--task <taskId>",
+    "WebIDE \u4EFB\u52A1 ID\uFF1B\u4F20\u5165\u65F6\u5728\u5E73\u53F0\u521B\u5EFA\u90E8\u7F72\u8BB0\u5F55\u5E76\u540C\u6B65\u65E5\u5FD7\uFF08\u4E0E --session \u4E8C\u9009\u4E00\uFF09"
   ).option(
     "--pack-only",
     "\u4EC5\u6784\u5EFA/\u6253\u5305\u5E76\u4E0A\u4F20 MinIO \u5F52\u6863\uFF0C\u4E0D\u4E0A\u4F20\u8FDC\u7A0B SFTP/SSH\uFF08\u65E0\u9700 wisdomDeploy\uFF09"
@@ -9186,14 +9559,30 @@ function registerDeployMainCommand(program) {
     async (env, opts) => {
       const cwd = process.cwd();
       const sessionId = opts.session?.trim();
+      const taskId = opts.task?.trim();
       const packOnly = Boolean(opts.packOnly);
+      if (sessionId && taskId) {
+        console.error("[apm] --session \u4E0E --task \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528");
+        process.exit(1);
+      }
       try {
         if (sessionId) {
           await runDeployWithBackendTracking({
             env,
             cwd,
             configPath: opts.config,
-            sessionId,
+            tracking: { kind: "session", sessionId },
+            packOnly,
+            deployTrigger: "session"
+          });
+          return;
+        }
+        if (taskId) {
+          await runDeployWithBackendTracking({
+            env,
+            cwd,
+            configPath: opts.config,
+            tracking: { kind: "task", taskId },
             packOnly,
             deployTrigger: "session"
           });
@@ -9227,7 +9616,7 @@ import path15 from "node:path";
 import Docker from "dockerode";
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/connection-options.ts
-import { existsSync as existsSync25, readFileSync as readFileSync18 } from "node:fs";
+import { existsSync as existsSync26, readFileSync as readFileSync19 } from "node:fs";
 import path12 from "node:path";
 function asOptionalTlsBuffer(value) {
   if (typeof value !== "string") {
@@ -9239,8 +9628,8 @@ function asOptionalTlsBuffer(value) {
   if (normalized === "") {
     return void 0;
   }
-  if (existsSync25(normalized)) {
-    return readFileSync18(normalized);
+  if (existsSync26(normalized)) {
+    return readFileSync19(normalized);
   }
   const looksLikePath = /[\\/]/.test(normalized) || normalized.endsWith(".pem");
   if (looksLikePath) {
@@ -9365,17 +9754,17 @@ var DockerodeClient = class {
     await this.client.getImage(image).remove({ force: true });
   }
   async pullImage(image, auth) {
-    const stream = await new Promise((resolve7, reject) => {
+    const stream = await new Promise((resolve8, reject) => {
       const pullOptions = auth ? { authconfig: auth } : void 0;
       this.client.pull(image, pullOptions, (err, output) => {
         if (err || !output) {
           reject(err ?? new Error("docker pull \u8FD4\u56DE\u7A7A\u8F93\u51FA"));
           return;
         }
-        resolve7(output);
+        resolve8(output);
       });
     });
-    await new Promise((resolve7, reject) => {
+    await new Promise((resolve8, reject) => {
       this.client.modem.followProgress(
         stream,
         (err) => {
@@ -9383,7 +9772,7 @@ var DockerodeClient = class {
             reject(err);
             return;
           }
-          resolve7();
+          resolve8();
         },
         () => void 0
       );
@@ -9450,7 +9839,7 @@ var DockerodeClient = class {
 var createDockerodeClient = (config) => new DockerodeClient(config);
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/env.ts
-import { existsSync as existsSync26, readFileSync as readFileSync19, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync27, readFileSync as readFileSync20, statSync as statSync11 } from "node:fs";
 import path13 from "node:path";
 function stripSurroundingQuotes(value) {
   const t = value.trim();
@@ -9467,10 +9856,10 @@ function loadEnvFromFile(envFilePath) {
     return {};
   }
   const targetPath = path13.resolve(envFilePath);
-  if (!existsSync26(targetPath) || !statSync10(targetPath).isFile()) {
+  if (!existsSync27(targetPath) || !statSync11(targetPath).isFile()) {
     return {};
   }
-  const raw = readFileSync19(targetPath, "utf-8");
+  const raw = readFileSync20(targetPath, "utf-8");
   const result = {};
   for (const line of raw.split(/\r?\n/)) {
     const normalized = line.trim();
@@ -9641,12 +10030,12 @@ function dockerPushImage(params, cwd) {
 }
 
 // src/commands/deploy/internal/backend-deploy/resolve-dockerfile.ts
-import { existsSync as existsSync27 } from "node:fs";
+import { existsSync as existsSync28 } from "node:fs";
 import path14 from "node:path";
 function resolveDockerBuildPaths(cwd) {
   const dockerfilePath = path14.join(cwd, "Dockerfile");
   Logger.info(`\u67E5\u627EDockerfile\u6587\u4EF6\uFF0C\u8DEF\u5F84: ${dockerfilePath}`);
-  if (!existsSync27(dockerfilePath)) {
+  if (!existsSync28(dockerfilePath)) {
     throw new Error(`Dockerfile \u4E0D\u5B58\u5728\uFF1A${dockerfilePath}`);
   }
   Logger.info("\u2713 Dockerfile \u5B58\u5728");