ai-project-manage-cli 8.0.1 → 8.0.2

package/dist/index.js

@@ -180,10 +180,6 @@ var init_request_config = __esm({
           method: "GET",
           path: "/cli/workspaces/baseline"
         }),
-        matchRepository: defineEndpoint({
-          method: "GET",
-          path: "/cli/repositories/match"
-        }),
         createWebIdeDraftPullRequest: defineEndpoint({
           method: "POST",
           path: "/cli/webide/draft-pull-requests"
@@ -208,22 +204,6 @@ var init_request_config = __esm({
           method: "DELETE",
           path: "/cli/project-documents"
         }),
-        createTaskDeployment: defineEndpoint({
-          method: "POST",
-          path: "/cli/task-deployments"
-        }),
-        updateTaskDeploymentStatus: defineEndpoint({
-          method: "PUT",
-          path: "/cli/task-deployments/status"
-        }),
-        syncTaskDeploymentLog: defineEndpoint({
-          method: "PUT",
-          path: "/cli/task-deployments/log"
-        }),
-        completeTaskDeployment: defineEndpoint({
-          method: "PUT",
-          path: "/cli/task-deployments/complete"
-        }),
         getDeployArtifactStorage: defineEndpoint(
           {
             method: "GET",
@@ -233,10 +213,6 @@ var init_request_config = __esm({
         getApmLogStorage: defineEndpoint({
           method: "GET",
           path: "/cli/apm-log-storage"
-        }),
-        attachTaskDeploymentArtifact: defineEndpoint({
-          method: "PUT",
-          path: "/cli/task-deployments/artifact"
         })
       }
     };
@@ -267,13 +243,13 @@ var init_client = __esm({
 });
 
 // src/commands/deploy/internal/minio.ts
-import { statSync as statSync4 } from "node:fs";
+import { statSync as statSync3 } 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 = statSync4(dir);
+    const st = statSync3(dir);
     return st.isDirectory();
   } catch {
     return false;
@@ -303,7 +279,7 @@ async function collectFiles(root) {
       if (e.isDirectory()) {
         await walk(abs, rel);
       } else if (e.isFile()) {
-        const st = statSync4(abs);
+        const st = statSync3(abs);
         out.push({
           absPath: abs,
           relativePath: rel.replace(/\\/g, "/"),
@@ -370,14 +346,14 @@ var init_minio = __esm({
       async deleteObjectsByPrefix(bucket, prefix) {
         const objectsStream = this.inner.listObjectsV2(bucket, prefix, true);
         const keys = [];
-        await new Promise((resolve8, reject) => {
+        await new Promise((resolve7, reject) => {
           objectsStream.on("data", (obj) => {
             if (obj.name) {
               keys.push(obj.name);
             }
           });
           objectsStream.on("error", reject);
-          objectsStream.on("end", resolve8);
+          objectsStream.on("end", resolve7);
         });
         const chunkSize = 500;
         for (let i = 0; i < keys.length; i += chunkSize) {
@@ -1409,16 +1385,16 @@ function hashLocalFileContent(content) {
   return createHash("sha256").update(content, "utf8").digest("hex");
 }
 function readLocalManifest(apmRoot, projectId) {
-  const manifestPath2 = join4(
+  const manifestPath = join4(
     projectDocumentsDir(apmRoot, projectId),
     MANIFEST_FILE
   );
-  if (!existsSync3(manifestPath2)) {
+  if (!existsSync3(manifestPath)) {
     return null;
   }
   try {
     return JSON.parse(
-      readFileSync3(manifestPath2, "utf8")
+      readFileSync3(manifestPath, "utf8")
     );
   } catch {
     return null;
@@ -1650,7 +1626,7 @@ async function runSyncProjectDocuments(options) {
 // src/commands/connect.ts
 init_client();
 import WebSocket from "ws";
-import { setTimeout as delay3 } from "node:timers/promises";
+import { setTimeout as delay2 } from "node:timers/promises";
 init_config();
 
 // src/ws/protocol.ts
@@ -1752,7 +1728,6 @@ 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 } : {}
     }
   };
@@ -1828,316 +1803,12 @@ function validateAgentWsMessage(value, kind) {
   return validateWebIdeMessagePush(o);
 }
 
-// src/commands/connect/deploy-run.ts
-init_client();
-
-// 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(
-      "git",
-      ["config", "--get", "remote.origin.url"],
-      { cwd, encoding: "utf8", maxBuffer: 1024 * 1024 }
-    );
-    const url = stdout.trim();
-    return url || null;
-  } catch {
-    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";
-import { promisify as promisify2 } from "util";
-var execFileAsync2 = promisify2(execFile2);
-function gitExecEnv() {
-  const existing = process.env.GIT_SSH_COMMAND?.trim();
-  const acceptNew = "-o StrictHostKeyChecking=accept-new";
-  let gitSshCommand;
-  if (!existing) {
-    gitSshCommand = `ssh ${acceptNew}`;
-  } else if (/\bStrictHostKeyChecking=/.test(existing)) {
-    gitSshCommand = existing;
-  } else {
-    gitSshCommand = `${existing} ${acceptNew}`;
-  }
-  return { ...process.env, GIT_SSH_COMMAND: gitSshCommand };
-}
-async function execGit(cwd, args, quiet = false) {
-  try {
-    const { stdout, stderr } = await execFileAsync2("git", args, {
-      cwd,
-      env: gitExecEnv(),
-      encoding: "utf8",
-      maxBuffer: 10 * 1024 * 1024
-    });
-    if (!quiet && stderr.trim()) {
-      process.stderr.write(stderr);
-    }
-    return stdout;
-  } catch (err) {
-    const e = err;
-    const detail = (e.stderr ?? e.message ?? String(err)).trim();
-    throw new Error(
-      `[apm] git ${args.join(" ")} \u5931\u8D25${detail ? `: ${detail}` : ""}`
-    );
-  }
-}
-async function isGitRepo(cwd) {
-  try {
-    await execGit(cwd, ["rev-parse", "--git-dir"], true);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function ensureGitRepo(cwd) {
-  await execGit(cwd, ["rev-parse", "--git-dir"], true);
-}
-async function getCurrentBranch(cwd) {
-  return (await execGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"], true)).trim();
-}
-async function isWorkingTreeDirty(cwd) {
-  const out = await execGit(cwd, ["status", "--porcelain"], true);
-  return out.trim().length > 0;
-}
-async function remoteBranchExists(cwd, branch) {
-  const out = await execGit(
-    cwd,
-    ["ls-remote", "--heads", "origin", branch],
-    true
-  );
-  return out.trim().length > 0;
-}
-async function resolveGitRepoRoot(cwd) {
-  return (await execGit(cwd, ["rev-parse", "--show-toplevel"], true)).trim();
-}
-async function ensureRemoteBaselineBranch(cwd, baselineBranch) {
-  await execGit(cwd, ["fetch", "origin", baselineBranch], true);
-  if (await remoteBranchExists(cwd, baselineBranch)) {
-    return;
-  }
-  throw new Error(
-    `[apm] \u8FDC\u7A0B\u4E0D\u5B58\u5728\u57FA\u7EBF\u5206\u652F origin/${baselineBranch}\uFF0C\u8BF7\u786E\u8BA4\u4ED3\u5E93\u9ED8\u8BA4\u5206\u652F\u5DF2\u63A8\u9001\u5230 origin`
-  );
-}
-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"
-  );
-}
-
-// src/workspace-repos.ts
-import {
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync4,
-  readdirSync as readdirSync3,
-  statSync as statSync3,
-  writeFileSync as writeFileSync3
-} from "fs";
-import { basename, dirname as dirname4, join as join5, relative as relative2, resolve as resolve3 } from "path";
-var WORKSPACE_REPOS_MANIFEST = "workspace-repos.json";
-var WORKSPACE_REPOS_VERSION = 1;
-function manifestPath(workdir) {
-  return join5(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 (!existsSync4(path19)) {
-    return null;
-  }
-  try {
-    const raw = JSON.parse(
-      readFileSync4(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 (existsSync4(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 = dirname4(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/commands/deploy/deploy-execute.ts
 import path11 from "node:path";
 
 // src/commands/deploy/internal/apm-config.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6 } from "node:fs";
-import { resolve as resolve5 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
+import { resolve as resolve4 } from "node:path";
 
 // src/commands/deploy/internal/config/config-validation.ts
 function req(v, field, section) {
@@ -2229,9 +1900,9 @@ function resolveFrontendDeployFromApmConfig(cfg) {
 }
 
 // src/commands/deploy/internal/config/maven-repo.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join6, resolve as resolve4 } from "node:path";
+import { join as join5, resolve as resolve3 } from "node:path";
 var MAVEN_REPO_ENV_KEYS = [
   "MAVEN_LOCAL_REPO",
   "M2_REPO",
@@ -2264,7 +1935,7 @@ function expandUserPath(pathStr, env = process.env) {
   if (/^[a-zA-Z]:[/\\]/.test(expanded)) {
     return expanded;
   }
-  return resolve4(expanded);
+  return resolve3(expanded);
 }
 function readMavenLocalRepoFromMavenOpts(mavenOpts, env = process.env) {
   const match = mavenOpts.match(/-Dmaven\.repo\.local=(?:"([^"]+)"|(\S+))/);
@@ -2288,12 +1959,12 @@ function readMavenLocalRepoFromEnv(env = process.env) {
   return null;
 }
 function readMavenLocalRepoFromSettings() {
-  const settingsPath = join6(homedir2(), ".m2", "settings.xml");
-  if (!existsSync5(settingsPath)) {
+  const settingsPath = join5(homedir2(), ".m2", "settings.xml");
+  if (!existsSync4(settingsPath)) {
     return null;
   }
   try {
-    const xml = readFileSync5(settingsPath, "utf8");
+    const xml = readFileSync4(settingsPath, "utf8");
     const match = xml.match(
       /<localRepository>\s*([^<]+?)\s*<\/localRepository>/
     );
@@ -2324,7 +1995,7 @@ function resolveMavenLocalRepoWithSource() {
     };
   }
   return {
-    path: join6(homedir2(), ".m2", "repository"),
+    path: join5(homedir2(), ".m2", "repository"),
     source: "default",
     sourceDetail: "~/.m2/repository"
   };
@@ -2420,16 +2091,16 @@ function resolveWisdomBackendDeployFromApmConfig(cfg) {
 
 // src/commands/deploy/internal/apm-config.ts
 function loadApmConfig(options) {
-  const p = resolve5(
+  const p = resolve4(
     process.cwd(),
-    options?.configPath ?? resolve5(workspaceApmDir(), "apm.config.json")
+    options?.configPath ?? resolve4(workspaceApmDir(), "apm.config.json")
   );
-  if (!existsSync6(p)) {
+  if (!existsSync5(p)) {
     console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
     process.exit(1);
   }
   try {
-    const raw = readFileSync6(p, "utf8");
+    const raw = readFileSync5(p, "utf8");
     return JSON.parse(raw);
   } catch (e) {
     console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
@@ -2474,8 +2145,8 @@ var DeployExecutionError = class extends Error {
 
 // src/commands/deploy/deploy-debug-log.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync10 } from "node:fs";
-import { dirname as dirname6, join as join10 } from "node:path";
+import { existsSync as existsSync9 } from "node:fs";
+import { dirname as dirname5, join as join9 } from "node:path";
 
 // src/commands/deploy/internal/deploy-artifact-minio.ts
 init_client();
@@ -2568,22 +2239,6 @@ async function uploadDeployArtifactZip(options) {
     console.warn(`[apm] MinIO \u90E8\u7F72\u4EA7\u7269\u5F52\u6863\u5931\u8D25: ${detail}`);
     return null;
   }
-  if (deploymentRunId) {
-    try {
-      await api.cli.attachTaskDeploymentArtifact({
-        id: deploymentRunId,
-        artifactObjectKey: objectKey,
-        artifactFileName: fileName
-      });
-      console.error(
-        `[apm] \u5DF2\u7ED1\u5B9A\u90E8\u7F72\u4EA7\u7269\u5230\u8BB0\u5F55 id=${deploymentRunId} file=${fileName}`
-      );
-    } catch (error) {
-      const detail = error instanceof Error ? error.message : String(error);
-      console.warn(`[apm] \u7ED1\u5B9A\u90E8\u7F72\u4EA7\u7269\u5230\u8BB0\u5F55\u5931\u8D25: ${detail}`);
-      return null;
-    }
-  }
   return {
     objectKey,
     fileName,
@@ -2593,27 +2248,27 @@ async function uploadDeployArtifactZip(options) {
 
 // src/commands/deploy/internal/deploy-shell-env.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync9 } from "node:fs";
-import { dirname as dirname5, join as join9 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { dirname as dirname4, join as join8 } 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 existsSync8, mkdirSync as mkdirSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
+import { join as join7 } from "path";
 
 // src/commands/connect-lock.ts
 init_config();
 import {
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync7,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync6,
   unlinkSync,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync3
 } from "fs";
-import { join as join7 } from "path";
-var CONNECT_LOCK_PATH = join7(APM_CONFIG_DIR, "connect.lock");
+import { join as join6 } from "path";
+var CONNECT_LOCK_PATH = join6(APM_CONFIG_DIR, "connect.lock");
 function isProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
@@ -2640,9 +2295,9 @@ function waitForPm2LockHandoff(timeoutMs = 5e3) {
   }
 }
 function readConnectLock() {
-  if (!existsSync7(CONNECT_LOCK_PATH)) return null;
+  if (!existsSync6(CONNECT_LOCK_PATH)) return null;
   try {
-    const raw = readFileSync7(CONNECT_LOCK_PATH, "utf8");
+    const raw = readFileSync6(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;
@@ -2677,13 +2332,13 @@ function acquireConnectLock(mode) {
       process.exit(1);
     }
   }
-  mkdirSync4(APM_CONFIG_DIR, { recursive: true });
+  mkdirSync3(APM_CONFIG_DIR, { recursive: true });
   const lock = {
     pid: process.pid,
     mode,
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync4(
+  writeFileSync3(
     CONNECT_LOCK_PATH,
     JSON.stringify(lock, null, 2) + "\n",
     "utf8"
@@ -2699,7 +2354,7 @@ function releaseConnectLock() {
 }
 function forceReleaseConnectLock() {
   try {
-    if (existsSync7(CONNECT_LOCK_PATH)) {
+    if (existsSync6(CONNECT_LOCK_PATH)) {
       unlinkSync(CONNECT_LOCK_PATH);
     }
   } catch {
@@ -2708,16 +2363,16 @@ function forceReleaseConnectLock() {
 
 // src/commands/daemon.ts
 var PM2_APP_NAME = "apm-connect";
-var PM2_ECOSYSTEM_PATH = join8(
+var PM2_ECOSYSTEM_PATH = join7(
   APM_CONFIG_DIR,
   "connect.ecosystem.config.cjs"
 );
-var PM2_CONNECT_ENTRY_PATH = join8(APM_CONFIG_DIR, "connect.entry.cjs");
-var PM2_CONNECT_LAUNCH_PATH = join8(
+var PM2_CONNECT_ENTRY_PATH = join7(APM_CONFIG_DIR, "connect.entry.cjs");
+var PM2_CONNECT_LAUNCH_PATH = join7(
   APM_CONFIG_DIR,
   "connect.launch.json"
 );
-var LEGACY_PM2_ECOSYSTEM_PATH = join8(
+var LEGACY_PM2_ECOSYSTEM_PATH = join7(
   APM_CONFIG_DIR,
   "connect.ecosystem.cjs"
 );
@@ -2849,8 +2504,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 = join8(root, ...rel.split("/"));
-    if (existsSync8(candidate)) {
+    const candidate = join7(root, ...rel.split("/"));
+    if (existsSync7(candidate)) {
       return candidate;
     }
   }
@@ -2887,7 +2542,7 @@ function spawnPm2At(binPath, args, options = {}) {
   return spawnPm2Target(buildPm2SpawnTarget(binPath), args, options);
 }
 function verifyPm2Bin(pm2Bin) {
-  if (!pm2Bin.trim() || !existsSync8(pm2Bin)) {
+  if (!pm2Bin.trim() || !existsSync7(pm2Bin)) {
     return false;
   }
   const result = spawnPm2At(pm2Bin, ["--version"], {
@@ -2900,10 +2555,10 @@ function collectPm2Candidates() {
   const globalBin = resolveNpmGlobalBin();
   if (globalBin) {
     if (useNpmShell2) {
-      candidates.push(join8(globalBin, "pm2.cmd"));
-      candidates.push(join8(globalBin, "pm2"));
+      candidates.push(join7(globalBin, "pm2.cmd"));
+      candidates.push(join7(globalBin, "pm2"));
     } else {
-      candidates.push(join8(globalBin, "pm2"));
+      candidates.push(join7(globalBin, "pm2"));
     }
   }
   const fromRoot = resolvePm2FromNpmRoot();
@@ -3026,7 +2681,7 @@ function ensureGlobalPm2(options) {
 }
 function resolveApmEntryPath(entryArg = process.argv[1]) {
   const fromArgv = entryArg?.trim();
-  if (fromArgv && existsSync8(fromArgv)) {
+  if (fromArgv && existsSync7(fromArgv)) {
     return fromArgv;
   }
   const npmResult = spawnSync2(useNpmShell2 ? "npm.cmd" : "npm", ["root", "-g"], {
@@ -3037,8 +2692,8 @@ function resolveApmEntryPath(entryArg = process.argv[1]) {
   if (npmResult.status === 0) {
     const globalRoot = npmResult.stdout?.toString().trim();
     if (globalRoot) {
-      const candidate = join8(globalRoot, CLI_PACKAGE_NAME, "dist", "index.js");
-      if (existsSync8(candidate)) {
+      const candidate = join7(globalRoot, CLI_PACKAGE_NAME, "dist", "index.js");
+      if (existsSync7(candidate)) {
         return candidate;
       }
     }
@@ -3196,8 +2851,8 @@ async function resolveBaseUrl(server) {
   return cfg?.baseUrl;
 }
 function writeConnectLaunchFiles(options) {
-  mkdirSync5(APM_CONFIG_DIR, { recursive: true });
-  writeFileSync5(PM2_CONNECT_ENTRY_PATH, CONNECT_ENTRY_SCRIPT, "utf8");
+  mkdirSync4(APM_CONFIG_DIR, { recursive: true });
+  writeFileSync4(PM2_CONNECT_ENTRY_PATH, CONNECT_ENTRY_SCRIPT, "utf8");
   const env = {
     ...collectPm2LaunchEnv()
   };
@@ -3212,7 +2867,7 @@ function writeConnectLaunchFiles(options) {
     cwd: options.cwd,
     env
   };
-  writeFileSync5(
+  writeFileSync4(
     PM2_CONNECT_LAUNCH_PATH,
     JSON.stringify(launch, null, 2) + "\n",
     "utf8"
@@ -3224,12 +2879,12 @@ function writeEcosystemFile(options) {
     entryScript: PM2_CONNECT_ENTRY_PATH,
     baseUrl: options.baseUrl
   });
-  writeFileSync5(
+  writeFileSync4(
     PM2_ECOSYSTEM_PATH,
     formatConnectPm2EcosystemFile(ecosystem),
     "utf8"
   );
-  if (existsSync8(LEGACY_PM2_ECOSYSTEM_PATH)) {
+  if (existsSync7(LEGACY_PM2_ECOSYSTEM_PATH)) {
     try {
       unlinkSync2(LEGACY_PM2_ECOSYSTEM_PATH);
     } catch {
@@ -3388,14 +3043,14 @@ function writeEnvPath(env, value) {
   env.PATH = value;
 }
 function resolveNodeInstallDir() {
-  return dirname5(process.execPath);
+  return dirname4(process.execPath);
 }
 function resolveNpmCmdPath() {
   if (process.platform !== "win32") {
     return null;
   }
-  const candidate = join9(resolveNodeInstallDir(), "npm.cmd");
-  return existsSync9(candidate) ? candidate : null;
+  const candidate = join8(resolveNodeInstallDir(), "npm.cmd");
+  return existsSync8(candidate) ? candidate : null;
 }
 function formatNpmRunShellCommand(scriptName) {
   const trimmed = scriptName.trim();
@@ -3567,7 +3222,7 @@ function logExecuteDeployContext(input) {
   const deploymentRunId = process.env[APM_DEPLOYMENT_RUN_ID_ENV]?.trim() || null;
   const shellEnv = buildDeployShellEnv();
   const npmGlobalBin = resolveNpmGlobalBin2();
-  const packageJsonPath = join10(input.cwd, "package.json");
+  const packageJsonPath = join9(input.cwd, "package.json");
   logLine("========== executeDeploy \u4E0A\u4E0B\u6587 ==========");
   logLine(`trigger=${trigger} deployEnv=${input.env}`);
   logLine(`cwd(input)=${input.cwdInput}`);
@@ -3577,12 +3232,12 @@ function logExecuteDeployContext(input) {
     `cwdMatchProcess=${input.cwd === input.processCwd ? "yes" : "no"} (connect \u901A\u5E38\u4E3A no)`
   );
   logLine(
-    `apm.config=${input.apmConfigPath} exists=${existsSync10(
+    `apm.config=${input.apmConfigPath} exists=${existsSync9(
       input.apmConfigPath
     )}`
   );
   logLine(
-    `package.json=${packageJsonPath} exists=${existsSync10(packageJsonPath)}`
+    `package.json=${packageJsonPath} exists=${existsSync9(packageJsonPath)}`
   );
   logLine(
     `flags captureOutput=${input.captureOutput} packOnly=${Boolean(
@@ -3596,7 +3251,7 @@ function logExecuteDeployContext(input) {
   );
   logLine(`process argv=${process.argv.join(" ")}`);
   logLine(`npmGlobalBin=${npmGlobalBin ?? "(resolve failed)"}`);
-  logLine(`nodeDir=${dirname6(process.execPath)}`);
+  logLine(`nodeDir=${dirname5(process.execPath)}`);
   logLine("--- process.env\uFF08\u8282\u9009\uFF09---");
   for (const [key, value] of Object.entries(
     collectInterestingEnv(process.env)
@@ -3638,62 +3293,22 @@ function logWisdomFrontendDeployContext(input) {
   logLine(
     `buildKey=build:${input.env} buildCmd=${input.buildCmd ?? "(missing)"}`
   );
-  logLine(`distDir=${input.distDir} exists=${existsSync10(input.distDir)}`);
+  logLine(`distDir=${input.distDir} exists=${existsSync9(input.distDir)}`);
   logLine(
     `packOnly=${input.packOnly} archiveDeployArtifact=${input.archiveDeployArtifact}`
   );
 }
 
 // src/commands/deploy/internal/wisdom-deploy.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync9, statSync as statSync7 } from "node:fs";
 import path10 from "node:path";
 
 // src/commands/deploy/deploy-shell-run.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
 
 // src/commands/deploy/deploy-log-utils.ts
-import { setTimeout as delay2 } 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_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 delay2(1e3 * attempt);
-      }
-    }
-  }
-  throw lastError;
-}
-var retryDeployStatusComplete = retryDeployLogSync;
-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;
-}
 
 // src/commands/deploy/deploy-shell-run.ts
 function runDeployShellCommand(command, cwd, captureOutput) {
@@ -3743,22 +3358,22 @@ import path9 from "node:path";
 
 // src/commands/deploy/internal/wisdom-backend/jar-incremental.ts
 import {
-  mkdirSync as mkdirSync7,
-  readdirSync as readdirSync4,
-  readFileSync as readFileSync9,
-  statSync as statSync6,
-  writeFileSync as writeFileSync7
+  mkdirSync as mkdirSync6,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync8,
+  statSync as statSync5,
+  writeFileSync as writeFileSync6
 } from "node:fs";
 import path6 from "node:path";
 import JSZip2 from "jszip";
 
 // src/commands/deploy/internal/wisdom-backend/manifest.ts
 import {
-  existsSync as existsSync11,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync8,
-  statSync as statSync5,
-  writeFileSync as writeFileSync6
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync7,
+  statSync as statSync4,
+  writeFileSync as writeFileSync5
 } from "node:fs";
 import path2 from "node:path";
 function deployCacheDir() {
@@ -3771,20 +3386,20 @@ function relativeKey(projectRoot, filePath) {
   return path2.relative(projectRoot, filePath).split(path2.sep).join("/");
 }
 function fileSignature(filePath) {
-  const stat2 = statSync5(filePath);
+  const stat2 = statSync4(filePath);
   return { size: stat2.size, mtime: stat2.mtimeMs / 1e3 };
 }
 function loadManifest() {
-  const manifestPath2 = manifestFilePath();
-  if (!existsSync11(manifestPath2)) {
+  const manifestPath = manifestFilePath();
+  if (!existsSync10(manifestPath)) {
     return {};
   }
-  return JSON.parse(readFileSync8(manifestPath2, "utf8"));
+  return JSON.parse(readFileSync7(manifestPath, "utf8"));
 }
 function saveManifest(manifest) {
   const dir = deployCacheDir();
-  mkdirSync6(dir, { recursive: true });
-  writeFileSync6(manifestFilePath(), JSON.stringify(manifest, null, 2), "utf8");
+  mkdirSync5(dir, { recursive: true });
+  writeFileSync5(manifestFilePath(), JSON.stringify(manifest, null, 2), "utf8");
 }
 function updateManifestEntries(manifest, entries, projectRoot) {
   for (const entry of entries) {
@@ -3915,7 +3530,7 @@ function buildSftpConnectOptions(settings) {
   };
 }
 async function sleep(ms) {
-  await new Promise((resolve8) => setTimeout(resolve8, ms));
+  await new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 async function uploadZipWithRetry(settings, localZip, remoteZipPath) {
   let lastError;
@@ -3959,7 +3574,7 @@ async function ensureRemoteDir(sftp, dir) {
   }
 }
 function execCommand(client, command) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve7, reject) => {
     client.exec(command, (err, stream) => {
       if (err) return reject(err);
       let stdout = "";
@@ -3969,7 +3584,7 @@ function execCommand(client, command) {
           reject(new Error(`\u8FDC\u7A0B\u547D\u4EE4\u5931\u8D25 (${code}): ${stderr || stdout}`));
           return;
         }
-        resolve8(stdout);
+        resolve7(stdout);
       }).on("data", (data) => {
         stdout += data.toString();
       });
@@ -4152,7 +3767,7 @@ function shouldUploadLibFile(localPath, remoteAttr, manifest, projectRoot) {
   if (!remoteAttr) {
     return [false, "\u8FDC\u7A0B\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7"];
   }
-  const localSize = statSync6(localPath).size;
+  const localSize = statSync5(localPath).size;
   const remoteSize = remoteAttr.size;
   if (localSize !== remoteSize) {
     return [true, `\u5927\u5C0F\u53D8\u5316 ${remoteSize} -> ${localSize}`];
@@ -4175,7 +3790,7 @@ function shouldUploadLibFile(localPath, remoteAttr, manifest, projectRoot) {
 }
 function listLibFilesToUpload(localLibDir, remoteStats, projectRoot, manifest = null) {
   const entries = [];
-  const jarFiles = readdirSync4(localLibDir).filter((name) => name.endsWith(".jar")).sort();
+  const jarFiles = readdirSync3(localLibDir).filter((name) => name.endsWith(".jar")).sort();
   for (const jarName of jarFiles) {
     const jarPath = path6.join(localLibDir, jarName);
     const remoteAttr = remoteStats.get(jarName);
@@ -4193,12 +3808,12 @@ function listLibFilesToUpload(localLibDir, remoteStats, projectRoot, manifest =
 }
 async function createUpdatePackage(entries, packageName) {
   const dir = deployCacheDirectory();
-  mkdirSync7(dir, { recursive: true });
+  mkdirSync6(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 = readFileSync9(entry.path);
+    const content = readFileSync8(entry.path);
     zip.file(entry.arcname, content);
     log(`  \u6253\u5305: ${entry.arcname} (${entry.reason})`);
   }
@@ -4207,11 +3822,11 @@ async function createUpdatePackage(entries, packageName) {
     compression: "DEFLATE",
     compressionOptions: { level: 6 }
   });
-  writeFileSync7(zipPath, buffer);
+  writeFileSync6(zipPath, buffer);
   return zipPath;
 }
 function listAllLibFilesForArchive(libDir) {
-  return readdirSync4(libDir).filter((name) => name.endsWith(".jar")).sort().map((jarName) => ({
+  return readdirSync3(libDir).filter((name) => name.endsWith(".jar")).sort().map((jarName) => ({
     path: path6.join(libDir, jarName),
     arcname: jarName,
     reason: "\u4EC5\u6253\u5305\u5F52\u6863"
@@ -4219,7 +3834,7 @@ function listAllLibFilesForArchive(libDir) {
 }
 
 // src/commands/deploy/internal/wisdom-backend/maven-build.ts
-import { existsSync as existsSync13, readdirSync as readdirSync5, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync12, readdirSync as readdirSync4, statSync as statSync6 } from "node:fs";
 import path7 from "node:path";
 import { spawnSync as spawnSync6 } from "node:child_process";
 function getMvnExecutable() {
@@ -4268,14 +3883,14 @@ function runMavenBuild(projectRoot, mavenLocalRepo, repoSource) {
 }
 function locateLibDir(projectRoot) {
   const targetDir = getTargetDir(projectRoot);
-  if (!existsSync13(targetDir)) {
+  if (!existsSync12(targetDir)) {
     fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
   }
   const libDir = path7.join(targetDir, "lib");
-  if (!existsSync13(libDir) || !statSync7(libDir).isDirectory()) {
+  if (!existsSync12(libDir) || !statSync6(libDir).isDirectory()) {
     fail(`lib \u76EE\u5F55\u4E0D\u5B58\u5728: ${libDir}`);
   }
-  const libJars = readdirSync5(libDir).filter((name) => name.endsWith(".jar"));
+  const libJars = readdirSync4(libDir).filter((name) => name.endsWith(".jar"));
   if (libJars.length === 0) {
     fail(`lib \u76EE\u5F55\u4E0B\u6CA1\u6709\u4F9D\u8D56 JAR: ${libDir}`);
   }
@@ -4284,10 +3899,10 @@ function locateLibDir(projectRoot) {
 }
 function locateMainJar(projectRoot) {
   const targetDir = getTargetDir(projectRoot);
-  if (!existsSync13(targetDir)) {
+  if (!existsSync12(targetDir)) {
     fail(`\u6784\u5EFA\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetDir}`);
   }
-  const jarFiles = readdirSync5(targetDir).filter((name) => name.endsWith(".jar") && !name.endsWith(".jar.original")).map((name) => path7.join(targetDir, name)).sort((a, b) => statSync7(b).mtimeMs - statSync7(a).mtimeMs);
+  const jarFiles = readdirSync4(targetDir).filter((name) => name.endsWith(".jar") && !name.endsWith(".jar.original")).map((name) => path7.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}`);
   }
@@ -4444,8 +4059,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((resolve8, reject) => {
-    client.on("ready", () => resolve8()).on("error", (err) => reject(err)).connect({
+  await new Promise((resolve7, reject) => {
+    client.on("ready", () => resolve7()).on("error", (err) => reject(err)).connect({
       host: config.host,
       port: config.port,
       username: config.username,
@@ -4513,7 +4128,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((resolve8, reject) => {
+  return new Promise((resolve7, reject) => {
     client.exec(command, (err, execStream) => {
       if (err) {
         reject(err);
@@ -4543,7 +4158,7 @@ ${errText}`.trim();
 \u8F93\u51FA: ${combined}` : "")
           );
         }
-        resolve8({ exitCode: code, out: out.trim(), err: errText.trim() });
+        resolve7({ exitCode: code, out: out.trim(), err: errText.trim() });
       });
     });
   });
@@ -4773,15 +4388,15 @@ function isWisdomDeployConfigured(cfg) {
   return Boolean(w?.host?.trim() && w?.remotePath?.trim());
 }
 function detectWisdomProjectType(cwd) {
-  return existsSync14(path10.join(cwd, "package.json")) ? "frontend" : "backend";
+  return existsSync13(path10.join(cwd, "package.json")) ? "frontend" : "backend";
 }
 function readPackageScripts(cwd) {
   const pkgPath = path10.join(cwd, "package.json");
-  if (!existsSync14(pkgPath)) {
+  if (!existsSync13(pkgPath)) {
     return {};
   }
   try {
-    const raw = readFileSync10(pkgPath, "utf8");
+    const raw = readFileSync9(pkgPath, "utf8");
     const parsed = JSON.parse(raw);
     return parsed.scripts ?? {};
   } catch {
@@ -4804,7 +4419,7 @@ function resolveFrontendDistDir(cwd) {
   for (const rel of candidates) {
     const full = path10.join(cwd, rel);
     try {
-      if (existsSync14(full) && statSync8(full).isDirectory()) {
+      if (existsSync13(full) && statSync7(full).isDirectory()) {
         return full;
       }
     } catch {
@@ -4898,58 +4513,141 @@ async function executeWisdomDeploy(options) {
 // src/commands/deploy/internal/deploy-baseline-sync.ts
 init_client();
 
-// src/baseline-resolve.ts
-function formatBaselineDiagnostic(workdirPath, baselineWorkdirPath, diagnostic) {
-  return diagnostic?.message ?? `\u672A\u5728\u5E73\u53F0\u627E\u5230\u4E0E\u5F53\u524D\u76EE\u5F55\u5339\u914D\u7684\u5DE5\u4F5C\u76EE\u5F55\u767B\u8BB0\uFF1A${workdirPath}\uFF08\u89C4\u8303\u5316\uFF1A${baselineWorkdirPath}\uFF09
-\u8BF7\u5148\u5728\u5E73\u53F0\u767B\u8BB0\u8BE5\u8DEF\u5F84\u5BF9\u5E94\u7684\u5DE5\u4F5C\u76EE\u5F55\u4E0E\u4ED3\u5E93\u3002`;
-}
-async function matchRepositoryByGitRemote(api, workdirPath) {
-  const gitRoot = await resolveGitRepoRoot(workdirPath);
-  const gitUrl = await tryReadGitOriginUrl(gitRoot);
-  if (!gitUrl) {
-    return null;
-  }
-  const matched = await api.cli.matchRepository({ url: gitUrl });
-  const repositoryId = matched.repositoryId?.trim();
-  const defaultBranch = matched.defaultBranch?.trim();
-  if (!repositoryId || !defaultBranch) {
-    return null;
-  }
-  console.log(
-    `[apm] \u5DE5\u4F5C\u7A7A\u95F4\u8DEF\u5F84\u672A\u5339\u914D\uFF0C\u5DF2\u901A\u8FC7 git remote \u5173\u8054\u4ED3\u5E93: ${gitUrl}`
-  );
-  return { repositoryId, defaultBranch };
-}
-async function resolveWorkspaceBaseline(api, workdirPath) {
-  const baseline = await api.cli.workspaceBaseline({ workdirPath });
-  const repositoryId = baseline.repositoryId?.trim();
-  const defaultBranch = baseline.defaultBranch?.trim();
-  if (repositoryId && defaultBranch) {
-    return {
-      repositoryId,
-      defaultBranch,
-      workdirPath: baseline.workdirPath,
-      matchedViaGitRemote: false
-    };
-  }
-  const viaGit = await matchRepositoryByGitRemote(api, workdirPath);
-  if (viaGit) {
-    return {
-      ...viaGit,
-      workdirPath: baseline.workdirPath,
-      matchedViaGitRemote: true
-    };
-  }
-  throw new Error(
-    `[apm] ${formatBaselineDiagnostic(
-      workdirPath,
-      baseline.workdirPath,
-      baseline.diagnostic
-    )}`
-  );
-}
-
-// src/commands/deploy/internal/deploy-baseline-sync.ts
+// src/git-utils.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+
+// src/git-remote.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+
+// src/git-utils.ts
+var execFileAsync2 = promisify2(execFile2);
+function gitExecEnv() {
+  const existing = process.env.GIT_SSH_COMMAND?.trim();
+  const acceptNew = "-o StrictHostKeyChecking=accept-new";
+  let gitSshCommand;
+  if (!existing) {
+    gitSshCommand = `ssh ${acceptNew}`;
+  } else if (/\bStrictHostKeyChecking=/.test(existing)) {
+    gitSshCommand = existing;
+  } else {
+    gitSshCommand = `${existing} ${acceptNew}`;
+  }
+  return { ...process.env, GIT_SSH_COMMAND: gitSshCommand };
+}
+async function execGit(cwd, args, quiet = false) {
+  try {
+    const { stdout, stderr } = await execFileAsync2("git", args, {
+      cwd,
+      env: gitExecEnv(),
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024
+    });
+    if (!quiet && stderr.trim()) {
+      process.stderr.write(stderr);
+    }
+    return stdout;
+  } catch (err) {
+    const e = err;
+    const detail = (e.stderr ?? e.message ?? String(err)).trim();
+    throw new Error(
+      `[apm] git ${args.join(" ")} \u5931\u8D25${detail ? `: ${detail}` : ""}`
+    );
+  }
+}
+async function isGitRepo(cwd) {
+  try {
+    await execGit(cwd, ["rev-parse", "--git-dir"], true);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureGitRepo(cwd) {
+  await execGit(cwd, ["rev-parse", "--git-dir"], true);
+}
+async function getCurrentBranch(cwd) {
+  return (await execGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"], true)).trim();
+}
+async function isWorkingTreeDirty(cwd) {
+  const out = await execGit(cwd, ["status", "--porcelain"], true);
+  return out.trim().length > 0;
+}
+async function remoteBranchExists(cwd, branch) {
+  const out = await execGit(
+    cwd,
+    ["ls-remote", "--heads", "origin", branch],
+    true
+  );
+  return out.trim().length > 0;
+}
+async function resolveGitRepoRoot(cwd) {
+  return (await execGit(cwd, ["rev-parse", "--show-toplevel"], true)).trim();
+}
+async function ensureRemoteBaselineBranch(cwd, baselineBranch) {
+  await execGit(cwd, ["fetch", "origin", baselineBranch], true);
+  if (await remoteBranchExists(cwd, baselineBranch)) {
+    return;
+  }
+  throw new Error(
+    `[apm] \u8FDC\u7A0B\u4E0D\u5B58\u5728\u57FA\u7EBF\u5206\u652F origin/${baselineBranch}\uFF0C\u8BF7\u786E\u8BA4\u4ED3\u5E93\u9ED8\u8BA4\u5206\u652F\u5DF2\u63A8\u9001\u5230 origin`
+  );
+}
+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"
+  );
+}
+
+// src/baseline-resolve.ts
+function formatBaselineDiagnostic(workdirPath, baselineWorkdirPath, diagnostic) {
+  return diagnostic?.message ?? `\u672A\u5728\u5E73\u53F0\u627E\u5230\u4E0E\u5F53\u524D\u76EE\u5F55\u5339\u914D\u7684\u5DE5\u4F5C\u76EE\u5F55\u767B\u8BB0\uFF1A${workdirPath}\uFF08\u89C4\u8303\u5316\uFF1A${baselineWorkdirPath}\uFF09
+\u8BF7\u5148\u5728\u5E73\u53F0\u767B\u8BB0\u8BE5\u8DEF\u5F84\u5BF9\u5E94\u7684\u5DE5\u4F5C\u76EE\u5F55\u3002`;
+}
+async function resolveWorkspaceBaseline(api, workdirPath) {
+  const baseline = await api.cli.workspaceBaseline({ workdirPath });
+  if (!baseline.workspaceId) {
+    throw new Error(
+      `[apm] ${formatBaselineDiagnostic(
+        workdirPath,
+        baseline.workdirPath,
+        baseline.diagnostic
+      )}`
+    );
+  }
+  let defaultBranch = baseline.defaultBranch?.trim() || "";
+  if (!defaultBranch) {
+    try {
+      const gitRoot = await resolveGitRepoRoot(workdirPath);
+      defaultBranch = (await resolveDefaultRemoteBranch(gitRoot)).trim();
+    } catch {
+      defaultBranch = "";
+    }
+  }
+  if (!defaultBranch) {
+    throw new Error(
+      "[apm] \u5DE5\u4F5C\u76EE\u5F55\u5DF2\u5339\u914D\uFF0C\u4F46\u65E0\u6CD5\u89E3\u6790\u57FA\u7EBF\u5206\u652F\u3002\u8BF7\u5728\u9879\u76EE\u4E2D\u914D\u7F6E\u57FA\u7840\u5206\u652F\uFF0C\u6216\u786E\u8BA4 origin \u5B58\u5728\u9ED8\u8BA4\u5206\u652F\u3002"
+    );
+  }
+  return { defaultBranch, workdirPath: baseline.workdirPath };
+}
+
+// src/commands/deploy/internal/deploy-baseline-sync.ts
 init_config();
 var LOG_PREFIX2 = "[apm] \u90E8\u7F72\u524D\u57FA\u7EBF\u540C\u6B65:";
 function formatGitError(error) {
@@ -5149,348 +4847,54 @@ function printDeployExecutionError(error) {
   console.error(error.message);
 }
 
-// src/commands/deploy/platform/deploy-console-capture.ts
-function captureDeployConsole(logSyncer) {
-  const chunks = [];
-  const appendLog = (line) => {
-    if (!line) return;
-    chunks.push(line);
-    logSyncer.updateLog(chunks.join("\n"));
-  };
-  const originalLog = console.log;
-  const originalError = console.error;
-  console.log = (...args) => {
-    appendLog(args.map(String).join(" "));
-    originalLog.apply(console, args);
-  };
-  console.error = (...args) => {
-    appendLog(args.map(String).join(" "));
-    originalError.apply(console, args);
-  };
-  return {
-    appendLog,
-    restore: () => {
-      console.log = originalLog;
-      console.error = originalError;
-    },
-    getLog: () => chunks.join("\n")
-  };
-}
-
-// src/commands/deploy/platform/deploy-log-syncer.ts
-var DEPLOY_LOG_SYNC_INTERVAL_MS = 1e4;
-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 lastRunAt = 0;
-  let timer;
-  let syncChain = Promise.resolve();
-  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;
-    }
-    const delta = latestLog.startsWith(lastSyncedLog) && lastSyncedLog.length > 0 ? latestLog.slice(lastSyncedLog.length) : latestLog;
-    if (!delta) {
-      return;
-    }
-    await syncDelta(delta, lastSyncedLog.length > 0);
-    lastSyncedLog = latestLog;
-  };
-  const enqueueSync = () => {
-    syncChain = syncChain.then(async () => {
-      try {
-        await syncIfChanged();
-        lastRunAt = Date.now();
-      } catch (error) {
-        logDeploySyncFailure(error);
-      }
-    });
-  };
-  const schedule = () => {
-    const now = Date.now();
-    const elapsed = now - lastRunAt;
-    if (elapsed >= DEPLOY_LOG_SYNC_INTERVAL_MS) {
-      if (timer) {
-        clearTimeout(timer);
-        timer = void 0;
-      }
-      enqueueSync();
-      return;
-    }
-    if (timer) {
-      return;
-    }
-    timer = setTimeout(() => {
-      timer = void 0;
-      enqueueSync();
-    }, DEPLOY_LOG_SYNC_INTERVAL_MS - elapsed);
-  };
-  const stopTimer = () => {
-    if (timer) {
-      clearTimeout(timer);
-      timer = void 0;
-    }
-  };
-  return {
-    updateLog(log2) {
-      latestLog = log2;
-      schedule();
-    },
-    async flush() {
-      stopTimer();
-      await syncChain;
-      await syncIfChanged();
-    },
-    async flushSafe() {
-      stopTimer();
-      try {
-        await syncChain;
-        await syncIfChanged();
-        return true;
-      } catch (error) {
-        logDeploySyncFailure(error);
-        return false;
-      }
-    },
-    dispose() {
-      stopTimer();
-    }
-  };
-}
-async function finalizeTaskDeployment(api, deploymentRunId, logSyncer, input) {
-  await logSyncer.flushSafe();
-  const payload = {
-    id: deploymentRunId,
-    status: input.status
-  };
-  if (input.error) {
-    payload.error = input.error;
-  }
-  await retryDeployStatusComplete(
-    () => api.cli.completeTaskDeployment(payload)
-  );
-}
-async function ensureDeploymentStatusSynced(api, deploymentRunId, logSyncer, outcome) {
-  await finalizeTaskDeployment(api, deploymentRunId, logSyncer, outcome);
-}
-
-// src/commands/deploy/platform/deploy-run-coordinator.ts
-function logDeployStatusSyncFailure(error) {
-  console.error(
-    "[apm] deploy status sync failed:",
-    error instanceof Error ? error.message : String(error)
-  );
+// src/commands/connect/deploy-run.ts
+function resolveDeployCommand(environment, packOnly) {
+  return packOnly ? `apm deploy ${environment} --pack-only` : `apm deploy ${environment}`;
 }
-async function runTrackedDeploy(input) {
-  const { api, deploymentRunId, run } = input;
-  let deploymentStarted = true;
-  let outcome = null;
-  let statusSynced = false;
-  let deployError;
-  const logSyncer = createDeployLogSyncer(api, deploymentRunId);
-  const previousDeploymentRunId = process.env[APM_DEPLOYMENT_RUN_ID_ENV];
-  process.env[APM_DEPLOYMENT_RUN_ID_ENV] = deploymentRunId;
-  const capture = captureDeployConsole(logSyncer);
-  const ensureStatusSynced = async () => {
-    if (statusSynced || !outcome) {
-      return;
-    }
-    logSyncer.updateLog(capture.getLog());
-    await ensureDeploymentStatusSynced(
-      api,
-      deploymentRunId,
-      logSyncer,
-      outcome
-    );
-    statusSynced = true;
+async function handleInboundDeploy(_cfg, msg, signal) {
+  if (signal.aborted) return;
+  const cwd = requireRemoteWorkdir(msg.workdir);
+  const displayCommand = resolveDeployCommand(msg.environment, msg.packOnly);
+  console.log(`[apm] deploy start env=${msg.environment} cwd=${cwd}`);
+  console.log(`[apm] deploy command: ${displayCommand}`);
+  if (signal.aborted) return;
+  const deployOptions = {
+    env: msg.environment,
+    cwd,
+    packOnly: msg.packOnly,
+    captureOutput: true,
+    archiveDeployArtifact: true,
+    deployTrigger: "connect"
   };
   try {
-    outcome = await run(capture.appendLog);
+    await executeDeploy(deployOptions);
+    console.log(`[apm] deploy success env=${msg.environment}`);
   } catch (error) {
-    deployError = error instanceof DeployExecutionError ? error : new DeployExecutionError(
+    const deployError = error instanceof DeployExecutionError ? error : new DeployExecutionError(
       error instanceof Error ? error.message : String(error),
       1
     );
-    if (deployError.output.trim()) {
-      capture.appendLog(deployError.output);
-    } else {
-      capture.appendLog(deployError.message);
-    }
-    outcome = { status: "FAILED", error: deployError.message };
-  } finally {
-    if (deploymentStarted && !statusSynced) {
-      if (!outcome) {
-        outcome = { status: "FAILED", error: "\u90E8\u7F72\u672A\u5B8C\u6210" };
-      }
-      try {
-        await ensureStatusSynced();
-      } catch (error) {
-        logDeployStatusSyncFailure(error);
-      }
-    }
-    capture.restore();
-    if (previousDeploymentRunId === void 0) {
-      delete process.env[APM_DEPLOYMENT_RUN_ID_ENV];
-    } else {
-      process.env[APM_DEPLOYMENT_RUN_ID_ENV] = previousDeploymentRunId;
-    }
-    logSyncer.dispose();
-  }
-  return { outcome, error: deployError };
-}
-
-// src/commands/connect/deploy-run.ts
-function resolveDeployCommand(environment, packOnly) {
-  return packOnly ? `apm deploy ${environment} --pack-only` : `apm deploy ${environment}`;
-}
-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;
-  }
-  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 api.cli.matchRepository({
-        url: remoteUrl,
-        baseBranch
-      });
-      if (matched.repositoryId?.trim() === repositoryId) {
-        return abs;
-      }
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-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"
-  });
-  const { error: deployError } = await runTrackedDeploy({
-    api,
-    deploymentRunId,
-    run: async (appendLog) => {
-      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=${cwd}` + (repositoryId ? ` repositoryId=${repositoryId}` : "")
-      );
-      console.log(`[apm] deploy command: ${displayCommand}`);
-      if (signal.aborted) {
-        return { status: "FAILED", error: "\u90E8\u7F72\u5DF2\u53D6\u6D88" };
-      }
-      const deployOptions = {
-        env: msg.environment,
-        cwd,
-        packOnly: msg.packOnly,
-        captureOutput: true,
-        archiveDeployArtifact: true,
-        deployTrigger: "connect"
-      };
-      const output = await executeDeploy(deployOptions);
-      if (output.trim()) {
-        appendLog(output);
-      }
-      console.log(`[apm] deploy success id=${deploymentRunId}`);
-      return { status: "SUCCESS" };
-    }
-  });
-  if (deployError) {
-    console.error(
-      `[apm] deploy failed id=${deploymentRunId}: ${deployError.message}`
-    );
+    printDeployExecutionError(deployError);
   }
 }
 
 // src/commands/clean-webide-cache.ts
-import { existsSync as existsSync16, rmSync as rmSync2 } from "node:fs";
-import { resolve as resolve7 } from "node:path";
+import { existsSync as existsSync15, rmSync as rmSync2 } from "node:fs";
+import { resolve as resolve6 } from "node:path";
 import { getDefaultSdkStateRoot } from "@cursor/sdk";
 
 // src/commands/connect/webide-agent-registry.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname7, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname6, resolve as resolve5 } from "node:path";
 function registryPath(workdir, taskId) {
-  return resolve6(workdir, ".apm", "webide", taskId, "cursor-agent.json");
+  return resolve5(workdir, ".apm", "webide", taskId, "cursor-agent.json");
 }
 function readRegistry(path19) {
-  if (!existsSync15(path19)) {
+  if (!existsSync14(path19)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync11(path19, "utf8"));
+    const parsed = JSON.parse(readFileSync10(path19, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const raw = parsed;
       const state = {};
@@ -5528,7 +4932,7 @@ async function purgeCursorAgentStoreForAgent(workdir, agentId) {
   const trimmedWorkdir = workdir.trim();
   if (!trimmedAgentId || !trimmedWorkdir) return false;
   const stateRoot = getDefaultSdkStateRoot(trimmedWorkdir);
-  if (!existsSync16(stateRoot)) return false;
+  if (!existsSync15(stateRoot)) return false;
   const { SqliteLocalAgentStore } = await import(
     /* @vite-ignore */
     "@cursor/sdk/sqlite"
@@ -5592,8 +4996,8 @@ async function cleanWebIdeWorkspaceCache(taskId, workdir) {
       `[apm] \u65E0 WebIDE agentId\uFF0C\u8DF3\u8FC7 agent store \u6E05\u7406 taskId=${trimmedTaskId}`
     );
   }
-  const dir = resolve7(trimmedWorkdir, ".apm", "webide", trimmedTaskId);
-  if (existsSync16(dir)) {
+  const dir = resolve6(trimmedWorkdir, ".apm", "webide", trimmedTaskId);
+  if (existsSync15(dir)) {
     rmSync2(dir, { recursive: true, force: true });
     console.log(`[apm] \u5DF2\u6E05\u7406 WebIDE \u7F13\u5B58 ${dir}`);
   } else {
@@ -5653,7 +5057,7 @@ function createRunSlotPool(maxConcurrent = DEFAULT_MAX_CONCURRENT, options = {})
       );
     }
     const queuedAt = Date.now();
-    return new Promise((resolve8) => {
+    return new Promise((resolve7) => {
       waiters.push(() => {
         active += 1;
         const waitedMs = Date.now() - queuedAt;
@@ -5664,7 +5068,7 @@ function createRunSlotPool(maxConcurrent = DEFAULT_MAX_CONCURRENT, options = {})
             )}s\uFF0C\u5F53\u524D\u5360\u7528 ${active}/${maxConcurrent}`
           );
         }
-        resolve8();
+        resolve7();
       });
     });
   };
@@ -5686,9 +5090,9 @@ init_webide_terminal_registry();
 import { Worker } from "node:worker_threads";
 import { totalmem } from "node:os";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { dirname as dirname8, join as join11 } from "node:path";
-var workerFile = join11(
-  dirname8(fileURLToPath3(import.meta.url)),
+import { dirname as dirname7, join as join10 } from "node:path";
+var workerFile = join10(
+  dirname7(fileURLToPath3(import.meta.url)),
   "webide-message-worker.js"
 );
 var SYSTEM_RESERVE_MB = 3072;
@@ -5722,8 +5126,8 @@ function spawnWebIdeMessageWorker(cfg, msg) {
   const registry = getWebIdeTerminalRegistry(cfg);
   let settled = false;
   let resolveDone;
-  const done = new Promise((resolve8) => {
-    resolveDone = resolve8;
+  const done = new Promise((resolve7) => {
+    resolveDone = resolve7;
   });
   const failIfStillQueued = async (reason) => {
     if (settled) return;
@@ -5846,11 +5250,11 @@ var RECONNECT_MAX_MS = 6e4;
 var SHUTDOWN_DRAIN_MS = 3e3;
 function interruptibleSleep(ms, signal) {
   if (signal.aborted) return Promise.resolve();
-  return new Promise((resolve8) => {
-    const timer = setTimeout(resolve8, ms);
+  return new Promise((resolve7) => {
+    const timer = setTimeout(resolve7, ms);
     const onAbort = () => {
       clearTimeout(timer);
-      resolve8();
+      resolve7();
     };
     signal.addEventListener("abort", onAbort, { once: true });
   });
@@ -6010,7 +5414,7 @@ function attachWsHandlers(ws, ctx, onOpen) {
   });
 }
 function connectOnce(url, ctx, connectionAbort, onConnected) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve7, reject) => {
     const ws = new WebSocket(url);
     let stopHeartbeat;
     let settled = false;
@@ -6039,7 +5443,7 @@ function connectOnce(url, ctx, connectionAbort, onConnected) {
         finish(() => reject(new Error("shutdown")));
         return;
       }
-      finish(resolve8);
+      finish(resolve7);
     });
     ws.on("error", (err) => {
       console.error("[apm] WebSocket \u9519\u8BEF:", err.message);
@@ -6121,7 +5525,7 @@ async function runConnect(options) {
     shutdownAbort.abort();
     logAbortSignalStats(shutdownAbort.signal, "connect:shutdown-after-abort");
     try {
-      await Promise.race([Promise.all(activeTasks), delay3(drainMs)]);
+      await Promise.race([Promise.all(activeTasks), delay2(drainMs)]);
     } catch {
     }
     releaseConnectLock();
@@ -6184,150 +5588,6 @@ async function runConnect(options) {
   }
 }
 
-// src/commands/deploy/deploy-tracking.ts
-init_client();
-init_config();
-function normalizeDeployEnvironment(env) {
-  const normalized = env.trim().toLowerCase();
-  if (normalized === "test") return "TEST";
-  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)) {
-    throw new DeployExecutionError("\u672A\u767B\u5F55\uFF0C\u65E0\u6CD5\u521B\u5EFA\u90E8\u7F72\u8BB0\u5F55", 1);
-  }
-  const environment = normalizeDeployEnvironment(deployOptions.env);
-  if (!environment) {
-    throw new DeployExecutionError(
-      `\u672A\u77E5\u90E8\u7F72\u73AF\u5883 ${deployOptions.env}\uFF0C\u4EC5\u652F\u6301 test/online`,
-      1
-    );
-  }
-  const api = createApmApiClient(cfg);
-  const repositoryId = await resolveRepositoryIdForWebIdeDeploy(
-    deployOptions.cwd,
-    api
-  );
-  let deploymentRunId;
-  try {
-    const run = await api.cli.createTaskDeployment({
-      taskId: tracking.taskId,
-      environment,
-      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);
-    throw new DeployExecutionError(`\u521B\u5EFA\u90E8\u7F72\u8BB0\u5F55\u5931\u8D25: ${detail}`, 1);
-  }
-  await api.cli.updateTaskDeploymentStatus({
-    id: deploymentRunId,
-    status: "DEPLOYING"
-  });
-  const { error: deployError } = await runTrackedDeploy({
-    api,
-    deploymentRunId,
-    run: async (appendLog) => {
-      const output = await executeDeploy({
-        ...deployOptions,
-        captureOutput: true,
-        archiveDeployArtifact: true
-      });
-      if (output.trim()) {
-        appendLog(output);
-      }
-      console.log(`[apm] deploy success id=${deploymentRunId}`);
-      return { status: "SUCCESS" };
-    }
-  });
-  if (deployError) {
-    printDeployExecutionError(deployError);
-    process.exit(deployError.exitCode);
-  }
-}
-
 // src/commands/deploy/deploy.ts
 function registerDeployMainCommand(program) {
   program.command("deploy").description(
@@ -6335,34 +5595,17 @@ function registerDeployMainCommand(program) {
   ).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(
-    "--task <taskId>",
-    "WebIDE \u4EFB\u52A1 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 SFTP/SSH\uFF08\u65E0\u9700 wisdomDeploy\uFF09"
   ).action(
     async (env, opts) => {
-      const cwd = process.cwd();
-      const taskId = opts.task?.trim();
-      const packOnly = Boolean(opts.packOnly);
       try {
-        if (taskId) {
-          await runDeployWithBackendTracking({
-            env,
-            cwd,
-            configPath: opts.config,
-            tracking: { taskId },
-            packOnly,
-            deployTrigger: "cli"
-          });
-          return;
-        }
         await executeDeploy({
           env,
-          cwd,
+          cwd: process.cwd(),
           configPath: opts.config,
-          packOnly,
+          packOnly: Boolean(opts.packOnly),
           deployTrigger: "cli"
         });
       } catch (error) {
@@ -6386,7 +5629,7 @@ import path15 from "node:path";
 import Docker from "dockerode";
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/connection-options.ts
-import { existsSync as existsSync17, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync11 } from "node:fs";
 import path12 from "node:path";
 function asOptionalTlsBuffer(value) {
   if (typeof value !== "string") {
@@ -6398,8 +5641,8 @@ function asOptionalTlsBuffer(value) {
   if (normalized === "") {
     return void 0;
   }
-  if (existsSync17(normalized)) {
-    return readFileSync12(normalized);
+  if (existsSync16(normalized)) {
+    return readFileSync11(normalized);
   }
   const looksLikePath = /[\\/]/.test(normalized) || normalized.endsWith(".pem");
   if (looksLikePath) {
@@ -6524,17 +5767,17 @@ var DockerodeClient = class {
     await this.client.getImage(image).remove({ force: true });
   }
   async pullImage(image, auth) {
-    const stream = await new Promise((resolve8, reject) => {
+    const stream = await new Promise((resolve7, 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;
         }
-        resolve8(output);
+        resolve7(output);
       });
     });
-    await new Promise((resolve8, reject) => {
+    await new Promise((resolve7, reject) => {
       this.client.modem.followProgress(
         stream,
         (err) => {
@@ -6542,7 +5785,7 @@ var DockerodeClient = class {
             reject(err);
             return;
           }
-          resolve8();
+          resolve7();
         },
         () => void 0
       );
@@ -6609,7 +5852,7 @@ var DockerodeClient = class {
 var createDockerodeClient = (config) => new DockerodeClient(config);
 
 // src/commands/deploy/internal/backend-deploy/dockerode-client/env.ts
-import { existsSync as existsSync18, readFileSync as readFileSync13, statSync as statSync9 } from "node:fs";
+import { existsSync as existsSync17, readFileSync as readFileSync12, statSync as statSync8 } from "node:fs";
 import path13 from "node:path";
 function stripSurroundingQuotes(value) {
   const t = value.trim();
@@ -6626,10 +5869,10 @@ function loadEnvFromFile(envFilePath) {
     return {};
   }
   const targetPath = path13.resolve(envFilePath);
-  if (!existsSync18(targetPath) || !statSync9(targetPath).isFile()) {
+  if (!existsSync17(targetPath) || !statSync8(targetPath).isFile()) {
     return {};
   }
-  const raw = readFileSync13(targetPath, "utf-8");
+  const raw = readFileSync12(targetPath, "utf-8");
   const result = {};
   for (const line of raw.split(/\r?\n/)) {
     const normalized = line.trim();
@@ -6800,12 +6043,12 @@ function dockerPushImage(params, cwd) {
 }
 
 // src/commands/deploy/internal/backend-deploy/resolve-dockerfile.ts
-import { existsSync as existsSync19 } from "node:fs";
+import { existsSync as existsSync18 } 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 (!existsSync19(dockerfilePath)) {
+  if (!existsSync18(dockerfilePath)) {
     throw new Error(`Dockerfile \u4E0D\u5B58\u5728\uFF1A${dockerfilePath}`);
   }
   Logger.info("\u2713 Dockerfile \u5B58\u5728");