@lark-apaas/fullstack-cli 1.1.68-alpha.20261019102946 → 1.1.68-beta.0

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import fs29 from "fs";
-import path25 from "path";
+import fs31 from "fs";
+import path26 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { config as dotenvConfig } from "dotenv";
 
@@ -2478,8 +2478,8 @@ var genDbSchemaCommand = {
 };
 
 // src/commands/sync/run.handler.ts
-import path5 from "path";
-import fs7 from "fs";
+import path6 from "path";
+import fs9 from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/config/sync.ts
@@ -2581,6 +2581,9 @@ function buildDefaultRules(opts) {
       type: "file",
       overwrite: true
     },
+    // UI 位于 server/mcp/ui，检查配置由 Agent 随 UI 代码创建。
+    // 不生成 UI 目录；仅给已有 Nest 工程增量补服务端排除项。
+    { onlyNestjs: true, type: "typescript-exclude", to: "tsconfig.node.json", path: "server/mcp/ui" },
     // 9. 把模板版本的 lint 脚本替换为支持 --files 的 runner
     //    只识别平台模板生成的 `concurrently ...` 形态，用户真正改写过的脚本保持原样
     {
@@ -2750,18 +2753,68 @@ function activateGitHooks(userProjectRoot) {
   return { action: "already-active" };
 }
 
+// src/commands/sync/typescript-exclude.ts
+import fs7 from "fs";
+import { applyEdits, modify, parse } from "jsonc-parser";
+function excludeTypeScriptPath(filename, excludedPath) {
+  if (!fs7.existsSync(filename)) return false;
+  const source = fs7.readFileSync(filename, "utf8");
+  const errors = [];
+  const raw = parse(source, errors, { allowTrailingComma: true });
+  if (errors.length || !raw || typeof raw !== "object") throw new Error(`Invalid exclude array: ${filename}`);
+  if (raw.exclude === void 0) {
+    console.warn(`Cannot safely update inherited excludes in ${filename}; add ${excludedPath} to the effective TypeScript exclude configuration.`);
+    return false;
+  }
+  if (!Array.isArray(raw.exclude) || raw.exclude.some((p) => typeof p !== "string")) throw new Error(`Invalid exclude array: ${filename}`);
+  if (raw.exclude.includes(excludedPath)) return false;
+  fs7.writeFileSync(filename, applyEdits(source, modify(source, ["exclude", raw.exclude.length], excludedPath, {
+    isArrayInsertion: true,
+    formattingOptions: { insertSpaces: true, tabSize: 2, eol: source.includes("\r\n") ? "\r\n" : "\n" }
+  })));
+  return true;
+}
+
+// src/commands/sync/resolve-stack.ts
+import fs8 from "fs";
+import path5 from "path";
+function resolveStack(userProjectRoot) {
+  const sparkMetaPath = path5.join(userProjectRoot, ".spark", "meta.json");
+  if (!fs8.existsSync(sparkMetaPath)) {
+    return void 0;
+  }
+  try {
+    const meta = JSON.parse(fs8.readFileSync(sparkMetaPath, "utf-8"));
+    return typeof meta.stack === "string" ? meta.stack : void 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[fullstack-cli] \u26A0 Failed to read .spark/meta.json, fallback to default sync: ${message}`);
+    return void 0;
+  }
+}
+function isNestjsProject(root, stack) {
+  if (stack === "nestjs-react-fullstack") return true;
+  if (stack) return false;
+  try {
+    const pkg2 = JSON.parse(fs8.readFileSync(path5.join(root, "package.json"), "utf8"));
+    return Boolean(pkg2.dependencies?.["@nestjs/core"]) && fs8.existsSync(path5.join(root, "tsconfig.node.json"));
+  } catch {
+    return false;
+  }
+}
+
 // src/commands/sync/run.handler.ts
 async function run2(options) {
   const userProjectRoot = process.env.INIT_CWD || process.cwd();
   const __filename = fileURLToPath3(import.meta.url);
-  const __dirname2 = path5.dirname(__filename);
-  const pluginRoot = path5.resolve(__dirname2, "..");
+  const __dirname2 = path6.dirname(__filename);
+  const pluginRoot = path6.resolve(__dirname2, "..");
   if (userProjectRoot === pluginRoot) {
     console.log("[fullstack-cli] Skip syncing (installing plugin itself)");
     process.exit(0);
   }
-  const userPackageJson = path5.join(userProjectRoot, "package.json");
-  if (!fs7.existsSync(userPackageJson)) {
+  const userPackageJson = path6.join(userProjectRoot, "package.json");
+  if (!fs9.existsSync(userPackageJson)) {
     console.log("[fullstack-cli] Skip syncing (not a valid npm project)");
     process.exit(0);
   }
@@ -2775,7 +2828,9 @@ async function run2(options) {
       console.warn("[fullstack-cli] No sync configuration found");
       process.exit(0);
     }
+    const isNestjs = isNestjsProject(userProjectRoot, stack);
     for (const rule of config.sync) {
+      if (rule.onlyNestjs && !isNestjs) continue;
       await syncRule(rule, pluginRoot, userProjectRoot);
     }
     if (config.permissions) {
@@ -2796,23 +2851,13 @@ async function run2(options) {
     process.exit(1);
   }
 }
-function resolveStack(userProjectRoot) {
-  const sparkMetaPath = path5.join(userProjectRoot, ".spark", "meta.json");
-  if (!fs7.existsSync(sparkMetaPath)) {
-    return void 0;
-  }
-  try {
-    const meta = JSON.parse(fs7.readFileSync(sparkMetaPath, "utf-8"));
-    return typeof meta.stack === "string" ? meta.stack : void 0;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.warn(`[fullstack-cli] \u26A0 Failed to read .spark/meta.json, fallback to default sync: ${message}`);
-    return void 0;
-  }
-}
 async function syncRule(rule, pluginRoot, userProjectRoot) {
+  if (rule.type === "typescript-exclude") {
+    excludeTypeScriptPath(path6.join(userProjectRoot, rule.to), rule.path);
+    return;
+  }
   if (rule.type === "delete-file" || rule.type === "delete-directory") {
-    const destPath2 = path5.join(userProjectRoot, rule.to);
+    const destPath2 = path6.join(userProjectRoot, rule.to);
     if (rule.type === "delete-file") {
       deleteFile(destPath2);
     } else {
@@ -2821,37 +2866,37 @@ async function syncRule(rule, pluginRoot, userProjectRoot) {
     return;
   }
   if (rule.type === "remove-line") {
-    const destPath2 = path5.join(userProjectRoot, rule.to);
+    const destPath2 = path6.join(userProjectRoot, rule.to);
     removeLineFromFile(destPath2, rule.pattern);
     return;
   }
   if (rule.type === "add-script") {
-    const packageJsonPath = path5.join(userProjectRoot, "package.json");
+    const packageJsonPath = path6.join(userProjectRoot, "package.json");
     addScript(packageJsonPath, rule.name, rule.command, rule.overwrite ?? false);
     return;
   }
   if (rule.type === "patch-script") {
-    const packageJsonPath = path5.join(userProjectRoot, "package.json");
+    const packageJsonPath = path6.join(userProjectRoot, "package.json");
     patchScript(packageJsonPath, rule.name, rule.to, rule.ifStartsWith);
     return;
   }
   if (rule.type === "add-line") {
-    const destPath2 = path5.join(userProjectRoot, rule.to);
+    const destPath2 = path6.join(userProjectRoot, rule.to);
     addLineToFile(destPath2, rule.line);
     return;
   }
   if (rule.type === "merge-json") {
-    const srcPath2 = path5.join(pluginRoot, rule.from);
-    const destPath2 = path5.join(userProjectRoot, rule.to);
+    const srcPath2 = path6.join(pluginRoot, rule.from);
+    const destPath2 = path6.join(userProjectRoot, rule.to);
     mergeJsonFile(srcPath2, destPath2, rule.arrayMerge);
     return;
   }
   if (!("from" in rule)) {
     return;
   }
-  const srcPath = path5.join(pluginRoot, rule.from);
-  const destPath = path5.join(userProjectRoot, rule.to);
-  if (!fs7.existsSync(srcPath)) {
+  const srcPath = path6.join(pluginRoot, rule.from);
+  const destPath = path6.join(userProjectRoot, rule.to);
+  if (!fs9.existsSync(srcPath)) {
     console.warn(`[fullstack-cli] Source not found: ${rule.from}`);
     return;
   }
@@ -2868,68 +2913,68 @@ async function syncRule(rule, pluginRoot, userProjectRoot) {
   }
 }
 function syncFile(src, dest, overwrite = true, onlyIfExists = false) {
-  if (onlyIfExists && !fs7.existsSync(dest)) {
-    console.log(`[fullstack-cli] \u25CB ${path5.basename(dest)} (skipped, target not exists)`);
+  if (onlyIfExists && !fs9.existsSync(dest)) {
+    console.log(`[fullstack-cli] \u25CB ${path6.basename(dest)} (skipped, target not exists)`);
     return;
   }
-  const destDir = path5.dirname(dest);
-  if (!fs7.existsSync(destDir)) {
-    fs7.mkdirSync(destDir, { recursive: true });
+  const destDir = path6.dirname(dest);
+  if (!fs9.existsSync(destDir)) {
+    fs9.mkdirSync(destDir, { recursive: true });
   }
-  if (fs7.existsSync(dest) && !overwrite) {
-    console.log(`[fullstack-cli] \u25CB ${path5.basename(dest)} (skipped, already exists)`);
+  if (fs9.existsSync(dest) && !overwrite) {
+    console.log(`[fullstack-cli] \u25CB ${path6.basename(dest)} (skipped, already exists)`);
     return;
   }
-  fs7.copyFileSync(src, dest);
-  console.log(`[fullstack-cli] \u2713 ${path5.basename(dest)}`);
+  fs9.copyFileSync(src, dest);
+  console.log(`[fullstack-cli] \u2713 ${path6.basename(dest)}`);
 }
 function syncDirectory(src, dest, overwrite = true) {
-  if (!fs7.existsSync(dest)) {
-    fs7.mkdirSync(dest, { recursive: true });
+  if (!fs9.existsSync(dest)) {
+    fs9.mkdirSync(dest, { recursive: true });
   }
-  const files = fs7.readdirSync(src);
+  const files = fs9.readdirSync(src);
   let count = 0;
   files.forEach((file) => {
-    const srcFile = path5.join(src, file);
-    const destFile = path5.join(dest, file);
-    const stats = fs7.statSync(srcFile);
+    const srcFile = path6.join(src, file);
+    const destFile = path6.join(dest, file);
+    const stats = fs9.statSync(srcFile);
     if (stats.isDirectory()) {
       syncDirectory(srcFile, destFile, overwrite);
     } else {
-      if (overwrite || !fs7.existsSync(destFile)) {
-        fs7.copyFileSync(srcFile, destFile);
-        console.log(`[fullstack-cli] \u2713 ${path5.relative(dest, destFile)}`);
+      if (overwrite || !fs9.existsSync(destFile)) {
+        fs9.copyFileSync(srcFile, destFile);
+        console.log(`[fullstack-cli] \u2713 ${path6.relative(dest, destFile)}`);
         count++;
       }
     }
   });
   if (count > 0) {
-    console.log(`[fullstack-cli] Synced ${count} files to ${path5.basename(dest)}/`);
+    console.log(`[fullstack-cli] Synced ${count} files to ${path6.basename(dest)}/`);
   }
 }
 function appendToFile(src, dest) {
-  const content = fs7.readFileSync(src, "utf-8");
+  const content = fs9.readFileSync(src, "utf-8");
   let existingContent = "";
-  if (fs7.existsSync(dest)) {
-    existingContent = fs7.readFileSync(dest, "utf-8");
+  if (fs9.existsSync(dest)) {
+    existingContent = fs9.readFileSync(dest, "utf-8");
   }
   if (existingContent.includes(content.trim())) {
-    console.log(`[fullstack-cli] \u25CB ${path5.basename(dest)} (already contains content)`);
+    console.log(`[fullstack-cli] \u25CB ${path6.basename(dest)} (already contains content)`);
     return;
   }
-  fs7.appendFileSync(dest, content);
-  console.log(`[fullstack-cli] \u2713 ${path5.basename(dest)} (appended)`);
+  fs9.appendFileSync(dest, content);
+  console.log(`[fullstack-cli] \u2713 ${path6.basename(dest)} (appended)`);
 }
 function setPermissions(permissions, projectRoot) {
   for (const [pattern, mode] of Object.entries(permissions)) {
     if (pattern === "**/*.sh") {
-      const scriptsDir = path5.join(projectRoot, "scripts");
-      if (fs7.existsSync(scriptsDir)) {
-        const files = fs7.readdirSync(scriptsDir);
+      const scriptsDir = path6.join(projectRoot, "scripts");
+      if (fs9.existsSync(scriptsDir)) {
+        const files = fs9.readdirSync(scriptsDir);
         files.forEach((file) => {
           if (file.endsWith(".sh")) {
-            const filePath = path5.join(scriptsDir, file);
-            fs7.chmodSync(filePath, mode);
+            const filePath = path6.join(scriptsDir, file);
+            fs9.chmodSync(filePath, mode);
           }
         });
       }
@@ -2937,27 +2982,27 @@ function setPermissions(permissions, projectRoot) {
   }
 }
 function deleteFile(filePath) {
-  if (fs7.existsSync(filePath)) {
-    fs7.unlinkSync(filePath);
-    console.log(`[fullstack-cli] \u2713 ${path5.basename(filePath)} (deleted)`);
+  if (fs9.existsSync(filePath)) {
+    fs9.unlinkSync(filePath);
+    console.log(`[fullstack-cli] \u2713 ${path6.basename(filePath)} (deleted)`);
   } else {
-    console.log(`[fullstack-cli] \u25CB ${path5.basename(filePath)} (not found)`);
+    console.log(`[fullstack-cli] \u25CB ${path6.basename(filePath)} (not found)`);
   }
 }
 function deleteDirectory(dirPath) {
-  if (fs7.existsSync(dirPath)) {
-    fs7.rmSync(dirPath, { recursive: true });
-    console.log(`[fullstack-cli] \u2713 ${path5.basename(dirPath)} (deleted)`);
+  if (fs9.existsSync(dirPath)) {
+    fs9.rmSync(dirPath, { recursive: true });
+    console.log(`[fullstack-cli] \u2713 ${path6.basename(dirPath)} (deleted)`);
   } else {
-    console.log(`[fullstack-cli] \u25CB ${path5.basename(dirPath)} (not found)`);
+    console.log(`[fullstack-cli] \u25CB ${path6.basename(dirPath)} (not found)`);
   }
 }
 function addScript(packageJsonPath, name, command, overwrite) {
-  if (!fs7.existsSync(packageJsonPath)) {
+  if (!fs9.existsSync(packageJsonPath)) {
     console.log(`[fullstack-cli] \u25CB package.json (not found)`);
     return;
   }
-  const content = fs7.readFileSync(packageJsonPath, "utf-8");
+  const content = fs9.readFileSync(packageJsonPath, "utf-8");
   const pkg2 = JSON.parse(content);
   if (!pkg2.scripts) {
     pkg2.scripts = {};
@@ -2969,16 +3014,16 @@ function addScript(packageJsonPath, name, command, overwrite) {
     }
   }
   pkg2.scripts[name] = command;
-  fs7.writeFileSync(packageJsonPath, JSON.stringify(pkg2, null, 2) + "\n");
+  fs9.writeFileSync(packageJsonPath, JSON.stringify(pkg2, null, 2) + "\n");
   console.log(`[fullstack-cli] \u2713 scripts.${name}`);
 }
 function patchScript(packageJsonPath, name, to, ifStartsWith) {
-  if (!fs7.existsSync(packageJsonPath)) {
+  if (!fs9.existsSync(packageJsonPath)) {
     console.log(`[fullstack-cli] \u25CB package.json (not found)`);
     return;
   }
   try {
-    const content = fs7.readFileSync(packageJsonPath, "utf-8");
+    const content = fs9.readFileSync(packageJsonPath, "utf-8");
     const pkg2 = JSON.parse(content);
     const current = pkg2.scripts?.[name];
     if (!current) {
@@ -2996,7 +3041,7 @@ function patchScript(packageJsonPath, name, to, ifStartsWith) {
       return;
     }
     pkg2.scripts[name] = to;
-    fs7.writeFileSync(packageJsonPath, JSON.stringify(pkg2, null, 2) + "\n");
+    fs9.writeFileSync(packageJsonPath, JSON.stringify(pkg2, null, 2) + "\n");
     console.log(`[fullstack-cli] \u2713 Patched scripts.${name}`);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -3004,38 +3049,38 @@ function patchScript(packageJsonPath, name, to, ifStartsWith) {
   }
 }
 function addLineToFile(filePath, line) {
-  const fileName = path5.basename(filePath);
-  if (!fs7.existsSync(filePath)) {
+  const fileName = path6.basename(filePath);
+  if (!fs9.existsSync(filePath)) {
     console.log(`[fullstack-cli] \u25CB ${fileName} (not found, skipped)`);
     return;
   }
-  const content = fs7.readFileSync(filePath, "utf-8");
+  const content = fs9.readFileSync(filePath, "utf-8");
   const lines = content.split("\n").map((l) => l.trim());
   if (lines.includes(line)) {
     console.log(`[fullstack-cli] \u25CB ${fileName} (line already exists: ${line})`);
     return;
   }
   const appendContent = (content.endsWith("\n") ? "" : "\n") + line + "\n";
-  fs7.appendFileSync(filePath, appendContent);
+  fs9.appendFileSync(filePath, appendContent);
   console.log(`[fullstack-cli] \u2713 ${fileName} (added: ${line})`);
 }
 function mergeJsonFile(src, dest, arrayMerge) {
-  const fileName = path5.basename(dest);
-  if (!fs7.existsSync(src)) {
+  const fileName = path6.basename(dest);
+  if (!fs9.existsSync(src)) {
     console.warn(`[fullstack-cli] Source not found: ${src}`);
     return;
   }
-  const templateContent = JSON.parse(fs7.readFileSync(src, "utf-8"));
-  if (!fs7.existsSync(dest)) {
-    const destDir = path5.dirname(dest);
-    if (!fs7.existsSync(destDir)) {
-      fs7.mkdirSync(destDir, { recursive: true });
+  const templateContent = JSON.parse(fs9.readFileSync(src, "utf-8"));
+  if (!fs9.existsSync(dest)) {
+    const destDir = path6.dirname(dest);
+    if (!fs9.existsSync(destDir)) {
+      fs9.mkdirSync(destDir, { recursive: true });
     }
-    fs7.writeFileSync(dest, JSON.stringify(templateContent, null, 2) + "\n");
+    fs9.writeFileSync(dest, JSON.stringify(templateContent, null, 2) + "\n");
     console.log(`[fullstack-cli] \u2713 ${fileName} (created)`);
     return;
   }
-  const userContent = JSON.parse(fs7.readFileSync(dest, "utf-8"));
+  const userContent = JSON.parse(fs9.readFileSync(dest, "utf-8"));
   const merged = deepMergeJson(userContent, templateContent, arrayMerge ?? {});
   const userStr = JSON.stringify(userContent, null, 2);
   const mergedStr = JSON.stringify(merged, null, 2);
@@ -3043,7 +3088,7 @@ function mergeJsonFile(src, dest, arrayMerge) {
     console.log(`[fullstack-cli] \u25CB ${fileName} (already up to date)`);
     return;
   }
-  fs7.writeFileSync(dest, mergedStr + "\n");
+  fs9.writeFileSync(dest, mergedStr + "\n");
   console.log(`[fullstack-cli] \u2713 ${fileName} (merged)`);
 }
 
@@ -3058,6 +3103,105 @@ var syncCommand = {
   }
 };
 
+// src/utils/api-error.ts
+var LOGID_HEADER = "x-tt-logid";
+var ERROR_RESPONSE_PREVIEW_LIMIT = 2e3;
+var InnerApiError = class _InnerApiError extends Error {
+  constructor(message, detail = {}) {
+    super(message);
+    this.name = "InnerApiError";
+    this.logId = detail.logId ?? "";
+    this.status = detail.status;
+    this.body = detail.body;
+    if (detail.cause !== void 0) {
+      this.cause = detail.cause;
+    }
+    Object.setPrototypeOf(this, _InnerApiError.prototype);
+  }
+};
+function getLogId(response) {
+  const headers = response?.headers;
+  if (!headers || typeof headers !== "object") {
+    return "";
+  }
+  try {
+    const getter = headers.get;
+    if (typeof getter === "function") {
+      return getter.call(headers, LOGID_HEADER) ?? "";
+    }
+    const value = headers[LOGID_HEADER];
+    return typeof value === "string" ? value : "";
+  } catch {
+    return "";
+  }
+}
+function formatLogId(response) {
+  const logId = getLogId(response);
+  return logId ? `, logid: ${logId}` : "";
+}
+async function readErrorBody(response) {
+  try {
+    if (typeof response.text === "function") {
+      const text = await response.text();
+      return text ? text.slice(0, ERROR_RESPONSE_PREVIEW_LIMIT) : "";
+    }
+    if (typeof response.json === "function") {
+      const serialized = JSON.stringify(await response.json());
+      return serialized ? serialized.slice(0, ERROR_RESPONSE_PREVIEW_LIMIT) : "";
+    }
+  } catch {
+    return "";
+  }
+  return "";
+}
+function asHttpErrorResponse(error) {
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  const response = error.response;
+  return response && typeof response === "object" ? response : void 0;
+}
+async function buildError(message, response, cause) {
+  if (!response) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    return new InnerApiError(`${message}: ${reason}`, { cause });
+  }
+  const logId = getLogId(response);
+  const body = await readErrorBody(response);
+  const parts = [`${message}: ${response.status ?? "unknown"}`];
+  if (response.statusText) {
+    parts.push(` ${response.statusText}`);
+  }
+  if (logId) {
+    parts.push(`, logid: ${logId}`);
+  }
+  if (body) {
+    parts.push(`, response: ${body}`);
+  }
+  return new InnerApiError(parts.join(""), {
+    logId,
+    status: response.status,
+    body,
+    cause
+  });
+}
+async function requestWithLogId(send, message, options = {}) {
+  let response;
+  try {
+    response = await send();
+  } catch (error) {
+    throw await buildError(message, asHttpErrorResponse(error), error);
+  }
+  if (!response) {
+    throw new InnerApiError(`${message}: \u672A\u62FF\u5230\u54CD\u5E94\u5BF9\u8C61`);
+  }
+  const isOk = options.expectStatus200 ? response.ok !== false && response.status === 200 : response.ok === true;
+  if (!isOk) {
+    throw await buildError(message, response, void 0);
+  }
+  return response;
+}
+
 // src/utils/telemetry.ts
 async function reportEvents(events) {
   if (events.length === 0) {
@@ -3065,14 +3209,13 @@ async function reportEvents(events) {
   }
   try {
     const client = getHttpClient();
-    const response = await client.post("/api/v1/studio/innerapi/resource_events", { events });
-    if (!response.ok) {
-      console.warn(`[telemetry] Failed to report events: ${response.status} ${response.statusText}`);
-      return false;
-    }
+    const response = await requestWithLogId(
+      () => client.post("/api/v1/studio/innerapi/resource_events", { events }),
+      "resource_events \u8BF7\u6C42\u5931\u8D25"
+    );
     const result = await response.json();
     if (result.status_code !== "0") {
-      console.warn(`[telemetry] API error: ${result.message}`);
+      console.warn(`[telemetry] API error: ${result.message}${formatLogId(response)}`);
       return false;
     }
     return true;
@@ -3104,12 +3247,12 @@ async function reportCreateInstanceEvent(pluginKey, version) {
 
 // src/utils/git.ts
 import { execSync, spawnSync as spawnSync3 } from "child_process";
-import fs8 from "fs";
-import path6 from "path";
+import fs10 from "fs";
+import path7 from "path";
 function isGitRepository(cwd = process.cwd()) {
   try {
-    const gitDir = path6.join(cwd, ".git");
-    if (fs8.existsSync(gitDir)) {
+    const gitDir = path7.join(cwd, ".git");
+    if (fs10.existsSync(gitDir)) {
       return true;
     }
     const result = spawnSync3("git", ["rev-parse", "--git-dir"], {
@@ -3138,7 +3281,7 @@ function getChangedFiles(cwd = process.cwd()) {
 function gitAddUpgradeFiles(cwd = process.cwd(), filesToStage) {
   const filteredFiles = [];
   for (const filePath of filesToStage) {
-    if (fs8.existsSync(path6.join(cwd, filePath))) {
+    if (fs10.existsSync(path7.join(cwd, filePath))) {
       filteredFiles.push(filePath);
       continue;
     }
@@ -3223,20 +3366,20 @@ Auto-committed by fullstack-cli`;
 }
 
 // src/utils/package-json.ts
-import fs9 from "fs";
-import path7 from "path";
+import fs11 from "fs";
+import path8 from "path";
 function readPackageJson(cwd = process.cwd()) {
-  const pkgPath = path7.join(cwd, "package.json");
-  if (!fs9.existsSync(pkgPath)) {
+  const pkgPath = path8.join(cwd, "package.json");
+  if (!fs11.existsSync(pkgPath)) {
     throw new Error(`package.json not found at ${pkgPath}`);
   }
-  const content = fs9.readFileSync(pkgPath, "utf-8");
+  const content = fs11.readFileSync(pkgPath, "utf-8");
   return JSON.parse(content);
 }
 function writePackageJson(pkg2, cwd = process.cwd()) {
-  const pkgPath = path7.join(cwd, "package.json");
+  const pkgPath = path8.join(cwd, "package.json");
   const content = JSON.stringify(pkg2, null, 2) + "\n";
-  fs9.writeFileSync(pkgPath, content, "utf-8");
+  fs11.writeFileSync(pkgPath, content, "utf-8");
 }
 function removeUpgradeScript(pkg2) {
   if (!pkg2.scripts?.upgrade) {
@@ -3281,15 +3424,15 @@ function cleanupPackageJson(cwd = process.cwd()) {
 }
 
 // src/commands/upgrade/shared/utils.ts
-import path8 from "path";
-import fs10 from "fs";
+import path9 from "path";
+import fs12 from "fs";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function getCliVersion() {
   try {
     const __filename = fileURLToPath4(import.meta.url);
-    const __dirname2 = path8.dirname(__filename);
-    const pkgPath = path8.resolve(__dirname2, "../../../package.json");
-    const pkgContent = fs10.readFileSync(pkgPath, "utf-8");
+    const __dirname2 = path9.dirname(__filename);
+    const pkgPath = path9.resolve(__dirname2, "../../../package.json");
+    const pkgContent = fs12.readFileSync(pkgPath, "utf-8");
     const pkg2 = JSON.parse(pkgContent);
     return pkg2.version || "unknown";
   } catch {
@@ -3298,11 +3441,14 @@ function getCliVersion() {
 }
 
 // src/commands/upgrade/get-upgrade-files.ts
-function getUpgradeFilesToStage(disableGenOpenapi = true) {
-  const syncConfig = genSyncConfig(void 0, { disableGenOpenapi });
+function getUpgradeFilesToStage(disableGenOpenapi = true, userProjectRoot = process.env.INIT_CWD || process.cwd()) {
+  const stack = resolveStack(userProjectRoot);
+  const isNestjs = isNestjsProject(userProjectRoot, stack);
+  const syncConfig = genSyncConfig(stack, { disableGenOpenapi });
   const filesToStage = /* @__PURE__ */ new Set();
   syncConfig.sync.forEach((rule) => {
-    if (rule.type === "file" || rule.type === "directory" || rule.type === "merge-json") {
+    if (rule.onlyNestjs && !isNestjs) return;
+    if (rule.type === "file" || rule.type === "directory" || rule.type === "merge-json" || rule.type === "typescript-exclude") {
       filesToStage.add(rule.to);
     } else if (rule.type === "remove-line" || rule.type === "add-line") {
       filesToStage.add(rule.to);
@@ -3333,7 +3479,7 @@ async function run3(options = {}) {
     if (shouldCommit) {
       console.log("[fullstack-cli] Step 3/3: Committing changes...");
       const version = getCliVersion();
-      const filesToStage = getUpgradeFilesToStage(options.disableGenOpenapi ?? true);
+      const filesToStage = getUpgradeFilesToStage(options.disableGenOpenapi ?? true, userProjectRoot);
       autoCommitUpgradeChanges(version, userProjectRoot, filesToStage);
     } else {
       console.log("[fullstack-cli] Step 3/3: Skipping commit (--no-commit flag)");
@@ -3348,8 +3494,8 @@ async function run3(options = {}) {
 
 // src/commands/upgrade/deps/run.handler.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import fs11 from "fs";
-import path9 from "path";
+import fs13 from "fs";
+import path10 from "path";
 
 // src/utils/grayscale/config.ts
 function getGrayscaleConfig(configJson) {
@@ -3597,8 +3743,8 @@ function installGrayscaleVersions(packages, grayscaleVersions, cwd, dryRun, mode
     if (version) {
       let current = "";
       try {
-        const installedPkgPath = path9.join(cwd, "node_modules", pkg2, "package.json");
-        const installedPkg = JSON.parse(fs11.readFileSync(installedPkgPath, "utf-8"));
+        const installedPkgPath = path10.join(cwd, "node_modules", pkg2, "package.json");
+        const installedPkg = JSON.parse(fs13.readFileSync(installedPkgPath, "utf-8"));
         current = installedPkg.version || "";
       } catch (err) {
         const code = err?.code;
@@ -3716,8 +3862,8 @@ var depsCommand = {
 
 // src/commands/upgrade/global-deps/run.handler.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import fs12 from "fs";
-import path10 from "path";
+import fs14 from "fs";
+import path11 from "path";
 var MANAGED_GLOBAL_CLIS = [
   "@lark-apaas/fullstack-cli",
   "@lark-apaas/miaoda-cli"
@@ -3728,15 +3874,15 @@ function readGlobalInstalledVersion(pkg2) {
   if (process.env.NPM_CONFIG_PREFIX) candidates.push(process.env.NPM_CONFIG_PREFIX);
   candidates.push("/usr");
   candidates.push("/usr/local");
-  if (process.env.HOME) candidates.push(path10.join(process.env.HOME, ".npm-global"));
+  if (process.env.HOME) candidates.push(path11.join(process.env.HOME, ".npm-global"));
   const seen = /* @__PURE__ */ new Set();
   for (const prefix of candidates) {
     if (seen.has(prefix)) continue;
     seen.add(prefix);
     try {
-      const pkgPath = path10.join(prefix, "lib", "node_modules", pkg2, "package.json");
-      if (fs12.existsSync(pkgPath)) {
-        const meta = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
+      const pkgPath = path11.join(prefix, "lib", "node_modules", pkg2, "package.json");
+      if (fs14.existsSync(pkgPath)) {
+        const meta = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
         if (meta && typeof meta.version === "string") return meta.version;
       }
     } catch (err) {
@@ -3833,8 +3979,8 @@ var upgradeCommand = {
 };
 
 // src/commands/action-plugin/utils.ts
-import fs13 from "fs";
-import path11 from "path";
+import fs15 from "fs";
+import path12 from "path";
 import { spawnSync as spawnSync6, execSync as execSync2 } from "child_process";
 function parsePluginName(input) {
   const match = input.match(/^(@[^/]+\/[^@]+)(?:@(.+))?$/);
@@ -3852,18 +3998,18 @@ function getProjectRoot() {
   return process.cwd();
 }
 function getPackageJsonPath() {
-  return path11.join(getProjectRoot(), "package.json");
+  return path12.join(getProjectRoot(), "package.json");
 }
 function getPluginPath(pluginName) {
-  return path11.join(getProjectRoot(), "node_modules", pluginName);
+  return path12.join(getProjectRoot(), "node_modules", pluginName);
 }
 function readPackageJson2() {
   const pkgPath = getPackageJsonPath();
-  if (!fs13.existsSync(pkgPath)) {
+  if (!fs15.existsSync(pkgPath)) {
     throw new Error("package.json not found in current directory");
   }
   try {
-    const content = fs13.readFileSync(pkgPath, "utf-8");
+    const content = fs15.readFileSync(pkgPath, "utf-8");
     return JSON.parse(content);
   } catch {
     throw new Error("Failed to parse package.json");
@@ -3871,7 +4017,7 @@ function readPackageJson2() {
 }
 function writePackageJson2(pkg2) {
   const pkgPath = getPackageJsonPath();
-  fs13.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  fs15.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
 }
 function readActionPlugins() {
   const pkg2 = readPackageJson2();
@@ -3904,12 +4050,12 @@ function npmInstall(tgzPath) {
   }
 }
 function getPackageVersion(pluginName) {
-  const pkgJsonPath = path11.join(getPluginPath(pluginName), "package.json");
-  if (!fs13.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path12.join(getPluginPath(pluginName), "package.json");
+  if (!fs15.existsSync(pkgJsonPath)) {
     return null;
   }
   try {
-    const content = fs13.readFileSync(pkgJsonPath, "utf-8");
+    const content = fs15.readFileSync(pkgJsonPath, "utf-8");
     const pkg2 = JSON.parse(content);
     return pkg2.version || null;
   } catch {
@@ -3917,49 +4063,49 @@ function getPackageVersion(pluginName) {
   }
 }
 function readPluginPackageJson(pluginPath) {
-  const pkgJsonPath = path11.join(pluginPath, "package.json");
-  if (!fs13.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path12.join(pluginPath, "package.json");
+  if (!fs15.existsSync(pkgJsonPath)) {
     return null;
   }
   try {
-    const content = fs13.readFileSync(pkgJsonPath, "utf-8");
+    const content = fs15.readFileSync(pkgJsonPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function extractTgzToNodeModules(tgzPath, pluginName) {
-  const nodeModulesPath = path11.join(getProjectRoot(), "node_modules");
-  const targetDir = path11.join(nodeModulesPath, pluginName);
-  const scopeDir = path11.dirname(targetDir);
-  if (!fs13.existsSync(scopeDir)) {
-    fs13.mkdirSync(scopeDir, { recursive: true });
+  const nodeModulesPath = path12.join(getProjectRoot(), "node_modules");
+  const targetDir = path12.join(nodeModulesPath, pluginName);
+  const scopeDir = path12.dirname(targetDir);
+  if (!fs15.existsSync(scopeDir)) {
+    fs15.mkdirSync(scopeDir, { recursive: true });
   }
-  if (fs13.existsSync(targetDir)) {
-    fs13.rmSync(targetDir, { recursive: true });
+  if (fs15.existsSync(targetDir)) {
+    fs15.rmSync(targetDir, { recursive: true });
   }
-  const tempDir = path11.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
-  if (fs13.existsSync(tempDir)) {
-    fs13.rmSync(tempDir, { recursive: true });
+  const tempDir = path12.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
+  if (fs15.existsSync(tempDir)) {
+    fs15.rmSync(tempDir, { recursive: true });
   }
-  fs13.mkdirSync(tempDir, { recursive: true });
+  fs15.mkdirSync(tempDir, { recursive: true });
   try {
     execSync2(`tar -xzf "${tgzPath}" -C "${tempDir}"`, { stdio: "pipe" });
-    const extractedDir = path11.join(tempDir, "package");
-    if (fs13.existsSync(extractedDir)) {
-      fs13.renameSync(extractedDir, targetDir);
+    const extractedDir = path12.join(tempDir, "package");
+    if (fs15.existsSync(extractedDir)) {
+      fs15.renameSync(extractedDir, targetDir);
     } else {
-      const files = fs13.readdirSync(tempDir);
+      const files = fs15.readdirSync(tempDir);
       if (files.length === 1) {
-        fs13.renameSync(path11.join(tempDir, files[0]), targetDir);
+        fs15.renameSync(path12.join(tempDir, files[0]), targetDir);
       } else {
         throw new Error("Unexpected tgz structure");
       }
     }
     return targetDir;
   } finally {
-    if (fs13.existsSync(tempDir)) {
-      fs13.rmSync(tempDir, { recursive: true });
+    if (fs15.existsSync(tempDir)) {
+      fs15.rmSync(tempDir, { recursive: true });
     }
   }
 }
@@ -3968,10 +4114,10 @@ function checkMissingPeerDeps(peerDeps) {
     return [];
   }
   const missing = [];
-  const nodeModulesPath = path11.join(getProjectRoot(), "node_modules");
+  const nodeModulesPath = path12.join(getProjectRoot(), "node_modules");
   for (const [depName, _version] of Object.entries(peerDeps)) {
-    const depPath = path11.join(nodeModulesPath, depName);
-    if (!fs13.existsSync(depPath)) {
+    const depPath = path12.join(nodeModulesPath, depName);
+    if (!fs15.existsSync(depPath)) {
       missing.push(depName);
     }
   }
@@ -3995,27 +4141,28 @@ function installMissingDeps(deps) {
 }
 function removePluginDirectory(pluginName) {
   const pluginPath = getPluginPath(pluginName);
-  if (fs13.existsSync(pluginPath)) {
-    fs13.rmSync(pluginPath, { recursive: true });
+  if (fs15.existsSync(pluginPath)) {
+    fs15.rmSync(pluginPath, { recursive: true });
     console.log(`[action-plugin] Removed ${pluginName}`);
   }
 }
 
 // src/commands/action-plugin/api-client.ts
 import { HttpClient as HttpClient2 } from "@lark-apaas/http-client";
-import fs14 from "fs";
-import path12 from "path";
+import fs16 from "fs";
+import path13 from "path";
 var PLUGIN_CACHE_DIR = "node_modules/.cache/fullstack-cli/plugins";
 async function getPluginVersions(keys, latestOnly = true) {
   const client = getHttpClient();
-  const response = await client.post(`/api/v1/studio/innerapi/plugins/-/versions/batch_get?keys=${keys.join(",")}&latest_only=${latestOnly}`);
-  if (!response.ok || response.status !== 200) {
-    throw new Error(`Failed to get plugin versions: ${response.status} ${response.statusText}`);
-  }
+  const response = await requestWithLogId(
+    () => client.post(`/api/v1/studio/innerapi/plugins/-/versions/batch_get?keys=${keys.join(",")}&latest_only=${latestOnly}`),
+    "Failed to get plugin versions",
+    { expectStatus200: true }
+  );
   const result = await response.json();
   console.log("getPluginVersions response:", result);
   if (result.status_code !== "0") {
-    throw new Error(`API error: ${result.message}`);
+    throw new Error(`API error: ${result.message}${formatLogId(response)}`);
   }
   return result.data.pluginVersions;
 }
@@ -4049,10 +4196,10 @@ async function downloadFromInner(pluginKey, version) {
   const { scope, name } = parsePluginKey(pluginKey);
   const url = `/api/v1/studio/innerapi/plugins/${scope}/${name}/versions/${version}/package`;
   console.log(`[action-plugin] Downloading plugin from inner API: ${url}`);
-  const response = await client.get(url);
-  if (!response.ok) {
-    throw new Error(`Failed to download plugin: ${response.status} ${response.statusText}`);
-  }
+  const response = await requestWithLogId(
+    () => client.get(url),
+    "Failed to download plugin"
+  );
   const arrayBuffer = await response.arrayBuffer();
   return Buffer.from(arrayBuffer);
 }
@@ -4060,27 +4207,27 @@ async function downloadFromPublic(downloadURL) {
   const client = new HttpClient2({
     timeout: 6e4
   });
-  const response = await client.get(downloadURL);
-  if (!response.ok) {
-    throw new Error(`Failed to download plugin from public URL: ${response.status} ${response.statusText}`);
-  }
+  const response = await requestWithLogId(
+    () => client.get(downloadURL),
+    "Failed to download plugin from public URL"
+  );
   const arrayBuffer = await response.arrayBuffer();
   return Buffer.from(arrayBuffer);
 }
 function getPluginCacheDir() {
-  return path12.join(process.cwd(), PLUGIN_CACHE_DIR);
+  return path13.join(process.cwd(), PLUGIN_CACHE_DIR);
 }
 function ensureCacheDir() {
   const cacheDir = getPluginCacheDir();
-  if (!fs14.existsSync(cacheDir)) {
-    fs14.mkdirSync(cacheDir, { recursive: true });
+  if (!fs16.existsSync(cacheDir)) {
+    fs16.mkdirSync(cacheDir, { recursive: true });
   }
 }
 function getTempFilePath(pluginKey, version) {
   ensureCacheDir();
   const safeKey = pluginKey.replace(/[/@]/g, "_");
   const filename = `${safeKey}@${version}.tgz`;
-  return path12.join(getPluginCacheDir(), filename);
+  return path13.join(getPluginCacheDir(), filename);
 }
 var MAX_RETRIES = 2;
 async function withRetry(operation, description, maxRetries = MAX_RETRIES) {
@@ -4117,7 +4264,7 @@ async function downloadPlugin(pluginKey, requestedVersion) {
     );
   }
   const tgzPath = getTempFilePath(pluginKey, pluginInfo.version);
-  fs14.writeFileSync(tgzPath, tgzBuffer);
+  fs16.writeFileSync(tgzPath, tgzBuffer);
   console.log(`[action-plugin] Downloaded to ${tgzPath} (${(tgzBuffer.length / 1024).toFixed(2)} KB)`);
   return {
     tgzPath,
@@ -4131,18 +4278,18 @@ function getCachePath(pluginKey, version) {
   ensureCacheDir();
   const safeKey = pluginKey.replace(/[/@]/g, "_");
   const filename = `${safeKey}@${version}.tgz`;
-  return path12.join(getPluginCacheDir(), filename);
+  return path13.join(getPluginCacheDir(), filename);
 }
 function hasCachedPlugin(pluginKey, version) {
   const cachePath = getCachePath(pluginKey, version);
-  return fs14.existsSync(cachePath);
+  return fs16.existsSync(cachePath);
 }
 function listCachedPlugins() {
   const cacheDir = getPluginCacheDir();
-  if (!fs14.existsSync(cacheDir)) {
+  if (!fs16.existsSync(cacheDir)) {
     return [];
   }
-  const files = fs14.readdirSync(cacheDir);
+  const files = fs16.readdirSync(cacheDir);
   const result = [];
   for (const file of files) {
     if (!file.endsWith(".tgz")) continue;
@@ -4150,8 +4297,8 @@ function listCachedPlugins() {
     if (!match) continue;
     const [, rawName, version] = match;
     const name = rawName.replace(/^_/, "@").replace(/_/, "/");
-    const filePath = path12.join(cacheDir, file);
-    const stat = fs14.statSync(filePath);
+    const filePath = path13.join(cacheDir, file);
+    const stat = fs16.statSync(filePath);
     result.push({
       name,
       version,
@@ -4164,14 +4311,14 @@ function listCachedPlugins() {
 }
 function cleanAllCache() {
   const cacheDir = getPluginCacheDir();
-  if (!fs14.existsSync(cacheDir)) {
+  if (!fs16.existsSync(cacheDir)) {
     return 0;
   }
-  const files = fs14.readdirSync(cacheDir);
+  const files = fs16.readdirSync(cacheDir);
   let count = 0;
   for (const file of files) {
     if (file.endsWith(".tgz")) {
-      fs14.unlinkSync(path12.join(cacheDir, file));
+      fs16.unlinkSync(path13.join(cacheDir, file));
       count++;
     }
   }
@@ -4179,21 +4326,21 @@ function cleanAllCache() {
 }
 function cleanPluginCache(pluginKey, version) {
   const cacheDir = getPluginCacheDir();
-  if (!fs14.existsSync(cacheDir)) {
+  if (!fs16.existsSync(cacheDir)) {
     return 0;
   }
   const safeKey = pluginKey.replace(/[/@]/g, "_");
-  const files = fs14.readdirSync(cacheDir);
+  const files = fs16.readdirSync(cacheDir);
   let count = 0;
   for (const file of files) {
     if (version) {
       if (file === `${safeKey}@${version}.tgz`) {
-        fs14.unlinkSync(path12.join(cacheDir, file));
+        fs16.unlinkSync(path13.join(cacheDir, file));
         count++;
       }
     } else {
       if (file.startsWith(`${safeKey}@`) && file.endsWith(".tgz")) {
-        fs14.unlinkSync(path12.join(cacheDir, file));
+        fs16.unlinkSync(path13.join(cacheDir, file));
         count++;
       }
     }
@@ -4620,45 +4767,45 @@ var actionPluginCommandGroup = {
 };
 
 // src/commands/capability/utils.ts
-import fs15 from "fs";
+import fs17 from "fs";
 import { createRequire as createRequire2 } from "module";
-import path13 from "path";
+import path14 from "path";
 var CAPABILITIES_DIR = "server/capabilities";
 var SHARED_CAPABILITIES_DIR = "shared/capabilities";
 function getProjectRoot2() {
   return process.cwd();
 }
 function getCapabilitiesDir() {
-  const sharedDir = path13.join(getProjectRoot2(), SHARED_CAPABILITIES_DIR);
-  if (fs15.existsSync(sharedDir)) {
+  const sharedDir = path14.join(getProjectRoot2(), SHARED_CAPABILITIES_DIR);
+  if (fs17.existsSync(sharedDir)) {
     return sharedDir;
   }
-  return path13.join(getProjectRoot2(), CAPABILITIES_DIR);
+  return path14.join(getProjectRoot2(), CAPABILITIES_DIR);
 }
 function getCapabilityPath(id) {
-  return path13.join(getCapabilitiesDir(), `${id}.json`);
+  return path14.join(getCapabilitiesDir(), `${id}.json`);
 }
 function getPluginManifestPath(pluginKey) {
-  return path13.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
+  return path14.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
 }
 function capabilitiesDirExists() {
-  return fs15.existsSync(getCapabilitiesDir());
+  return fs17.existsSync(getCapabilitiesDir());
 }
 function listCapabilityIds() {
   const dir = getCapabilitiesDir();
-  if (!fs15.existsSync(dir)) {
+  if (!fs17.existsSync(dir)) {
     return [];
   }
-  const files = fs15.readdirSync(dir);
+  const files = fs17.readdirSync(dir);
   return files.filter((f) => f.endsWith(".json") && f !== "capabilities.json").map((f) => f.replace(/\.json$/, ""));
 }
 function readCapability(id) {
   const filePath = getCapabilityPath(id);
-  if (!fs15.existsSync(filePath)) {
+  if (!fs17.existsSync(filePath)) {
     throw new Error(`Capability not found: ${id}`);
   }
   try {
-    const content = fs15.readFileSync(filePath, "utf-8");
+    const content = fs17.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -4685,11 +4832,11 @@ function readAllCapabilities() {
 }
 function readPluginManifest(pluginKey) {
   const manifestPath = getPluginManifestPath(pluginKey);
-  if (!fs15.existsSync(manifestPath)) {
+  if (!fs17.existsSync(manifestPath)) {
     throw new Error(`Plugin not installed: ${pluginKey} (manifest.json not found)`);
   }
   try {
-    const content = fs15.readFileSync(manifestPath, "utf-8");
+    const content = fs17.readFileSync(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -4706,7 +4853,7 @@ function hasValidParamsSchema(paramsSchema) {
 }
 async function loadPlugin(pluginKey) {
   try {
-    const userRequire = createRequire2(path13.join(getProjectRoot2(), "package.json"));
+    const userRequire = createRequire2(path14.join(getProjectRoot2(), "package.json"));
     const resolvedPath = userRequire.resolve(pluginKey);
     const pluginModule = await import(resolvedPath);
     const pluginPackage = pluginModule.default ?? pluginModule;
@@ -4869,8 +5016,8 @@ var capabilityCommandGroup = {
 import { execFile } from "child_process";
 
 // src/commands/component/registry-preparer.ts
-import fs16 from "fs";
-import path14 from "path";
+import fs18 from "fs";
+import path15 from "path";
 import os from "os";
 
 // src/commands/component/service.ts
@@ -4884,49 +5031,53 @@ var debug = createDebug("component");
 async function getComponents(keys) {
   const client = getHttpClient();
   debug("\u8C03\u7528 /components/batch_get %o", keys);
-  const response = await client.post(
-    `/api/v1/studio/innerapi/components/batch_get?keys=${keys.join(",")}`
+  const response = await requestWithLogId(
+    () => client.post(
+      `/api/v1/studio/innerapi/components/batch_get?keys=${keys.join(",")}`
+    ),
+    "\u83B7\u53D6\u7EC4\u4EF6\u4FE1\u606F\u5931\u8D25",
+    { expectStatus200: true }
   );
-  if (response.status !== 200) {
-    throw new Error(
-      `\u83B7\u53D6\u7EC4\u4EF6\u4FE1\u606F\u5931\u8D25\uFF1A${response.status} ${response.statusText}`
-    );
-  }
   const result = await response.json();
   if (result.status_code !== "0") {
     debug("\u63A5\u53E3\u8FD4\u56DE\u9519\u8BEF\uFF1A%o", result);
-    throw new Error(`\u83B7\u53D6\u7EC4\u4EF6\u4FE1\u606F\u5931\u8D25\uFF1A${result.error_msg}`);
+    throw new Error(`\u83B7\u53D6\u7EC4\u4EF6\u4FE1\u606F\u5931\u8D25\uFF1A${result.error_msg}${formatLogId(response)}`);
   }
   return mapValues(result.data.components, ([component]) => component);
 }
 async function getRegistryItem(url) {
   const client = getHttpClient();
   debug("\u4E0B\u8F7D registry-item.json\uFF1A%s", url);
-  const response = await client.get(url);
-  if (!response.ok) {
-    throw new Error(
-      `\u4E0B\u8F7D registry-item.json \u5931\u8D25\uFF1A${response.status} ${response.statusText}`
-    );
-  }
+  const response = await requestWithLogId(
+    () => client.get(url),
+    "\u4E0B\u8F7D registry-item.json \u5931\u8D25"
+  );
   const item = await response.json();
   return item;
 }
 async function sendInstallEvent(key) {
   const client = getHttpClient();
-  await client.post("/api/v1/studio/innerapi/resource_events", {
-    events: [
-      {
-        resourceType: "component",
-        resourceKey: key,
-        eventType: "install",
-        details: {}
-      }
-    ]
-  });
+  try {
+    await requestWithLogId(
+      () => client.post("/api/v1/studio/innerapi/resource_events", {
+        events: [
+          {
+            resourceType: "component",
+            resourceKey: key,
+            eventType: "install",
+            details: {}
+          }
+        ]
+      }),
+      "\u4E0A\u62A5\u7EC4\u4EF6\u5B89\u88C5\u4E8B\u4EF6\u5931\u8D25"
+    );
+  } catch (error) {
+    console.warn(`[component] ${error instanceof Error ? error.message : error}`);
+  }
 }
 
 // src/commands/component/registry-preparer.ts
-var REGISTRY_TEMP_DIR = path14.join(os.tmpdir(), "miaoda-registry");
+var REGISTRY_TEMP_DIR = path15.join(os.tmpdir(), "miaoda-registry");
 function parseComponentKey(key) {
   const match = key.match(/^@([^/]+)\/(.+)$/);
   if (!match) {
@@ -4938,11 +5089,11 @@ function parseComponentKey(key) {
 }
 function getLocalRegistryPath(key) {
   const { scope, name } = parseComponentKey(key);
-  return path14.join(REGISTRY_TEMP_DIR, scope, `${name}.json`);
+  return path15.join(REGISTRY_TEMP_DIR, scope, `${name}.json`);
 }
 function ensureDir(dirPath) {
-  if (!fs16.existsSync(dirPath)) {
-    fs16.mkdirSync(dirPath, { recursive: true });
+  if (!fs18.existsSync(dirPath)) {
+    fs18.mkdirSync(dirPath, { recursive: true });
   }
 }
 async function prepareRecursive(key, visited) {
@@ -4975,8 +5126,8 @@ async function prepareRecursive(key, visited) {
     registryDependencies: deps.map((dep) => getLocalRegistryPath(dep))
   };
   const localPath = getLocalRegistryPath(key);
-  ensureDir(path14.dirname(localPath));
-  fs16.writeFileSync(localPath, JSON.stringify(rewrittenItem, null, 2), "utf-8");
+  ensureDir(path15.dirname(localPath));
+  fs18.writeFileSync(localPath, JSON.stringify(rewrittenItem, null, 2), "utf-8");
   debug("\u4FDD\u5B58\u5230: %s", localPath);
 }
 async function prepareComponentRegistryItems(id) {
@@ -4986,18 +5137,18 @@ async function prepareComponentRegistryItems(id) {
 }
 function cleanupTempDir() {
   try {
-    if (fs16.existsSync(REGISTRY_TEMP_DIR)) {
-      fs16.rmSync(REGISTRY_TEMP_DIR, { recursive: true, force: true });
+    if (fs18.existsSync(REGISTRY_TEMP_DIR)) {
+      fs18.rmSync(REGISTRY_TEMP_DIR, { recursive: true, force: true });
     }
   } catch {
   }
 }
 function getDownloadedRegistryItem(itemId) {
   const localPath = getLocalRegistryPath(itemId);
-  if (!fs16.existsSync(localPath)) {
+  if (!fs18.existsSync(localPath)) {
     return null;
   }
-  const content = fs16.readFileSync(localPath, "utf-8");
+  const content = fs18.readFileSync(localPath, "utf-8");
   return JSON.parse(content);
 }
 
@@ -5165,58 +5316,58 @@ var componentCommandGroup = {
 };
 
 // src/commands/migration/version-manager.ts
-import fs17 from "fs";
-import path15 from "path";
+import fs19 from "fs";
+import path16 from "path";
 var PACKAGE_JSON = "package.json";
 var VERSION_FIELD = "migrationVersion";
 function getPackageJsonPath2() {
-  return path15.join(process.cwd(), PACKAGE_JSON);
+  return path16.join(process.cwd(), PACKAGE_JSON);
 }
 function getCurrentVersion() {
   const pkgPath = getPackageJsonPath2();
-  if (!fs17.existsSync(pkgPath)) {
+  if (!fs19.existsSync(pkgPath)) {
     throw new Error("package.json not found");
   }
-  const pkg2 = JSON.parse(fs17.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs19.readFileSync(pkgPath, "utf-8"));
   return pkg2[VERSION_FIELD] ?? 0;
 }
 function setCurrentVersion(version) {
   const pkgPath = getPackageJsonPath2();
-  const pkg2 = JSON.parse(fs17.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs19.readFileSync(pkgPath, "utf-8"));
   pkg2[VERSION_FIELD] = version;
-  fs17.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  fs19.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/detector.ts
-import fs19 from "fs";
-import path17 from "path";
+import fs21 from "fs";
+import path18 from "path";
 
 // src/commands/migration/versions/v001_capability/utils.ts
-import fs18 from "fs";
-import path16 from "path";
+import fs20 from "fs";
+import path17 from "path";
 var CAPABILITIES_DIR2 = "server/capabilities";
 function getProjectRoot3() {
   return process.cwd();
 }
 function getCapabilitiesDir2() {
-  return path16.join(getProjectRoot3(), CAPABILITIES_DIR2);
+  return path17.join(getProjectRoot3(), CAPABILITIES_DIR2);
 }
 function getPluginManifestPath2(pluginKey) {
-  return path16.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
+  return path17.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/detector.ts
 function detectJsonMigration() {
   const capabilitiesDir = getCapabilitiesDir2();
-  const oldFilePath = path17.join(capabilitiesDir, "capabilities.json");
-  if (!fs19.existsSync(oldFilePath)) {
+  const oldFilePath = path18.join(capabilitiesDir, "capabilities.json");
+  if (!fs21.existsSync(oldFilePath)) {
     return {
       needsMigration: false,
       reason: "capabilities.json not found"
     };
   }
   try {
-    const content = fs19.readFileSync(oldFilePath, "utf-8");
+    const content = fs21.readFileSync(oldFilePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!Array.isArray(parsed)) {
       return {
@@ -5267,8 +5418,8 @@ async function check(options) {
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
-import fs20 from "fs";
-import path18 from "path";
+import fs22 from "fs";
+import path19 from "path";
 
 // src/commands/migration/versions/v001_capability/mapping.ts
 var DEFAULT_PLUGIN_VERSION = "1.0.0";
@@ -5498,18 +5649,18 @@ function transformCapabilities(oldCapabilities) {
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
 function loadExistingCapabilities() {
   const capabilitiesDir = getCapabilitiesDir2();
-  if (!fs20.existsSync(capabilitiesDir)) {
+  if (!fs22.existsSync(capabilitiesDir)) {
     return [];
   }
-  const files = fs20.readdirSync(capabilitiesDir);
+  const files = fs22.readdirSync(capabilitiesDir);
   const capabilities = [];
   for (const file of files) {
     if (file === "capabilities.json" || !file.endsWith(".json")) {
       continue;
     }
     try {
-      const filePath = path18.join(capabilitiesDir, file);
-      const content = fs20.readFileSync(filePath, "utf-8");
+      const filePath = path19.join(capabilitiesDir, file);
+      const content = fs22.readFileSync(filePath, "utf-8");
       const capability = JSON.parse(content);
       if (capability.id && capability.pluginKey) {
         capabilities.push(capability);
@@ -5567,9 +5718,9 @@ async function migrateJsonFiles(options) {
   }
   const capabilitiesDir = getCapabilitiesDir2();
   for (const cap of newCapabilities) {
-    const filePath = path18.join(capabilitiesDir, `${cap.id}.json`);
+    const filePath = path19.join(capabilitiesDir, `${cap.id}.json`);
     const content = JSON.stringify(cap, null, 2);
-    fs20.writeFileSync(filePath, content, "utf-8");
+    fs22.writeFileSync(filePath, content, "utf-8");
     console.log(`   \u2713 Created: ${cap.id}.json`);
   }
   return {
@@ -5581,11 +5732,11 @@ async function migrateJsonFiles(options) {
 }
 
 // src/commands/migration/versions/v001_capability/plugin-installer/detector.ts
-import fs21 from "fs";
+import fs23 from "fs";
 function isPluginInstalled2(pluginKey) {
   const actionPlugins = readActionPlugins();
   const manifestPath = getPluginManifestPath2(pluginKey);
-  return fs21.existsSync(manifestPath) && !!actionPlugins[pluginKey];
+  return fs23.existsSync(manifestPath) && !!actionPlugins[pluginKey];
 }
 function detectPluginsToInstall(capabilities) {
   const pluginKeys = /* @__PURE__ */ new Set();
@@ -5661,12 +5812,12 @@ async function installPlugins(capabilities, options) {
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/index.ts
-import path20 from "path";
+import path21 from "path";
 import { Project as Project3 } from "ts-morph";
 
 // src/commands/migration/versions/v001_capability/code-migrator/scanner.ts
-import fs22 from "fs";
-import path19 from "path";
+import fs24 from "fs";
+import path20 from "path";
 var EXCLUDED_DIRS = [
   "node_modules",
   "dist",
@@ -5681,9 +5832,9 @@ var EXCLUDED_PATTERNS = [
   /\.d\.ts$/
 ];
 function scanDirectory(dir, files = []) {
-  const entries = fs22.readdirSync(dir, { withFileTypes: true });
+  const entries = fs24.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path19.join(dir, entry.name);
+    const fullPath = path20.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (EXCLUDED_DIRS.includes(entry.name)) {
         continue;
@@ -5699,14 +5850,14 @@ function scanDirectory(dir, files = []) {
   return files;
 }
 function scanServerFiles() {
-  const serverDir = path19.join(getProjectRoot3(), "server");
-  if (!fs22.existsSync(serverDir)) {
+  const serverDir = path20.join(getProjectRoot3(), "server");
+  if (!fs24.existsSync(serverDir)) {
     return [];
   }
   return scanDirectory(serverDir);
 }
 function hasCapabilityImport(filePath) {
-  const content = fs22.readFileSync(filePath, "utf-8");
+  const content = fs24.readFileSync(filePath, "utf-8");
   return /import\s+.*from\s+['"][^'"]*capabilities[^'"]*['"]/.test(content);
 }
 function scanFilesToMigrate() {
@@ -6083,7 +6234,7 @@ function analyzeFile(project, filePath, actionNameMap) {
   const callSites = analyzeCallSites(sourceFile, imports);
   const classInfo = analyzeClass(sourceFile);
   const { canMigrate, reason } = canAutoMigrate(classInfo);
-  const relativePath = path20.relative(getProjectRoot3(), filePath);
+  const relativePath = path21.relative(getProjectRoot3(), filePath);
   return {
     filePath: relativePath,
     imports,
@@ -6094,7 +6245,7 @@ function analyzeFile(project, filePath, actionNameMap) {
   };
 }
 function migrateFile(project, analysis, dryRun) {
-  const absolutePath = path20.join(getProjectRoot3(), analysis.filePath);
+  const absolutePath = path21.join(getProjectRoot3(), analysis.filePath);
   if (!analysis.canAutoMigrate) {
     return {
       filePath: analysis.filePath,
@@ -6197,17 +6348,17 @@ function getSuggestion(analysis) {
 }
 
 // src/commands/migration/versions/v001_capability/cleanup.ts
-import fs23 from "fs";
-import path21 from "path";
+import fs25 from "fs";
+import path22 from "path";
 function cleanupOldFiles(capabilities, dryRun) {
   const deletedFiles = [];
   const errors = [];
   const capabilitiesDir = getCapabilitiesDir2();
-  const oldJsonPath = path21.join(capabilitiesDir, "capabilities.json");
-  if (fs23.existsSync(oldJsonPath)) {
+  const oldJsonPath = path22.join(capabilitiesDir, "capabilities.json");
+  if (fs25.existsSync(oldJsonPath)) {
     try {
       if (!dryRun) {
-        fs23.unlinkSync(oldJsonPath);
+        fs25.unlinkSync(oldJsonPath);
       }
       deletedFiles.push("capabilities.json");
     } catch (error) {
@@ -6215,11 +6366,11 @@ function cleanupOldFiles(capabilities, dryRun) {
     }
   }
   for (const cap of capabilities) {
-    const tsFilePath = path21.join(capabilitiesDir, `${cap.id}.ts`);
-    if (fs23.existsSync(tsFilePath)) {
+    const tsFilePath = path22.join(capabilitiesDir, `${cap.id}.ts`);
+    if (fs25.existsSync(tsFilePath)) {
       try {
         if (!dryRun) {
-          fs23.unlinkSync(tsFilePath);
+          fs25.unlinkSync(tsFilePath);
         }
         deletedFiles.push(`${cap.id}.ts`);
       } catch (error) {
@@ -6235,8 +6386,8 @@ function cleanupOldFiles(capabilities, dryRun) {
 }
 
 // src/commands/migration/versions/v001_capability/report-generator.ts
-import fs24 from "fs";
-import path22 from "path";
+import fs26 from "fs";
+import path23 from "path";
 var REPORT_FILE = "capability-migration-report.md";
 function printSummary(result) {
   const { jsonMigration, pluginInstallation, codeMigration, cleanup } = result;
@@ -6399,15 +6550,15 @@ async function generateReport(result) {
   }
   lines.push("");
   const logDir = process.env.LOG_DIR || "logs";
-  if (!fs24.existsSync(logDir)) {
+  if (!fs26.existsSync(logDir)) {
     return;
   }
-  const reportDir = path22.join(logDir, "migration");
-  if (!fs24.existsSync(reportDir)) {
-    fs24.mkdirSync(reportDir, { recursive: true });
+  const reportDir = path23.join(logDir, "migration");
+  if (!fs26.existsSync(reportDir)) {
+    fs26.mkdirSync(reportDir, { recursive: true });
   }
-  const reportPath = path22.join(reportDir, REPORT_FILE);
-  fs24.writeFileSync(reportPath, lines.join("\n"), "utf-8");
+  const reportPath = path23.join(reportDir, REPORT_FILE);
+  fs26.writeFileSync(reportPath, lines.join("\n"), "utf-8");
   console.log(`\u{1F4C4} Report generated: ${reportPath}`);
 }
 
@@ -6939,10 +7090,10 @@ var migrationCommand = {
 };
 
 // src/commands/read-logs/index.ts
-import path23 from "path";
+import path24 from "path";
 
 // src/commands/read-logs/std-utils.ts
-import fs25 from "fs";
+import fs27 from "fs";
 function formatStdPrefixTime(localTime) {
   const match = localTime.match(/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/);
   if (!match) return localTime;
@@ -6972,11 +7123,11 @@ function stripPrefixFromStdLine(line) {
   return `[${time}] ${content}`;
 }
 function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarker) {
-  const stat = fs25.statSync(filePath);
+  const stat = fs27.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], markerFound: false, totalLinesCount: 0 };
   }
-  const fd = fs25.openSync(filePath, "r");
+  const fd = fs27.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -6990,7 +7141,7 @@ function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarke
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs25.readSync(fd, buffer, 0, length, position);
+      fs27.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -7032,7 +7183,7 @@ function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarke
       }
     }
   } finally {
-    fs25.closeSync(fd);
+    fs27.closeSync(fd);
   }
   return { lines: collected.reverse(), markerFound, totalLinesCount };
 }
@@ -7053,21 +7204,21 @@ function readServerStdSegment(filePath, maxLines, offset) {
 }
 
 // src/commands/read-logs/tail.ts
-import fs26 from "fs";
+import fs28 from "fs";
 function fileExists(filePath) {
   try {
-    fs26.accessSync(filePath, fs26.constants.F_OK | fs26.constants.R_OK);
+    fs28.accessSync(filePath, fs28.constants.F_OK | fs28.constants.R_OK);
     return true;
   } catch {
     return false;
   }
 }
 function readFileTailLines(filePath, maxLines) {
-  const stat = fs26.statSync(filePath);
+  const stat = fs28.statSync(filePath);
   if (stat.size === 0) {
     return [];
   }
-  const fd = fs26.openSync(filePath, "r");
+  const fd = fs28.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   const chunks = [];
   let position = stat.size;
@@ -7077,13 +7228,13 @@ function readFileTailLines(filePath, maxLines) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs26.readSync(fd, buffer, 0, length, position);
+      fs28.readSync(fd, buffer, 0, length, position);
       chunks.unshift(buffer.toString("utf8"));
       const chunkLines = buffer.toString("utf8").split("\n").length - 1;
       collectedLines += chunkLines;
     }
   } finally {
-    fs26.closeSync(fd);
+    fs28.closeSync(fd);
   }
   const content = chunks.join("");
   const allLines = content.split("\n");
@@ -7099,11 +7250,11 @@ function readFileTailLines(filePath, maxLines) {
   return allLines.slice(allLines.length - maxLines);
 }
 function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
-  const stat = fs26.statSync(filePath);
+  const stat = fs28.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs26.openSync(filePath, "r");
+  const fd = fs28.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -7115,7 +7266,7 @@ function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs26.readSync(fd, buffer, 0, length, position);
+      fs28.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -7146,7 +7297,7 @@ function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
       }
     }
   } finally {
-    fs26.closeSync(fd);
+    fs28.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -7288,7 +7439,7 @@ function readDevStdSegment(filePath, maxLines, offset) {
 }
 
 // src/commands/read-logs/json-lines.ts
-import fs27 from "fs";
+import fs29 from "fs";
 
 // src/commands/read-logs/structured-log.ts
 function normalizeLevelName(value) {
@@ -7364,11 +7515,11 @@ function buildWantedLevelSet(levels) {
   return set.size > 0 ? set : null;
 }
 function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
-  const stat = fs27.statSync(filePath);
+  const stat = fs29.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs27.openSync(filePath, "r");
+  const fd = fs29.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -7383,7 +7534,7 @@ function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs27.readSync(fd, buffer, 0, length, position);
+      fs29.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -7445,7 +7596,7 @@ function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs27.closeSync(fd);
+    fs29.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -7488,11 +7639,11 @@ function extractTraceId(obj) {
 function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
   const wanted = traceId.trim();
   if (!wanted) return { lines: [], totalLinesCount: 0 };
-  const stat = fs27.statSync(filePath);
+  const stat = fs29.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs27.openSync(filePath, "r");
+  const fd = fs29.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -7505,7 +7656,7 @@ function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs27.readSync(fd, buffer, 0, length, position);
+      fs29.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -7558,7 +7709,7 @@ function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs27.closeSync(fd);
+    fs29.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -7567,11 +7718,11 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
   if (!wantedLevelSet) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const stat = fs27.statSync(filePath);
+  const stat = fs29.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs27.openSync(filePath, "r");
+  const fd = fs29.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -7583,7 +7734,7 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs27.readSync(fd, buffer, 0, length, position);
+      fs29.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -7630,7 +7781,7 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs27.closeSync(fd);
+    fs29.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -8005,30 +8156,30 @@ async function readLogsJsonResult(options) {
   };
 }
 function resolveLogFilePath(logDir, type) {
-  const base = path23.isAbsolute(logDir) ? logDir : path23.join(process.cwd(), logDir);
+  const base = path24.isAbsolute(logDir) ? logDir : path24.join(process.cwd(), logDir);
   if (type === "server") {
-    return path23.join(base, "server.log");
+    return path24.join(base, "server.log");
   }
   if (type === "trace") {
-    return path23.join(base, "trace.log");
+    return path24.join(base, "trace.log");
   }
   if (type === "server-std") {
-    return path23.join(base, "server.std.log");
+    return path24.join(base, "server.std.log");
   }
   if (type === "client-std") {
-    return path23.join(base, "client.std.log");
+    return path24.join(base, "client.std.log");
   }
   if (type === "dev") {
-    return path23.join(base, "dev.log");
+    return path24.join(base, "dev.log");
   }
   if (type === "dev-std") {
-    return path23.join(base, "dev.std.log");
+    return path24.join(base, "dev.std.log");
   }
   if (type === "install-dep-std") {
-    return path23.join(base, "install-dep.std.log");
+    return path24.join(base, "install-dep.std.log");
   }
   if (type === "browser") {
-    return path23.join(base, "browser.log");
+    return path24.join(base, "browser.log");
   }
   throw new Error(`Unsupported log type: ${type}`);
 }
@@ -8114,70 +8265,54 @@ var UPLOAD_STATIC_DEFAULTS = {
 };
 
 // src/commands/build/api-client.ts
-var ERROR_RESPONSE_PREVIEW_LIMIT = 2e3;
-async function getErrorResponseDetails(response) {
-  try {
-    if (typeof response.text === "function") {
-      const text = await response.text();
-      if (!text) {
-        return "";
-      }
-      return `, response: ${text.slice(0, ERROR_RESPONSE_PREVIEW_LIMIT)}`;
-    }
-    if (typeof response.json === "function") {
-      const data = await response.json();
-      const serialized = JSON.stringify(data);
-      if (!serialized) {
-        return "";
-      }
-      return `, response: ${serialized.slice(0, ERROR_RESPONSE_PREVIEW_LIMIT)}`;
-    }
-  } catch {
-    return "";
-  }
-  return "";
-}
-async function throwIfResponseNotOk(response, message) {
-  if (response.ok && response.status === 200) {
-    return;
-  }
-  const details = await getErrorResponseDetails(response);
-  throw new Error(`${message}: ${response.status} ${response.statusText}${details}`);
-}
 async function genArtifactUploadCredential(appId, body) {
   const client = getHttpClient();
   const url = `/v1/app/${appId}/pipeline/gen_artifact_upload_credential`;
-  const response = await client.post(url, body);
-  await throwIfResponseNotOk(response, "gen_artifact_upload_credential \u8BF7\u6C42\u5931\u8D25");
+  const response = await requestWithLogId(
+    () => client.post(url, body),
+    "gen_artifact_upload_credential \u8BF7\u6C42\u5931\u8D25",
+    { expectStatus200: true }
+  );
   return response.json();
 }
 async function getDefaultBucketId(appId) {
   const client = getHttpClient();
   const url = `/v1/app/${appId}/storage/inner/staticBucket`;
-  const response = await client.post(url, {});
-  await throwIfResponseNotOk(response, "getOrCreateStaticBucket \u8BF7\u6C42\u5931\u8D25");
+  const response = await requestWithLogId(
+    () => client.post(url, {}),
+    "getOrCreateStaticBucket \u8BF7\u6C42\u5931\u8D25",
+    { expectStatus200: true }
+  );
   const data = await response.json();
   if (data.status_code !== "0") {
-    throw new Error(`getOrCreateStaticBucket \u8FD4\u56DE\u5F02\u5E38, status_code: ${data.status_code}`);
+    throw new Error(
+      `getOrCreateStaticBucket \u8FD4\u56DE\u5F02\u5E38, status_code: ${data.status_code}${formatLogId(response)}`
+    );
   }
   const bucketId = data?.data?.bucketID;
   if (!bucketId) {
-    throw new Error(`\u672A\u627E\u5230\u5E94\u7528 ${appId} \u7684\u9759\u6001\u8D44\u6E90\u5B58\u50A8\u6876`);
+    throw new Error(`\u672A\u627E\u5230\u5E94\u7528 ${appId} \u7684\u9759\u6001\u8D44\u6E90\u5B58\u50A8\u6876${formatLogId(response)}`);
   }
   return bucketId;
 }
 async function preUploadStaticAttachment(appId, bucketId) {
   const client = getHttpClient();
   const url = `/v1/app/${appId}/storage/bucket/${bucketId}/preUploadStatic`;
-  const response = await client.post(url, {});
-  await throwIfResponseNotOk(response, "preUploadStatic \u8BF7\u6C42\u5931\u8D25");
+  const response = await requestWithLogId(
+    () => client.post(url, {}),
+    "preUploadStatic \u8BF7\u6C42\u5931\u8D25",
+    { expectStatus200: true }
+  );
   return response.json();
 }
 async function uploadStaticAttachmentCallback(appId, bucketId, body) {
   const client = getHttpClient();
   const url = `/v1/app/${appId}/storage/bucket/${bucketId}/object/callbackStatic`;
-  const response = await client.post(url, body);
-  await throwIfResponseNotOk(response, "callbackStatic \u8BF7\u6C42\u5931\u8D25");
+  const response = await requestWithLogId(
+    () => client.post(url, body),
+    "callbackStatic \u8BF7\u6C42\u5931\u8D25",
+    { expectStatus200: true }
+  );
   return response.json();
 }
 
@@ -8214,9 +8349,9 @@ function camelToKebab(str) {
 }
 
 // src/commands/build/upload-static.handler.ts
-import * as fs28 from "fs";
+import * as fs30 from "fs";
 import * as os2 from "os";
-import * as path24 from "path";
+import * as path25 from "path";
 import { execFileSync } from "child_process";
 function readCredentialsFromEnv() {
   const uploadPrefix = process.env.STATIC_UPLOAD_PREFIX;
@@ -8240,8 +8375,8 @@ async function uploadStatic(options) {
       endpoint = UPLOAD_STATIC_DEFAULTS.endpoint,
       region = UPLOAD_STATIC_DEFAULTS.region
     } = options;
-    const resolvedStaticDir = path24.resolve(staticDir);
-    if (!fs28.existsSync(resolvedStaticDir)) {
+    const resolvedStaticDir = path25.resolve(staticDir);
+    if (!fs30.existsSync(resolvedStaticDir)) {
       console.error(`${LOG_PREFIX} \u76EE\u5F55\u4E0D\u5B58\u5728: ${resolvedStaticDir}\uFF0C\u8DF3\u8FC7\u4E0A\u4F20`);
       return;
     }
@@ -8274,8 +8409,8 @@ async function uploadStatic(options) {
       ({ AccessKeyID: accessKeyID, SecretAccessKey: secretAccessKey, SessionToken: sessionToken } = uploadCredential);
     }
     console.error(`${LOG_PREFIX} \u4E0A\u4F20\u76EE\u6807: ${uploadPrefix}`);
-    const confPath = path24.join(os2.tmpdir(), `.tosutilconfig-static-${process.pid}`);
-    fs28.writeFileSync(confPath, "");
+    const confPath = path25.join(os2.tmpdir(), `.tosutilconfig-static-${process.pid}`);
+    fs30.writeFileSync(confPath, "");
     try {
       console.error(`${LOG_PREFIX} \u914D\u7F6E tosutil...`);
       configureTosutil(resolvedTosutil, confPath, {
@@ -8289,7 +8424,7 @@ async function uploadStatic(options) {
       uploadToTos(resolvedTosutil, confPath, resolvedStaticDir, uploadPrefix);
     } finally {
       try {
-        fs28.unlinkSync(confPath);
+        fs30.unlinkSync(confPath);
       } catch {
       }
     }
@@ -8309,8 +8444,8 @@ async function uploadStatic(options) {
   }
 }
 function resolveTosutilPath(tosutilPath) {
-  if (path24.isAbsolute(tosutilPath)) {
-    return fs28.existsSync(tosutilPath) ? tosutilPath : null;
+  if (path25.isAbsolute(tosutilPath)) {
+    return fs30.existsSync(tosutilPath) ? tosutilPath : null;
   }
   try {
     const resolved = execFileSync("which", [tosutilPath], { encoding: "utf-8" }).trim();
@@ -8355,7 +8490,7 @@ async function resolveBucketId(appId) {
   return bucketId;
 }
 function isDirEmpty(dirPath) {
-  const entries = fs28.readdirSync(dirPath);
+  const entries = fs30.readdirSync(dirPath);
   return entries.length === 0;
 }
 
@@ -8451,13 +8586,13 @@ var commands = [
 
 // src/index.ts
 for (const filename of [".env.local", ".env"]) {
-  const envPath = path25.join(process.cwd(), filename);
-  if (fs29.existsSync(envPath)) {
+  const envPath = path26.join(process.cwd(), filename);
+  if (fs31.existsSync(envPath)) {
     dotenvConfig({ path: envPath });
   }
 }
-var __dirname = path25.dirname(fileURLToPath5(import.meta.url));
-var pkg = JSON.parse(fs29.readFileSync(path25.join(__dirname, "../package.json"), "utf-8"));
+var __dirname = path26.dirname(fileURLToPath5(import.meta.url));
+var pkg = JSON.parse(fs31.readFileSync(path26.join(__dirname, "../package.json"), "utf-8"));
 var cli = new FullstackCLI(pkg.version);
 cli.useAll(commands);
 cli.run();