ai-project-manage-cli 8.1.6 → 8.1.8

package/dist/index.js

@@ -79,179 +79,9 @@ function buildAgentWsUrl(httpBase, apiKey) {
   return `${origin}/ws/agent?${q.toString()}`;
 }
 
-// src/utils/workspace.ts
-import { copyFileSync, existsSync, mkdirSync as mkdirSync2, readdirSync, statSync } from "fs";
-import { dirname, join as join2, resolve as resolve2 } from "path";
-import { fileURLToPath } from "url";
-
-// src/utils/path.ts
-import { realpathSync } from "fs";
-import { platform } from "os";
-import { resolve } from "path";
-function toFsPath(inputPath) {
-  const absolute = resolve(inputPath);
-  if (platform() !== "win32") return absolute;
-  if (absolute.startsWith("\\\\?\\")) return absolute;
-  const normalized = absolute.replace(/\//g, "\\");
-  if (normalized.startsWith("\\\\")) {
-    return `\\\\?\\UNC\\${normalized.slice(2)}`;
-  }
-  return `\\\\?\\${normalized}`;
-}
-function normalizeWorkdirPath(path) {
-  let normalized = path.trim().replace(/\\/g, "/").normalize("NFC");
-  if (normalized.startsWith("//?/")) {
-    normalized = normalized.slice(4);
-  }
-  const windowsDrive = /^([A-Za-z]:)\/*(.*)$/.exec(normalized);
-  if (windowsDrive) {
-    const drive = windowsDrive[1].toLowerCase();
-    const rest = windowsDrive[2].replace(/\/+/g, "/").replace(/\/$/, "");
-    return rest ? `${drive}/${rest}` : drive;
-  }
-  normalized = normalized.replace(/\/+/g, "/");
-  if (normalized.length > 1 && normalized.endsWith("/")) {
-    normalized = normalized.slice(0, -1);
-  }
-  return normalized;
-}
-function resolveWorkdirPath(cwd = process.cwd()) {
-  const absolute = resolve(cwd);
-  try {
-    return normalizeWorkdirPath(realpathSync.native(absolute));
-  } catch {
-    return normalizeWorkdirPath(absolute);
-  }
-}
-
-// src/utils/workspace.ts
-var __dirname = dirname(fileURLToPath(import.meta.url));
-var CLI_TEMPLATE_DIR = resolve2(__dirname, "../template");
-function workspaceApmDir(cwd = resolveWorkdirPath()) {
-  return resolve2(resolve2(cwd), ".apm");
-}
-async function ensureLoggedConfig() {
-  const cfg = await ensureApmConfig();
-  if (!resolveApiKey(cfg)) {
-    console.error(
-      "[apm] \u672A\u68C0\u6D4B\u5230 API Key\uFF0C\u8BF7\u5148\u6267\u884C: apm login --api-key cm_xxx"
-    );
-    process.exit(1);
-  }
-  return cfg;
-}
-async function ensureDirExists(dir) {
-  mkdirSync2(dir, { recursive: true });
-}
-async function ensureWorkspaceApmDirForInit(cwd = resolveWorkdirPath()) {
-  const dir = workspaceApmDir(cwd);
-  const fsDir = toFsPath(dir);
-  if (existsSync(fsDir) && !statSync(fsDir).isDirectory()) {
-    throw new Error(`[apm] \u8DEF\u5F84\u5DF2\u5B58\u5728\u4F46\u4E0D\u662F\u76EE\u5F55: ${dir}`);
-  }
-  mkdirSync2(fsDir, { recursive: true });
-}
-var WEBIDE_AGENTS_TEMPLATE_NAME = "AGENTS.webide.md";
-function shouldSkipTemplateEntry(name) {
-  return name === ".DS_Store" || name === "Thumbs.db";
-}
-function isWebIdeRuleFileName(name) {
-  return name.startsWith("webide");
-}
-function copyTemplateEntry(src, dest) {
-  const fsSrc = toFsPath(src);
-  const fsDest = toFsPath(dest);
-  const st = statSync(fsSrc);
-  if (st.isDirectory()) {
-    mkdirSync2(fsDest, { recursive: true });
-    for (const name of readdirSync(fsSrc)) {
-      if (shouldSkipTemplateEntry(name)) continue;
-      copyTemplateEntry(join2(src, name), join2(dest, name));
-    }
-    return;
-  }
-  if (!st.isFile()) return;
-  mkdirSync2(toFsPath(dirname(dest)), { recursive: true });
-  copyFileSync(fsSrc, fsDest);
-}
-function listWebIdeRuleFileNames(rulesDir) {
-  const fsRulesDir = toFsPath(rulesDir);
-  if (!existsSync(fsRulesDir) || !statSync(fsRulesDir).isDirectory()) {
-    return [];
-  }
-  return readdirSync(fsRulesDir).filter((name) => {
-    if (shouldSkipTemplateEntry(name) || !isWebIdeRuleFileName(name)) {
-      return false;
-    }
-    return statSync(toFsPath(join2(rulesDir, name))).isFile();
-  });
-}
-function assertWebIdeTemplateCopiedToApm(apmDir, workdir) {
-  const required = ["AGENTS.md", "rules"];
-  for (const item of required) {
-    const path = join2(apmDir, item);
-    if (!existsSync(toFsPath(path))) {
-      throw new Error(`[apm] WebIDE \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path}`);
-    }
-  }
-  const rulesDir = join2(apmDir, "rules");
-  const ruleNames = listWebIdeRuleFileNames(rulesDir);
-  if (ruleNames.length === 0) {
-    throw new Error(`[apm] WebIDE \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11 webide \u89C4\u5219: ${rulesDir}`);
-  }
-  const leakedRules = join2(workdir, "rules");
-  const apmRules = join2(apmDir, "rules");
-  if (existsSync(toFsPath(leakedRules)) && !existsSync(toFsPath(join2(apmRules, "webide_reply.md")))) {
-    throw new Error(
-      `[apm] \u6A21\u677F\u88AB\u590D\u5236\u5230\u9519\u8BEF\u4F4D\u7F6E: ${leakedRules}\uFF08\u5E94\u5728 ${apmRules}\uFF09`
-    );
-  }
-}
-async function copyWebIdeTemplateFiles(targetDir, workdir = resolveWorkdirPath()) {
-  const resolvedTarget = resolve2(targetDir);
-  const templateDir = resolve2(CLI_TEMPLATE_DIR);
-  const fsTemplateDir = toFsPath(templateDir);
-  if (!existsSync(fsTemplateDir) || !statSync(fsTemplateDir).isDirectory()) {
-    throw new Error(`[apm] \u672A\u627E\u5230 CLI \u6A21\u677F\u76EE\u5F55: ${templateDir}`);
-  }
-  const agentsSrc = join2(templateDir, WEBIDE_AGENTS_TEMPLATE_NAME);
-  if (!existsSync(toFsPath(agentsSrc))) {
-    throw new Error(`[apm] \u672A\u627E\u5230 WebIDE \u6307\u5357: ${agentsSrc}`);
-  }
-  const rulesSrc = join2(templateDir, "rules");
-  const ruleNames = listWebIdeRuleFileNames(rulesSrc);
-  if (ruleNames.length === 0) {
-    throw new Error(`[apm] CLI \u6A21\u677F\u4E2D\u6CA1\u6709 webide \u89C4\u5219: ${rulesSrc}`);
-  }
-  mkdirSync2(toFsPath(resolvedTarget), { recursive: true });
-  copyFileSync(
-    toFsPath(agentsSrc),
-    toFsPath(join2(resolvedTarget, "AGENTS.md"))
-  );
-  const rulesDest = join2(resolvedTarget, "rules");
-  mkdirSync2(toFsPath(rulesDest), { recursive: true });
-  for (const name of ruleNames) {
-    copyTemplateEntry(join2(rulesSrc, name), join2(rulesDest, name));
-  }
-  assertWebIdeTemplateCopiedToApm(resolvedTarget, resolve2(workdir));
-}
-
-// src/commands/init.ts
-async function initializeWorkspace(workdir) {
-  await ensureWorkspaceApmDirForInit(workdir);
-  const apmDir = workspaceApmDir(workdir);
-  await copyWebIdeTemplateFiles(apmDir, workdir);
-  console.log(`[apm] \u5DF2\u6309 WebIDE \u521D\u59CB\u5316\u5DE5\u4F5C\u533A\uFF1A${apmDir}`);
-  return { didInit: true };
-}
-async function runInit() {
-  const workdir = resolveWorkdirPath();
-  await initializeWorkspace(workdir);
-  console.log(`[apm] \u5DE5\u4F5C\u76EE\u5F55\u8DEF\u5F84\uFF1A${workdir}`);
-}
-
-// src/commands/login.ts
-import { ApiError } from "listpage-http";
+// src/commands/sync-webide-agent.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
 
 // src/api/client.ts
 import { createApiClient } from "listpage-http";
@@ -266,6 +96,10 @@ var requestConfig = {
         path: "/cli/me"
       }
     ),
+    webideAgentConfig: defineEndpoint({
+      method: "GET",
+      path: "/cli/webide/agent-config"
+    }),
     webideAppendMessageContent: defineEndpoint({
       method: "PUT",
       path: "/cli/webide/messages/content"
@@ -324,6 +158,14 @@ var requestConfig = {
       method: "PUT",
       path: "/cli/webide/plan"
     }),
+    webideUpsertChecklist: defineEndpoint({
+      method: "PUT",
+      path: "/cli/webide/checklist"
+    }),
+    webideGetChecklist: defineEndpoint({
+      method: "GET",
+      path: "/cli/webide/checklist"
+    }),
     webideReplaceTestCases: defineEndpoint({
       method: "PUT",
       path: "/cli/webide/test-cases"
@@ -456,7 +298,157 @@ function createApmApiClient(cfg) {
   });
 }
 
+// src/utils/path.ts
+import { realpathSync } from "fs";
+import { platform } from "os";
+import { resolve } from "path";
+function toFsPath(inputPath) {
+  const absolute = resolve(inputPath);
+  if (platform() !== "win32") return absolute;
+  if (absolute.startsWith("\\\\?\\")) return absolute;
+  const normalized = absolute.replace(/\//g, "\\");
+  if (normalized.startsWith("\\\\")) {
+    return `\\\\?\\UNC\\${normalized.slice(2)}`;
+  }
+  return `\\\\?\\${normalized}`;
+}
+function normalizeWorkdirPath(path) {
+  let normalized = path.trim().replace(/\\/g, "/").normalize("NFC");
+  if (normalized.startsWith("//?/")) {
+    normalized = normalized.slice(4);
+  }
+  const windowsDrive = /^([A-Za-z]:)\/*(.*)$/.exec(normalized);
+  if (windowsDrive) {
+    const drive = windowsDrive[1].toLowerCase();
+    const rest = windowsDrive[2].replace(/\/+/g, "/").replace(/\/$/, "");
+    return rest ? `${drive}/${rest}` : drive;
+  }
+  normalized = normalized.replace(/\/+/g, "/");
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function resolveWorkdirPath(cwd = process.cwd()) {
+  const absolute = resolve(cwd);
+  try {
+    return normalizeWorkdirPath(realpathSync.native(absolute));
+  } catch {
+    return normalizeWorkdirPath(absolute);
+  }
+}
+
+// src/utils/workspace.ts
+import { existsSync, mkdirSync as mkdirSync2, readdirSync, statSync } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+function workspaceApmDir(cwd = resolveWorkdirPath()) {
+  return resolve2(resolve2(cwd), ".apm");
+}
+async function ensureLoggedConfig() {
+  const cfg = await ensureApmConfig();
+  if (!resolveApiKey(cfg)) {
+    console.error(
+      "[apm] \u672A\u68C0\u6D4B\u5230 API Key\uFF0C\u8BF7\u5148\u6267\u884C: apm login --api-key cm_xxx"
+    );
+    process.exit(1);
+  }
+  return cfg;
+}
+async function ensureDirExists(dir) {
+  mkdirSync2(dir, { recursive: true });
+}
+async function ensureWorkspaceApmDirForInit(cwd = resolveWorkdirPath()) {
+  const dir = workspaceApmDir(cwd);
+  const fsDir = toFsPath(dir);
+  if (existsSync(fsDir) && !statSync(fsDir).isDirectory()) {
+    throw new Error(`[apm] \u8DEF\u5F84\u5DF2\u5B58\u5728\u4F46\u4E0D\u662F\u76EE\u5F55: ${dir}`);
+  }
+  mkdirSync2(fsDir, { recursive: true });
+}
+
+// src/commands/sync-webide-agent.ts
+var REVISION_FILE = ".webide-agent.json";
+var RULE_KEY = /^webide_[a-z0-9_]+$/;
+function withTrailingNewline(text) {
+  return text.endsWith("\n") ? text : `${text}
+`;
+}
+function readRevision(apmDir) {
+  const path = toFsPath(join3(apmDir, REVISION_FILE));
+  if (!existsSync2(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    if (parsed?.version === 1 && parsed.revision?.trim()) {
+      return parsed.revision.trim();
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function writeRevision(apmDir, revision) {
+  writeFileSync2(
+    toFsPath(join3(apmDir, REVISION_FILE)),
+    `${JSON.stringify({ version: 1, revision }, null, 2)}
+`,
+    "utf8"
+  );
+}
+async function syncWebIdeAgentFiles(workdir, cfg) {
+  const api = createApmApiClient(cfg);
+  const bundle = await api.cli.webideAgentConfig();
+  const revision = bundle.revision?.trim();
+  if (!revision) {
+    throw new Error("[apm] \u5E73\u53F0\u672A\u8FD4\u56DE WebIDE \u89C4\u5219\u7248\u672C");
+  }
+  const apmDir = workspaceApmDir(workdir);
+  mkdirSync3(toFsPath(apmDir), { recursive: true });
+  if (readRevision(apmDir) === revision) {
+    return { revision, wrote: false, ruleCount: bundle.rules?.length ?? 0 };
+  }
+  const rulesDir = join3(apmDir, "rules");
+  mkdirSync3(toFsPath(rulesDir), { recursive: true });
+  writeFileSync2(
+    toFsPath(join3(apmDir, "AGENTS.md")),
+    withTrailingNewline(bundle.guide ?? ""),
+    "utf8"
+  );
+  for (const rule of bundle.rules ?? []) {
+    const key = rule.key?.trim() ?? "";
+    if (!RULE_KEY.test(key)) {
+      throw new Error(`[apm] \u975E\u6CD5\u89C4\u5219\u540D: ${key || "(\u7A7A)"}`);
+    }
+    writeFileSync2(
+      toFsPath(join3(rulesDir, `${key}.md`)),
+      withTrailingNewline(rule.body ?? ""),
+      "utf8"
+    );
+  }
+  writeRevision(apmDir, revision);
+  return {
+    revision,
+    wrote: true,
+    ruleCount: bundle.rules?.length ?? 0
+  };
+}
+
+// src/commands/init.ts
+async function initializeWorkspace(workdir, cfg) {
+  await ensureWorkspaceApmDirForInit(workdir);
+  await syncWebIdeAgentFiles(workdir, cfg);
+  const apmDir = workspaceApmDir(workdir);
+  console.log(`[apm] \u5DF2\u6309 WebIDE \u521D\u59CB\u5316\u5DE5\u4F5C\u533A\uFF1A${apmDir}`);
+  return { didInit: true };
+}
+async function runInit() {
+  const workdir = resolveWorkdirPath();
+  const cfg = await ensureLoggedConfig();
+  await initializeWorkspace(workdir, cfg);
+  console.log(`[apm] \u5DE5\u4F5C\u76EE\u5F55\u8DEF\u5F84\uFF1A${workdir}`);
+}
+
 // src/commands/login.ts
+import { ApiError } from "listpage-http";
 async function runLogin(opts) {
   const baseUrl = (opts.server?.trim() || process.env.AI_PM_SERVER?.trim() || DEFAULT_BASE_URL).replace(/\/+$/, "");
   const apiKey = (opts.apiKey?.trim() || process.env.APM_API_KEY?.trim() || "").replace(/^Bearer\s+/i, "");
@@ -512,17 +504,19 @@ async function runLogin(opts) {
 
 // src/commands/update.ts
 import { spawnSync } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
 
 // src/version.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, join as join3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname, join as join4 } from "path";
+import { fileURLToPath } from "url";
 var CLI_PACKAGE_NAME = "ai-project-manage-cli";
 function readCliVersion() {
   try {
-    const dir = dirname2(fileURLToPath2(import.meta.url));
-    const pkgPath = join3(dir, "..", "package.json");
-    const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+    const dir = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = join4(dir, "..", "package.json");
+    const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -530,6 +524,7 @@ function readCliVersion() {
 }
 
 // src/commands/update.ts
+var APM_SKIP_SELF_UPDATE_ENV = "APM_SKIP_SELF_UPDATE";
 var useNpmShell = process.platform === "win32";
 function runNpm(args, options = {}) {
   return spawnSync(useNpmShell ? "npm.cmd" : "npm", args, {
@@ -622,10 +617,17 @@ function npmAvailable() {
   return !r.error && r.status === 0;
 }
 async function runUpdate(options = {}) {
+  if (process.env[APM_SKIP_SELF_UPDATE_ENV] === "1") {
+    return { didUpdate: false };
+  }
   const current = readCliVersion();
   const currentMajor = parseMajorVersion(current);
   const globalLatest = await fetchLatestPublishedVersion();
   const latestInMajor = options.allowMajorUpgrade ? null : await fetchLatestPublishedVersionInMajor(currentMajor);
+  if (options.quietIfCurrent && !options.allowMajorUpgrade && !latestInMajor && !globalLatest) {
+    console.warn(`[apm] \u65E0\u6CD5\u68C0\u6D4B\u6700\u65B0\u7248\u672C\uFF0C\u7EE7\u7EED\u4F7F\u7528\u5F53\u524D ${current}`);
+    return { didUpdate: false };
+  }
   const resolved = resolveUpdateTarget({
     current,
     allowMajorUpgrade: options.allowMajorUpgrade,
@@ -633,8 +635,10 @@ async function runUpdate(options = {}) {
     globalLatest
   });
   if (resolved.action === "skip") {
-    console.log(`[apm] \u5DF2\u662F\u6700\u65B0\u7248\u672C ${current}`);
-    return;
+    if (!options.quietIfCurrent) {
+      console.log(`[apm] \u5DF2\u662F\u6700\u65B0\u7248\u672C ${current}`);
+    }
+    return { didUpdate: false };
   }
   if (resolved.majorUpgradeAvailable) {
     console.log(
@@ -671,26 +675,72 @@ async function runUpdate(options = {}) {
   } else {
     console.log(`[apm] \u5DF2\u662F\u6700\u65B0\u7248\u672C ${current}`);
   }
+  return { didUpdate: expectedBump };
+}
+function resolveApmEntryPath(entryArg = process.argv[1]) {
+  const npmResult = runNpm(["root", "-g"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (npmResult.status === 0) {
+    const globalRoot = npmResult.stdout?.toString().trim();
+    if (globalRoot) {
+      const candidate = join5(globalRoot, CLI_PACKAGE_NAME, "dist", "index.js");
+      if (existsSync3(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  const fromArgv = entryArg?.trim();
+  if (fromArgv && existsSync3(fromArgv)) {
+    return fromArgv;
+  }
+  if (fromArgv) {
+    return fromArgv;
+  }
+  console.error("[apm] \u65E0\u6CD5\u89E3\u6790 apm \u5165\u53E3\u8DEF\u5F84");
+  process.exit(1);
+}
+function reexecConnectAfterUpdate(options) {
+  console.log("[apm] \u66F4\u65B0\u5B8C\u6210\uFF0C\u6B63\u5728\u4EE5\u65B0\u7248\u672C\u91CD\u65B0\u8FDE\u63A5\u2026");
+  const apmScript = resolveApmEntryPath();
+  const args = [apmScript, "connect"];
+  const server = options.server?.trim();
+  if (server) {
+    args.push("--server", server);
+  }
+  const result = spawnSync(process.execPath, args, {
+    stdio: "inherit",
+    env: { ...process.env, [APM_SKIP_SELF_UPDATE_ENV]: "1" }
+  });
+  if (result.error) {
+    console.error("[apm] \u91CD\u542F connect \u5931\u8D25:", result.error.message);
+    process.exit(1);
+  }
+  process.exit(result.status ?? 0);
 }
 
 // src/commands/update-skills.ts
-import { existsSync as existsSync2, statSync as statSync2 } from "fs";
+import { existsSync as existsSync4, statSync as statSync2 } from "fs";
 async function syncWorkspaceSkills(workdir) {
   const apmDir = workspaceApmDir(workdir);
   const fsApmDir = toFsPath(apmDir);
-  if (!existsSync2(fsApmDir)) {
+  if (!existsSync4(fsApmDir)) {
     throw new Error("[apm] \u672A\u627E\u5230 .apm \u76EE\u5F55\uFF0C\u8BF7\u5148\u6267\u884C apm init");
   }
   const apmStat = statSync2(fsApmDir);
   if (!apmStat.isDirectory()) {
     throw new Error(`[apm] \u8DEF\u5F84\u5DF2\u5B58\u5728\u4F46\u4E0D\u662F\u76EE\u5F55: ${apmDir}`);
   }
-  await copyWebIdeTemplateFiles(apmDir, workdir);
-  console.log("[apm] \u5DF2\u540C\u6B65 WebIDE \u6307\u5357\u4E0E\u89C4\u5219");
+  const cfg = await ensureLoggedConfig();
+  const result = await syncWebIdeAgentFiles(workdir, cfg);
+  console.log(
+    result.wrote ? `[apm] \u5DF2\u540C\u6B65 WebIDE \u6307\u5357\u4E0E ${result.ruleCount} \u6761\u89C4\u5219` : "[apm] WebIDE \u6307\u5357\u4E0E\u89C4\u5219\u672A\u53D8\u5316"
+  );
 }
 async function runUpdateSkills() {
   const apmDir = workspaceApmDir();
-  if (!existsSync2(apmDir)) {
+  if (!existsSync4(apmDir)) {
     console.error("[apm] \u672A\u627E\u5230 .apm \u76EE\u5F55\uFF0C\u8BF7\u5148\u6267\u884C apm init");
     process.exit(1);
   }
@@ -703,14 +753,14 @@ async function runUpdateSkills() {
 
 // src/utils/project-documents.ts
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync5,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   rmSync,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync3
 } from "fs";
 import { createHash } from "crypto";
-import { dirname as dirname3, join as join4, relative, sep } from "path";
+import { dirname as dirname2, join as join6, relative, sep } from "path";
 
 // src/utils/git.ts
 import { execFile as execFile2 } from "child_process";
@@ -784,11 +834,11 @@ function normalizeProjectIdForPath(projectId) {
 }
 function projectDocumentsDir(apmRoot, projectId) {
   const id = normalizeProjectIdForPath(projectId);
-  return join4(apmRoot ?? workspaceApmDir(), "project", id);
+  return join6(apmRoot ?? workspaceApmDir(), "project", id);
 }
 function projectDocumentLocalPath(apmRoot, projectId, documentPath) {
   const normalized = normalizeLocalDocumentPath(documentPath);
-  return join4(
+  return join6(
     projectDocumentsDir(apmRoot, projectId),
     ...normalized.split("/")
   );
@@ -808,16 +858,16 @@ function hashLocalFileContent(content) {
   return createHash("sha256").update(content, "utf8").digest("hex");
 }
 function readLocalManifest(apmRoot, projectId) {
-  const manifestPath = join4(
+  const manifestPath = join6(
     projectDocumentsDir(apmRoot, projectId),
     MANIFEST_FILE
   );
-  if (!existsSync3(manifestPath)) {
+  if (!existsSync5(manifestPath)) {
     return null;
   }
   try {
     return JSON.parse(
-      readFileSync3(manifestPath, "utf8")
+      readFileSync4(manifestPath, "utf8")
     );
   } catch {
     return null;
@@ -825,13 +875,13 @@ function readLocalManifest(apmRoot, projectId) {
 }
 function listLocalDocumentPaths(apmRoot, projectId) {
   const root = projectDocumentsDir(apmRoot, projectId);
-  if (!existsSync3(root)) {
+  if (!existsSync5(root)) {
     return [];
   }
   const paths = [];
   const walk = (dir) => {
     for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-      const abs = join4(dir, entry.name);
+      const abs = join6(dir, entry.name);
       if (entry.isDirectory()) {
         walk(abs);
         continue;
@@ -950,8 +1000,8 @@ ${diagnostic ?? ""}`);
       const absPath = toFsPath(
         projectDocumentLocalPath(targetApmDir, projectId, doc.path)
       );
-      await ensureDirExists(dirname3(absPath));
-      writeFileSync2(absPath, doc.content, "utf8");
+      await ensureDirExists(dirname2(absPath));
+      writeFileSync3(absPath, doc.content, "utf8");
       downloaded += 1;
     }
   }
@@ -960,13 +1010,13 @@ ${diagnostic ?? ""}`);
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path)
     );
-    if (existsSync3(absPath)) {
+    if (existsSync5(absPath)) {
       rmSync(absPath, { force: true });
       deleted += 1;
     }
   }
-  writeFileSync2(
-    toFsPath(join4(docsDir, MANIFEST_FILE)),
+  writeFileSync3(
+    toFsPath(join6(docsDir, MANIFEST_FILE)),
     `${JSON.stringify(remoteManifest, null, 2)}
 `,
     "utf8"
@@ -1009,7 +1059,7 @@ async function syncProjectDocumentsPush(cfg, workdirPath, apmRoot, options) {
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path)
     );
-    const content = readFileSync3(absPath, "utf8");
+    const content = readFileSync4(absPath, "utf8");
     const contentHash = hashLocalFileContent(content);
     if (remoteHashByPath.get(path) === contentHash) {
       continue;
@@ -1284,8 +1334,8 @@ function handleCancelAction(payload, ctx) {
 }
 
 // src/commands/connect/core/worker/worker.ts
-import { dirname as dirname4, join as join5 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname3, join as join7 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { Worker } from "node:worker_threads";
 
 // src/commands/connect/core/worker/config.ts
@@ -1310,8 +1360,8 @@ function resolveWebIdeWorkerHeapMb(env = process.env, totalMemoryBytes = totalme
 }
 
 // src/commands/connect/core/worker/worker.ts
-var workerFile = join5(
-  dirname4(fileURLToPath3(import.meta.url)),
+var workerFile = join7(
+  dirname3(fileURLToPath2(import.meta.url)),
   "worker-script.js"
 );
 var ActionWorker = class {
@@ -1663,14 +1713,14 @@ function dispatchConnectAction(payload, ctx) {
 
 // src/commands/connect-lock.ts
 import {
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync4,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync5,
   unlinkSync,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "fs";
-import { join as join6 } from "path";
-var CONNECT_LOCK_PATH = join6(APM_CONFIG_DIR, "connect.lock");
+import { join as join8 } from "path";
+var CONNECT_LOCK_PATH = join8(APM_CONFIG_DIR, "connect.lock");
 function isProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   try {
@@ -1681,9 +1731,9 @@ function isProcessAlive(pid) {
   }
 }
 function readConnectLock() {
-  if (!existsSync4(CONNECT_LOCK_PATH)) return null;
+  if (!existsSync6(CONNECT_LOCK_PATH)) return null;
   try {
-    const raw = readFileSync4(CONNECT_LOCK_PATH, "utf8");
+    const raw = readFileSync5(CONNECT_LOCK_PATH, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.pid !== "number" || typeof parsed.startedAt !== "string") {
       return null;
@@ -1715,12 +1765,12 @@ function acquireConnectLock() {
     console.error(`[apm] \u5DF2\u6709 apm connect \u5728\u8FD0\u884C (pid=${existing.pid})`);
     process.exit(1);
   }
-  mkdirSync3(APM_CONFIG_DIR, { recursive: true });
+  mkdirSync4(APM_CONFIG_DIR, { recursive: true });
   const lock = {
     pid: process.pid,
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync3(
+  writeFileSync4(
     CONNECT_LOCK_PATH,
     JSON.stringify(lock, null, 2) + "\n",
     "utf8"
@@ -1847,6 +1897,10 @@ function resolveConnectServerOption(options) {
   return void 0;
 }
 async function runConnect(options) {
+  const { didUpdate } = await runUpdate({ quietIfCurrent: true });
+  if (didUpdate) {
+    reexecConnectAfterUpdate(options);
+  }
   const cfg = await ensureLoggedConfig();
   const serverOverride = resolveConnectServerOption(options);
   if (serverOverride) {
@@ -1951,7 +2005,7 @@ function buildProgram() {
   ).option("--api-key <key>", "\u8FDC\u7A0B\u4E3B\u673A API Key\uFF08cm_ \u5F00\u5934\uFF09").option("--server <url>", "API \u6839\u5730\u5740\uFF0C\u4F8B\u5982 http://127.0.0.1:3000").action(async (opts) => {
     await runLogin(opts);
   });
-  program.command("init").description("\u5728\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6309 WebIDE \u5DE5\u4F5C\u533A\u521D\u59CB\u5316\uFF1A\u5199\u5165\u6307\u5357\u4E0E webide \u89C4\u5219").action(async () => {
+  program.command("init").description("\u5728\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6309 WebIDE \u5DE5\u4F5C\u533A\u521D\u59CB\u5316\uFF1A\u4ECE\u5E73\u53F0\u5199\u5165\u6307\u5357\u4E0E\u89C4\u5219").action(async () => {
     await runInit();
   });
   program.command("update").description(
@@ -1964,7 +2018,7 @@ function buildProgram() {
   ).action(async (opts) => {
     await runUpdate({ allowMajorUpgrade: opts.major === true });
   });
-  program.command("update-skills").description("\u540C\u6B65 .apm/ \u4E0B\u7684 WebIDE \u6307\u5357\u4E0E\u89C4\u5219").action(async () => {
+  program.command("update-skills").description("\u4ECE\u5E73\u53F0\u540C\u6B65 .apm/ \u4E0B\u7684 WebIDE \u6307\u5357\u4E0E\u89C4\u5219").action(async () => {
     await runUpdateSkills();
   });
   program.command("sync-project-documents").description(
@@ -1973,7 +2027,7 @@ function buildProgram() {
     await runSyncProjectDocuments(opts);
   });
   program.command("connect").description(
-    "\u8FDE\u63A5\u5E73\u53F0 WebSocket\uFF08/ws/agent\uFF09\uFF0C\u7EF4\u6301\u5FC3\u8DF3\u5E76\u5904\u7406\u4E0B\u884C webide-message"
+    "\u8FDE\u63A5\u524D\u68C0\u6D4B\u5E76\u66F4\u65B0\u5230\u5F53\u524D\u5927\u7248\u672C\u6700\u65B0 CLI\uFF0C\u518D\u8FDE\u63A5\u5E73\u53F0 WebSocket\uFF08/ws/agent\uFF09"
   ).option("--server <url>", "API \u6839\u5730\u5740\uFF0C\u8986\u76D6 config \u4E2D\u7684 baseUrl").action(async (opts) => {
     await runConnect({ server: opts.server });
   });