@lark-apaas/fullstack-cli 1.1.16-beta.0 → 1.1.16-beta.10

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/index.ts
-import fs21 from "fs";
-import path17 from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import fs26 from "fs";
+import path22 from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
 import { config as dotenvConfig } from "dotenv";
 
 // src/cli.ts
@@ -472,11 +472,16 @@ var KNOWN_TYPE_FACTORIES = {
   user_profile: "userProfile",
   file_attachment: "fileAttachment"
 };
+var KNOWN_ARRAY_TYPE_FACTORIES = {
+  user_profile: "userProfileArray",
+  file_attachment: "fileAttachmentArray"
+};
 var replaceUnknownTransform = {
   name: "replace-unknown",
   transform(ctx) {
     const { sourceFile, stats } = ctx;
     const fullText = sourceFile.getFullText();
+    const replacements = [];
     sourceFile.forEachDescendant((node) => {
       if (!Node5.isCallExpression(node)) {
         return;
@@ -490,25 +495,49 @@ var replaceUnknownTransform = {
       const lines = textBefore.split("\n");
       let factoryName = "text";
       let foundKnownType = false;
+      let isArrayType = false;
       for (let i = lines.length - 1; i >= Math.max(0, lines.length - 5); i--) {
         const line = lines[i];
         const todoMatch = line.match(/\/\/ TODO: failed to parse database type '(?:\w+\.)?([\w_]+)(\[\])?'/);
         if (todoMatch) {
           const typeName = todoMatch[1];
-          if (KNOWN_TYPE_FACTORIES[typeName]) {
+          isArrayType = todoMatch[2] === "[]";
+          if (isArrayType && KNOWN_ARRAY_TYPE_FACTORIES[typeName]) {
+            factoryName = KNOWN_ARRAY_TYPE_FACTORIES[typeName];
+            foundKnownType = true;
+          } else if (KNOWN_TYPE_FACTORIES[typeName]) {
             factoryName = KNOWN_TYPE_FACTORIES[typeName];
             foundKnownType = true;
           }
           break;
         }
       }
+      replacements.push({
+        expression,
+        factoryName,
+        foundKnownType,
+        isArrayType,
+        node
+      });
+    });
+    for (const { expression, factoryName, foundKnownType, isArrayType, node } of replacements) {
       expression.replaceWithText(factoryName);
+      if (isArrayType && foundKnownType) {
+        const parent = node.getParent();
+        if (Node5.isPropertyAccessExpression(parent) && parent.getName() === "array") {
+          const grandParent = parent.getParent();
+          if (Node5.isCallExpression(grandParent)) {
+            const nodeText = node.getText();
+            grandParent.replaceWithText(nodeText);
+          }
+        }
+      }
       if (foundKnownType) {
         stats.replacedUnknown++;
       } else {
         stats.fallbackToText++;
       }
-    });
+    }
     const todoCommentRegex = /\/\/ TODO: failed to parse database type '[^']+'\s*\n/g;
     const currentText = sourceFile.getFullText();
     const cleanedText = currentText.replace(todoCommentRegex, "");
@@ -1005,6 +1034,215 @@ function resolveTemplateTypesPath() {
   return void 0;
 }
 
+// src/commands/db/gen-dbschema/utils/fetch-column-comments.ts
+import postgres from "postgres";
+var DEFAULT_TIMEOUT_MS = 1e4;
+async function fetchColumnComments(connectionString, options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const url = new URL(connectionString);
+  const schemaName = url.searchParams.get("schema") ?? "public";
+  const start = Date.now();
+  console.log(`[fetchColumnComments] \u2192 Querying pg_description for schema=${schemaName} (timeout=${timeoutMs}ms)`);
+  const sql = postgres(connectionString, {
+    connect_timeout: Math.ceil(timeoutMs / 1e3),
+    idle_timeout: Math.ceil(timeoutMs / 1e3)
+  });
+  try {
+    const queryPromise = sql`
+      SELECT
+        c.table_name AS "tableName",
+        c.column_name AS "columnName",
+        pgd.description AS "comment"
+      FROM information_schema.columns c
+      JOIN pg_catalog.pg_statio_all_tables st
+        ON c.table_name = st.relname AND c.table_schema = st.schemaname
+      JOIN pg_catalog.pg_description pgd
+        ON pgd.objoid = st.relid AND pgd.objsubid = c.ordinal_position
+      WHERE c.table_schema = ${schemaName}
+        AND pgd.description IS NOT NULL
+        AND pgd.description != ''
+    `;
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error(`Timeout after ${timeoutMs}ms`)), timeoutMs);
+    });
+    const result = await Promise.race([queryPromise, timeoutPromise]);
+    const commentMap = /* @__PURE__ */ new Map();
+    for (const row of result) {
+      const key = `${row.tableName}.${row.columnName}`;
+      commentMap.set(key, row.comment);
+    }
+    console.log(`[fetchColumnComments] \u2190 Fetched ${commentMap.size} column comments (${Date.now() - start}ms)`);
+    return commentMap;
+  } finally {
+    await sql.end().catch(() => {
+    });
+  }
+}
+function extractTypeAnnotation(comment) {
+  const typeStart = comment.indexOf("@type");
+  if (typeStart === -1) return null;
+  const afterType = comment.slice(typeStart + 5).trimStart();
+  if (!afterType.startsWith("{")) return null;
+  let depth = 0;
+  let endIndex = 0;
+  for (let i = 0; i < afterType.length; i++) {
+    if (afterType[i] === "{") depth++;
+    if (afterType[i] === "}") depth--;
+    if (depth === 0) {
+      endIndex = i + 1;
+      break;
+    }
+  }
+  if (endIndex === 0) return null;
+  return afterType.slice(0, endIndex);
+}
+function parseColumnComment(comment) {
+  const typeValue = extractTypeAnnotation(comment);
+  if (typeValue) {
+    const descMatch = comment.match(/@description\s+([^@]+)/);
+    return {
+      type: typeValue,
+      description: descMatch?.[1]?.trim()
+    };
+  }
+  return { description: comment.trim() };
+}
+
+// src/commands/db/gen-dbschema/transforms/text/jsonb-comments.ts
+function addJsonbTypeComments(source, columnComments) {
+  if (!columnComments || columnComments.size === 0) {
+    return { text: source, added: 0 };
+  }
+  const lines = source.split("\n");
+  const result = [];
+  let added = 0;
+  let currentTableName = null;
+  const tableDefRegex = /export const\s+\w+\s*=\s*pgTable\(\s*["'`]([^"'`]+)["'`]/;
+  const jsonFieldWithNameRegex = /^\s*(\w+):\s*(?:json|jsonb)\(\s*["'`]([^"'`]+)["'`]\)/;
+  const jsonFieldNoNameRegex = /^\s*(\w+):\s*(?:json|jsonb)\(\s*\)/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const tableMatch = line.match(tableDefRegex);
+    if (tableMatch) {
+      currentTableName = tableMatch[1];
+    }
+    let columnName = null;
+    const jsonMatchWithName = line.match(jsonFieldWithNameRegex);
+    const jsonMatchNoName = line.match(jsonFieldNoNameRegex);
+    if (jsonMatchWithName) {
+      columnName = jsonMatchWithName[2];
+    } else if (jsonMatchNoName) {
+      columnName = jsonMatchNoName[1];
+    }
+    if (columnName && currentTableName) {
+      const commentKey = `${currentTableName}.${columnName}`;
+      const comment = columnComments.get(commentKey);
+      if (comment) {
+        const parsed = parseColumnComment(comment);
+        const indentMatch = line.match(/^\s*/);
+        const indent = indentMatch ? indentMatch[0] : "";
+        const prevLine = result[result.length - 1]?.trim() ?? "";
+        if (!prevLine.startsWith("/**") && !prevLine.startsWith("*") && !prevLine.startsWith("//")) {
+          const commentLines = [];
+          commentLines.push(`${indent}/**`);
+          if (parsed.description) {
+            const safeDesc = parsed.description.replace(/[\r\n]+/g, " ").trim();
+            commentLines.push(`${indent} * ${safeDesc}`);
+          }
+          if (parsed.type) {
+            if (parsed.description) {
+              commentLines.push(`${indent} *`);
+            }
+            const safeType = parsed.type.replace(/[\r\n]+/g, " ").trim();
+            commentLines.push(`${indent} * @type ${safeType}`);
+          }
+          commentLines.push(`${indent} */`);
+          result.push(...commentLines);
+          added++;
+        }
+      }
+    }
+    if (line.match(/^\}\);?\s*$/) || line.match(/^}\s*,\s*\{/)) {
+      currentTableName = null;
+    }
+    result.push(line);
+  }
+  return { text: result.join("\n"), added };
+}
+
+// src/commands/db/gen-dbschema/transforms/text/synced-table-comments.ts
+var TABLE_COMMENT = "Synced table: data is auto-synced from external source. Do not rename or delete this table.";
+var FIELD_COMMENT = "Synced field: auto-synced, do not modify or delete";
+var TABLE_DEF_REGEX = /^(export const\s+\w+\s*=\s*(?:pgTable|pgView|pgMaterializedView)\(\s*["'`])([^"'`]+)(["'`])/;
+var FIELD_WITH_NAME_REGEX = /^\s*[\w"']+\s*:\s*\w+\(\s*["'`]([^"'`]+)["'`]/;
+var FIELD_PROP_NAME_REGEX = /^\s*([\w]+)\s*:/;
+function addSyncedTableComments(source, syncedTableMap) {
+  if (!syncedTableMap || syncedTableMap.size === 0) {
+    return { text: source, added: 0 };
+  }
+  const lines = source.split("\n");
+  const result = [];
+  let added = 0;
+  let currentSyncedFields = null;
+  let insideTableBody = false;
+  let braceDepth = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const tableMatch = line.match(TABLE_DEF_REGEX);
+    if (tableMatch) {
+      const tableName = tableMatch[2];
+      const syncedFields = syncedTableMap.get(tableName);
+      if (syncedFields) {
+        currentSyncedFields = syncedFields;
+        insideTableBody = true;
+        braceDepth = 0;
+        const prevLine = result[result.length - 1]?.trim() ?? "";
+        if (!prevLine.includes("Synced table")) {
+          const indentMatch = line.match(/^\s*/);
+          const indent = indentMatch ? indentMatch[0] : "";
+          result.push(`${indent}// ${TABLE_COMMENT}`);
+          added++;
+        }
+      }
+    }
+    if (insideTableBody) {
+      for (const ch of line) {
+        if (ch === "{") braceDepth++;
+        if (ch === "}") braceDepth--;
+      }
+      if (braceDepth <= 0) {
+        insideTableBody = false;
+        currentSyncedFields = null;
+      }
+      if (currentSyncedFields && braceDepth >= 1 && !tableMatch) {
+        const columnName = extractColumnName2(line);
+        if (columnName && currentSyncedFields.has(columnName)) {
+          const prevLine = result[result.length - 1]?.trim() ?? "";
+          if (!prevLine.includes("Synced field")) {
+            const indentMatch = line.match(/^\s*/);
+            const indent = indentMatch ? indentMatch[0] : "";
+            result.push(`${indent}// ${FIELD_COMMENT}`);
+            added++;
+          }
+        }
+      }
+    }
+    result.push(line);
+  }
+  return { text: result.join("\n"), added };
+}
+function extractColumnName2(line) {
+  const withNameMatch = line.match(FIELD_WITH_NAME_REGEX);
+  if (withNameMatch) {
+    return withNameMatch[1];
+  }
+  const propMatch = line.match(FIELD_PROP_NAME_REGEX);
+  if (propMatch) {
+    return propMatch[1];
+  }
+  return null;
+}
+
 // src/commands/db/gen-dbschema/transforms/text/table-aliases.ts
 var TABLE_ALIAS_MARKER = "// table aliases";
 function generateTableAliases(source) {
@@ -1041,7 +1279,7 @@ function formatSource(source) {
 }
 
 // src/commands/db/gen-dbschema/postprocess.ts
-function postprocessSchema(rawSource) {
+function postprocessSchema(rawSource, options = {}) {
   const patchResult = patchDefects(rawSource);
   let source = patchResult.text;
   const { sourceFile } = parseSource(source);
@@ -1051,12 +1289,18 @@ function postprocessSchema(rawSource) {
   source = ensureHeader(source);
   source = addSystemFieldComments(source);
   source = inlineCustomTypes(source);
+  const jsonbCommentsResult = addJsonbTypeComments(source, options.columnComments);
+  source = jsonbCommentsResult.text;
+  const syncedCommentsResult = addSyncedTableComments(source, options.syncedTableMap);
+  source = syncedCommentsResult.text;
   source = generateTableAliases(source);
   source = formatSource(source);
   return {
     source,
     astStats,
-    patchedDefects: patchResult.fixed
+    patchedDefects: patchResult.fixed,
+    addedJsonbComments: jsonbCommentsResult.added,
+    addedSyncedComments: syncedCommentsResult.added
   };
 }
 function logStats(result, prefix = "[postprocess]") {
@@ -1103,17 +1347,26 @@ function logStats(result, prefix = "[postprocess]") {
   if (astStats.removedImports.length > 0) {
     console.info(`${prefix} Removed imports: ${astStats.removedImports.join(", ")}`);
   }
+  if (result.addedJsonbComments > 0) {
+    console.info(`${prefix} Added ${result.addedJsonbComments} JSDoc comments for jsonb fields`);
+  }
+  if (result.addedSyncedComments > 0) {
+    console.info(`${prefix} Added ${result.addedSyncedComments} comments for synced tables/fields`);
+  }
 }
 
 // src/commands/db/gen-dbschema/index.ts
-function postprocessDrizzleSchema(targetPath) {
+async function postprocessDrizzleSchema(targetPath, options = {}) {
   const resolvedPath = path.resolve(targetPath);
   if (!fs3.existsSync(resolvedPath)) {
     console.warn(`[postprocess-drizzle-schema] File not found: ${resolvedPath}`);
     return void 0;
   }
   const rawSource = fs3.readFileSync(resolvedPath, "utf8");
-  const result = postprocessSchema(rawSource);
+  const result = postprocessSchema(rawSource, {
+    columnComments: options.columnComments,
+    syncedTableMap: options.syncedTableMap
+  });
   fs3.writeFileSync(resolvedPath, result.source, "utf8");
   logStats(result, "[postprocess-drizzle-schema]");
   return {
@@ -1122,10 +1375,114 @@ function postprocessDrizzleSchema(targetPath) {
     unmatchedUnknown: result.astStats.unmatchedUnknown,
     patchedDefects: result.patchedDefects,
     replacedTimestamps: result.astStats.replacedTimestamp,
-    replacedDefaultNow: result.astStats.replacedDefaultNow
+    replacedDefaultNow: result.astStats.replacedDefaultNow,
+    addedJsonbComments: result.addedJsonbComments,
+    addedSyncedComments: result.addedSyncedComments
   };
 }
 
+// src/utils/http-client.ts
+import { HttpClient } from "@lark-apaas/http-client";
+var clientInstance = null;
+function getHttpClient() {
+  if (!clientInstance) {
+    clientInstance = new HttpClient({
+      timeout: 3e4,
+      platform: {
+        enabled: true
+      }
+    });
+    const canaryEnv = process.env.FORCE_FRAMEWORK_CLI_CANARY_ENV;
+    if (canaryEnv) {
+      clientInstance.interceptors.request.use((req) => {
+        req.headers["x-tt-env"] = canaryEnv;
+        return req;
+      });
+    }
+  }
+  return clientInstance;
+}
+
+// src/commands/db/gen-dbschema/utils/fetch-synced-tables.ts
+var DEFAULT_TIMEOUT_MS2 = 1e4;
+async function fetchSyncedTables(appId, workspace) {
+  try {
+    const client = getHttpClient();
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(
+        () => reject(new Error(`Timeout after ${DEFAULT_TIMEOUT_MS2}ms`)),
+        DEFAULT_TIMEOUT_MS2
+      );
+    });
+    const dbBranch = process.env.FORCE_DB_BRANCH || "main";
+    const start = Date.now();
+    console.log(
+      `[fetchSyncedTables] \u2192 GET listTableView (dbBranch=${dbBranch}) appId=${appId ? "set" : "unset"} workspace=${workspace ? "set" : "unset"}`
+    );
+    const response = await Promise.race([
+      client.get(
+        `/api/v1/dataloom/inner/app/${appId}/workspaces/${workspace}/listTableView`,
+        { params: { dbBranch }, headers: { "x-supaas-bizsource": "miaoda" } }
+      ),
+      timeoutPromise
+    ]);
+    console.log(
+      `[fetchSyncedTables] \u2190 listTableView response: ${response.status} ${response.statusText} (${Date.now() - start}ms) with logId=${response.headers.get("x-tt-logid")}`
+    );
+    if (!response.ok) {
+      throw new Error(
+        `listTableView API failed: ${response.status} ${response.statusText}`
+      );
+    }
+    let json;
+    try {
+      json = await response.json();
+    } catch (error) {
+      console.warn(
+        "[fetchSyncedTables] \u26A0 Failed to parse listTableView response JSON, returning empty map:",
+        error instanceof Error ? error.message : String(error)
+      );
+      return /* @__PURE__ */ new Map();
+    }
+    const tableView = json?.data?.data;
+    if (!tableView) {
+      console.warn(
+        "[fetchSyncedTables] \u26A0 listTableView response missing data.data, returning empty map"
+      );
+      return /* @__PURE__ */ new Map();
+    }
+    const syncedMap = extractSyncedTableMap(tableView);
+    const totalCount = (tableView.table?.data?.length ?? 0) + (tableView.view?.data?.length ?? 0) + (tableView.materializedView?.data?.length ?? 0);
+    console.log(
+      `[fetchSyncedTables] \u2713 Extracted synced tables: ${syncedMap.size}/${totalCount} (elapsed ${Date.now() - start}ms)`
+    );
+    return syncedMap;
+  } catch (error) {
+    console.error(
+      "[fetchSyncedTables] \u274C Error fetching synced tables:",
+      error
+    );
+    return /* @__PURE__ */ new Map();
+  }
+}
+function extractSyncedTableMap(tableView) {
+  const syncedMap = /* @__PURE__ */ new Map();
+  const allTables = [
+    ...tableView.table?.data ?? [],
+    ...tableView.view?.data ?? [],
+    ...tableView.materializedView?.data ?? []
+  ];
+  for (const table of allTables) {
+    if (table.bitableSyncTask && table.bitableSyncTask.fieldApiNameList?.length > 0) {
+      syncedMap.set(
+        table.tableName,
+        new Set(table.bitableSyncTask.fieldApiNameList)
+      );
+    }
+  }
+  return syncedMap;
+}
+
 // src/commands/db/gen-nest-resource/generator.ts
 import { pluralize } from "inflection";
 
@@ -1804,7 +2161,9 @@ async function run(options = {}) {
   }
   const databaseUrl = process.env.SUDA_DATABASE_URL;
   if (!databaseUrl) {
-    console.error("[gen-db-schema] Error: SUDA_DATABASE_URL environment variable is required");
+    console.error(
+      "[gen-db-schema] Error: SUDA_DATABASE_URL environment variable is required"
+    );
     process.exit(1);
   }
   const outputPath = options.output || process.env.DB_SCHEMA_OUTPUT || "server/database/schema.ts";
@@ -1819,9 +2178,14 @@ async function run(options = {}) {
     path2.resolve(__dirname2, "../../../dist/config/drizzle.config.js")
   ];
   const configPath = configPathCandidates.find((p) => fs4.existsSync(p));
-  console.log("[gen-db-schema] Using drizzle config from:", configPath ?? "(not found)");
+  console.log(
+    "[gen-db-schema] Using drizzle config from:",
+    configPath ?? "(not found)"
+  );
   if (!configPath) {
-    console.error("[gen-db-schema] Error: drizzle config not found in CLI package");
+    console.error(
+      "[gen-db-schema] Error: drizzle config not found in CLI package"
+    );
     process.exit(1);
   }
   const resolveDrizzleKitBin = () => {
@@ -1837,7 +2201,9 @@ async function run(options = {}) {
           const binField = pkgJson.bin;
           const binRelPath = typeof binField === "string" ? binField : binField?.["drizzle-kit"];
           if (!binRelPath) {
-            throw new Error("Unable to resolve drizzle-kit binary from package.json");
+            throw new Error(
+              "Unable to resolve drizzle-kit binary from package.json"
+            );
           }
           return path2.resolve(currentDir, binRelPath);
         }
@@ -1847,6 +2213,67 @@ async function run(options = {}) {
     }
     throw new Error("Unable to locate drizzle-kit package root");
   };
+  let columnComments;
+  let syncedTableMap;
+  const appId = process.env.app_id;
+  const workspace = process.env.suda_workspace_id;
+  console.log(
+    `[gen-db-schema] Pre-fetch info: columnComments=enabled, syncedTables=${appId && workspace ? "enabled" : "skipped"} (app_id=${appId ? "set" : "unset"}, suda_workspace_id=${workspace ? "set" : "unset"})`
+  );
+  const columnCommentsTask = (async () => {
+    const start = Date.now();
+    console.log("[gen-db-schema] \u2192 Fetching column comments...");
+    const res = await fetchColumnComments(databaseUrl, { timeoutMs: 1e4 });
+    console.log(
+      `[gen-db-schema] \u2190 Fetched column comments: ${res.size} items (${Date.now() - start}ms)`
+    );
+    return res;
+  })();
+  const syncedTablesTask = appId && workspace ? (async () => {
+    const start = Date.now();
+    console.log(
+      "[gen-db-schema] \u2192 Fetching synced tables from listTableView..."
+    );
+    const res = await fetchSyncedTables(appId, workspace);
+    console.log(
+      `[gen-db-schema] \u2190 Fetched synced tables: ${res.size} tables (${Date.now() - start}ms)`
+    );
+    return res;
+  })() : void 0;
+  const fetchTasks = await Promise.allSettled([
+    columnCommentsTask,
+    ...syncedTablesTask ? [syncedTablesTask] : []
+  ]);
+  if (fetchTasks[0].status === "fulfilled") {
+    columnComments = fetchTasks[0].value;
+    console.log(
+      `[gen-db-schema] \u2713 Column comments ready: ${columnComments.size}`
+    );
+  } else {
+    console.warn(
+      "[gen-db-schema] \u26A0 Failed to fetch column comments (skipping):",
+      fetchTasks[0].reason instanceof Error ? fetchTasks[0].reason.message : String(fetchTasks[0].reason)
+    );
+  }
+  if (appId && workspace) {
+    if (fetchTasks[1]?.status === "fulfilled") {
+      syncedTableMap = fetchTasks[1].value;
+      console.log(
+        `[gen-db-schema] \u2713 Synced tables ready: ${syncedTableMap.size}`
+      );
+    } else if (fetchTasks[1]?.status === "rejected") {
+      console.warn(
+        "[gen-db-schema] \u26A0 Failed to fetch synced tables (skipping):",
+        fetchTasks[1].reason instanceof Error ? fetchTasks[1].reason.message : String(fetchTasks[1].reason)
+      );
+      syncedTableMap = /* @__PURE__ */ new Map();
+    }
+  } else {
+    console.info(
+      "[gen-db-schema] \u2139 Skipping synced table detection (app_id or suda_workspace_id not set)"
+    );
+    syncedTableMap = /* @__PURE__ */ new Map();
+  }
   try {
     const env = {
       ...process.env,
@@ -1857,22 +2284,34 @@ async function run(options = {}) {
     };
     const drizzleKitBin = resolveDrizzleKitBin();
     const spawnArgs = [drizzleKitBin, "introspect", "--config", configPath];
-    const result = spawnSync(process.execPath, spawnArgs, { stdio: "inherit", env, cwd: process.cwd() });
+    const result = spawnSync(process.execPath, spawnArgs, {
+      stdio: "inherit",
+      env,
+      cwd: process.cwd()
+    });
     if (result.error) {
       console.error("[gen-db-schema] Execution failed:", result.error);
       throw result.error;
     }
     if ((result.status ?? 0) !== 0) {
-      throw new Error(`drizzle-kit introspect failed with status ${result.status}`);
+      throw new Error(
+        `drizzle-kit introspect failed with status ${result.status}`
+      );
     }
     const generatedSchema = path2.join(OUT_DIR, "schema.ts");
     if (!fs4.existsSync(generatedSchema)) {
       console.error("[gen-db-schema] schema.ts not generated");
       throw new Error("drizzle-kit introspect failed to generate schema.ts");
     }
-    const stats = postprocessDrizzleSchema(generatedSchema);
+    const stats = await postprocessDrizzleSchema(generatedSchema, {
+      columnComments,
+      syncedTableMap
+    });
     if (stats?.unmatchedUnknown?.length) {
-      console.warn("[gen-db-schema] Unmatched custom types detected:", stats.unmatchedUnknown);
+      console.warn(
+        "[gen-db-schema] Unmatched custom types detected:",
+        stats.unmatchedUnknown
+      );
     }
     console.log("[gen-db-schema] \u2713 Postprocessed schema");
     fs4.mkdirSync(path2.dirname(SCHEMA_FILE), { recursive: true });
@@ -1887,14 +2326,22 @@ async function run(options = {}) {
           schemaFilePath,
           moduleOutputDir: path2.resolve(process.cwd(), "server/modules")
         });
-        console.log("[gen-db-schema] \u2713 Generate NestJS Module Boilerplate Successfully");
+        console.log(
+          "[gen-db-schema] \u2713 Generate NestJS Module Boilerplate Successfully"
+        );
       }
     } catch (error) {
-      console.warn("[gen-db-schema] Generate NestJS Module Boilerplate failed:", error instanceof Error ? error.message : String(error));
+      console.warn(
+        "[gen-db-schema] Generate NestJS Module Boilerplate failed:",
+        error instanceof Error ? error.message : String(error)
+      );
     }
     console.log("[gen-db-schema] \u2713 Complete");
   } catch (err) {
-    console.error("[gen-db-schema] Failed:", err instanceof Error ? err.message : String(err));
+    console.error(
+      "[gen-db-schema] Failed:",
+      err instanceof Error ? err.message : String(err)
+    );
     exitCode = 1;
   } finally {
     if (fs4.existsSync(OUT_DIR)) {
@@ -1931,12 +2378,15 @@ var syncConfig = {
       type: "directory",
       overwrite: true
     },
-    // 2. 覆写 nest-cli.json 配置，禁止用户修改
+    // 2. 智能合并 nest-cli.json 配置（保留用户自定义的 assets、plugins 等）
     {
       from: "templates/nest-cli.json",
       to: "nest-cli.json",
-      type: "file",
-      overwrite: true
+      type: "merge-json",
+      arrayMerge: {
+        "compilerOptions.assets": { key: "include" },
+        "compilerOptions.plugins": { key: "name" }
+      }
     },
     // // 2. 追加内容到 .gitignore
     // {
@@ -1960,6 +2410,34 @@ var syncConfig = {
       type: "remove-line",
       to: ".gitignore",
       pattern: "package-lock.json"
+    },
+    // 5. 注册 postinstall 脚本，自动恢复 action plugins
+    {
+      type: "add-script",
+      name: "postinstall",
+      command: "fullstack-cli action-plugin init",
+      overwrite: false
+    },
+    // 6. 替换 drizzle.config.ts（仅当文件存在时）
+    {
+      from: "templates/drizzle.config.ts",
+      to: "drizzle.config.ts",
+      type: "file",
+      overwrite: true,
+      onlyIfExists: true
+    },
+    // 7. 确保 .gitignore 包含 .agent/ 目录
+    {
+      type: "add-line",
+      to: ".gitignore",
+      line: ".agent/"
+    },
+    // 8. 同步 .spark_project 配置文件（总是覆盖）
+    {
+      from: "templates/.spark_project",
+      to: ".spark_project",
+      type: "file",
+      overwrite: true
     }
   ],
   // 文件权限设置
@@ -2001,6 +2479,52 @@ function removeLineFromFile(filePath, pattern) {
   return true;
 }
 
+// src/utils/merge-json.ts
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function mergeArrayByKey(userArr, templateArr, key) {
+  const result = [...userArr];
+  for (const templateItem of templateArr) {
+    if (!isPlainObject(templateItem)) continue;
+    const templateKey = templateItem[key];
+    const existingIndex = result.findIndex(
+      (item) => isPlainObject(item) && item[key] === templateKey
+    );
+    if (existingIndex >= 0) {
+      result[existingIndex] = templateItem;
+    } else {
+      result.push(templateItem);
+    }
+  }
+  return result;
+}
+function deepMergeJson(user, template, arrayMerge = {}, currentPath = "") {
+  const result = { ...user };
+  for (const key of Object.keys(template)) {
+    const fullPath = currentPath ? `${currentPath}.${key}` : key;
+    const templateValue = template[key];
+    const userValue = user[key];
+    if (Array.isArray(templateValue)) {
+      const mergeConfig = arrayMerge[fullPath];
+      if (mergeConfig && Array.isArray(userValue)) {
+        result[key] = mergeArrayByKey(userValue, templateValue, mergeConfig.key);
+      } else {
+        result[key] = templateValue;
+      }
+    } else if (isPlainObject(templateValue)) {
+      if (isPlainObject(userValue)) {
+        result[key] = deepMergeJson(userValue, templateValue, arrayMerge, fullPath);
+      } else {
+        result[key] = templateValue;
+      }
+    } else {
+      result[key] = templateValue;
+    }
+  }
+  return result;
+}
+
 // src/commands/sync/run.handler.ts
 async function run2(options) {
   const userProjectRoot = process.env.INIT_CWD || process.cwd();
@@ -2053,6 +2577,22 @@ async function syncRule(rule, pluginRoot, userProjectRoot) {
     removeLineFromFile(destPath2, rule.pattern);
     return;
   }
+  if (rule.type === "add-script") {
+    const packageJsonPath = path4.join(userProjectRoot, "package.json");
+    addScript(packageJsonPath, rule.name, rule.command, rule.overwrite ?? false);
+    return;
+  }
+  if (rule.type === "add-line") {
+    const destPath2 = path4.join(userProjectRoot, rule.to);
+    addLineToFile(destPath2, rule.line);
+    return;
+  }
+  if (rule.type === "merge-json") {
+    const srcPath2 = path4.join(pluginRoot, rule.from);
+    const destPath2 = path4.join(userProjectRoot, rule.to);
+    mergeJsonFile(srcPath2, destPath2, rule.arrayMerge);
+    return;
+  }
   if (!("from" in rule)) {
     return;
   }
@@ -2067,14 +2607,18 @@ async function syncRule(rule, pluginRoot, userProjectRoot) {
       syncDirectory(srcPath, destPath, rule.overwrite ?? true);
       break;
     case "file":
-      syncFile(srcPath, destPath, rule.overwrite ?? true);
+      syncFile(srcPath, destPath, rule.overwrite ?? true, rule.onlyIfExists ?? false);
       break;
     case "append":
       appendToFile(srcPath, destPath);
       break;
   }
 }
-function syncFile(src, dest, overwrite = true) {
+function syncFile(src, dest, overwrite = true, onlyIfExists = false) {
+  if (onlyIfExists && !fs6.existsSync(dest)) {
+    console.log(`[fullstack-cli] \u25CB ${path4.basename(dest)} (skipped, target not exists)`);
+    return;
+  }
   const destDir = path4.dirname(dest);
   if (!fs6.existsSync(destDir)) {
     fs6.mkdirSync(destDir, { recursive: true });
@@ -2155,6 +2699,69 @@ function deleteDirectory(dirPath) {
     console.log(`[fullstack-cli] \u25CB ${path4.basename(dirPath)} (not found)`);
   }
 }
+function addScript(packageJsonPath, name, command, overwrite) {
+  if (!fs6.existsSync(packageJsonPath)) {
+    console.log(`[fullstack-cli] \u25CB package.json (not found)`);
+    return;
+  }
+  const content = fs6.readFileSync(packageJsonPath, "utf-8");
+  const pkg2 = JSON.parse(content);
+  if (!pkg2.scripts) {
+    pkg2.scripts = {};
+  }
+  if (pkg2.scripts[name]) {
+    if (!overwrite) {
+      console.log(`[fullstack-cli] \u25CB scripts.${name} (already exists)`);
+      return;
+    }
+  }
+  pkg2.scripts[name] = command;
+  fs6.writeFileSync(packageJsonPath, JSON.stringify(pkg2, null, 2) + "\n");
+  console.log(`[fullstack-cli] \u2713 scripts.${name}`);
+}
+function addLineToFile(filePath, line) {
+  const fileName = path4.basename(filePath);
+  if (!fs6.existsSync(filePath)) {
+    console.log(`[fullstack-cli] \u25CB ${fileName} (not found, skipped)`);
+    return;
+  }
+  const content = fs6.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";
+  fs6.appendFileSync(filePath, appendContent);
+  console.log(`[fullstack-cli] \u2713 ${fileName} (added: ${line})`);
+}
+function mergeJsonFile(src, dest, arrayMerge) {
+  const fileName = path4.basename(dest);
+  if (!fs6.existsSync(src)) {
+    console.warn(`[fullstack-cli] Source not found: ${src}`);
+    return;
+  }
+  const templateContent = JSON.parse(fs6.readFileSync(src, "utf-8"));
+  if (!fs6.existsSync(dest)) {
+    const destDir = path4.dirname(dest);
+    if (!fs6.existsSync(destDir)) {
+      fs6.mkdirSync(destDir, { recursive: true });
+    }
+    fs6.writeFileSync(dest, JSON.stringify(templateContent, null, 2) + "\n");
+    console.log(`[fullstack-cli] \u2713 ${fileName} (created)`);
+    return;
+  }
+  const userContent = JSON.parse(fs6.readFileSync(dest, "utf-8"));
+  const merged = deepMergeJson(userContent, templateContent, arrayMerge ?? {});
+  const userStr = JSON.stringify(userContent, null, 2);
+  const mergedStr = JSON.stringify(merged, null, 2);
+  if (userStr === mergedStr) {
+    console.log(`[fullstack-cli] \u25CB ${fileName} (already up to date)`);
+    return;
+  }
+  fs6.writeFileSync(dest, mergedStr + "\n");
+  console.log(`[fullstack-cli] \u2713 ${fileName} (merged)`);
+}
 
 // src/commands/sync/index.ts
 var syncCommand = {
@@ -2167,55 +2774,443 @@ var syncCommand = {
   }
 };
 
-// src/commands/action-plugin/utils.ts
-import fs7 from "fs";
-import path5 from "path";
-import { spawnSync as spawnSync2, execSync } from "child_process";
-function parsePluginName(input) {
-  const match = input.match(/^(@[^/]+\/[^@]+)(?:@(.+))?$/);
-  if (!match) {
-    throw new Error(
-      `Invalid plugin name format: ${input}. Expected format: @scope/name or @scope/name@version`
-    );
+// src/utils/telemetry.ts
+async function reportEvents(events) {
+  if (events.length === 0) {
+    return true;
+  }
+  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 result = await response.json();
+    if (result.status_code !== "0") {
+      console.warn(`[telemetry] API error: ${result.message}`);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.warn(`[telemetry] Failed to report events: ${error instanceof Error ? error.message : error}`);
+    return false;
   }
-  return {
-    name: match[1],
-    version: match[2] || "latest"
-  };
-}
-function getProjectRoot() {
-  return process.cwd();
 }
-function getPackageJsonPath() {
-  return path5.join(getProjectRoot(), "package.json");
+async function reportInstallEvent(pluginKey, version) {
+  await reportEvents([
+    {
+      resourceType: "plugin",
+      resourceKey: pluginKey,
+      eventType: "install",
+      details: { version }
+    }
+  ]);
 }
-function getPluginPath(pluginName) {
-  return path5.join(getProjectRoot(), "node_modules", pluginName);
+async function reportCreateInstanceEvent(pluginKey, version) {
+  await reportEvents([
+    {
+      resourceType: "plugin",
+      resourceKey: pluginKey,
+      eventType: "create_instance",
+      details: { version }
+    }
+  ]);
 }
-function readPackageJson() {
-  const pkgPath = getPackageJsonPath();
-  if (!fs7.existsSync(pkgPath)) {
-    throw new Error("package.json not found in current directory");
-  }
+
+// src/utils/git.ts
+import { execSync, spawnSync as spawnSync2 } from "child_process";
+import fs7 from "fs";
+import path5 from "path";
+function isGitRepository(cwd = process.cwd()) {
   try {
-    const content = fs7.readFileSync(pkgPath, "utf-8");
-    return JSON.parse(content);
+    const gitDir = path5.join(cwd, ".git");
+    if (fs7.existsSync(gitDir)) {
+      return true;
+    }
+    const result = spawnSync2("git", ["rev-parse", "--git-dir"], {
+      cwd,
+      stdio: "pipe",
+      encoding: "utf-8"
+    });
+    return result.status === 0;
   } catch {
-    throw new Error("Failed to parse package.json");
+    return false;
   }
 }
-function writePackageJson(pkg2) {
-  const pkgPath = getPackageJsonPath();
-  fs7.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
-}
-function readActionPlugins() {
-  const pkg2 = readPackageJson();
-  return pkg2.actionPlugins || {};
+function getChangedFiles(cwd = process.cwd()) {
+  try {
+    const output = execSync("git status --porcelain", {
+      cwd,
+      stdio: "pipe",
+      encoding: "utf-8"
+    });
+    return output.split("\n").filter((line) => line.trim()).map((line) => line.substring(3));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to get changed files: ${message}`);
+  }
+}
+function gitAddUpgradeFiles(cwd = process.cwd(), filesToStage) {
+  const filteredFiles = [];
+  for (const filePath of filesToStage) {
+    if (fs7.existsSync(path5.join(cwd, filePath))) {
+      filteredFiles.push(filePath);
+      continue;
+    }
+    const tracked = spawnSync2("git", ["ls-files", "--error-unmatch", "--", filePath], {
+      cwd,
+      stdio: "pipe",
+      encoding: "utf-8"
+    });
+    if (tracked.status === 0) {
+      filteredFiles.push(filePath);
+    }
+  }
+  if (filteredFiles.length === 0) {
+    return;
+  }
+  const result = spawnSync2("git", ["add", "--", ...filteredFiles], {
+    cwd,
+    stdio: "pipe",
+    encoding: "utf-8"
+  });
+  if (result.error || result.status !== 0) {
+    const errorMsg = result.stderr || result.error?.message || "Unknown error";
+    throw new Error(`git add failed: ${errorMsg}`);
+  }
+}
+function hasStagedChanges(cwd = process.cwd()) {
+  const result = spawnSync2("git", ["diff", "--cached", "--quiet"], {
+    cwd,
+    stdio: "pipe",
+    encoding: "utf-8"
+  });
+  if (result.status === 0) {
+    return false;
+  }
+  if (result.status === 1) {
+    return true;
+  }
+  const errorMsg = result.stderr || result.error?.message || "Unknown error";
+  throw new Error(`Failed to check staged changes: ${errorMsg}`);
+}
+function gitCommit(message, cwd = process.cwd()) {
+  const result = spawnSync2("git", ["commit", "-m", message], {
+    cwd,
+    stdio: "pipe",
+    encoding: "utf-8"
+  });
+  if (result.error || result.status !== 0) {
+    const errorMsg = result.stderr || result.error?.message || "Unknown error";
+    throw new Error(`git commit failed: ${errorMsg}`);
+  }
+}
+function autoCommitUpgradeChanges(version, cwd, filesToStage, commitMessage) {
+  if (!isGitRepository(cwd)) {
+    console.log("[fullstack-cli] \u26A0 Not a git repository, skipping auto-commit");
+    return false;
+  }
+  const changedFiles = getChangedFiles(cwd);
+  if (changedFiles.length === 0) {
+    console.log("[fullstack-cli] No changes to commit");
+    return false;
+  }
+  try {
+    gitAddUpgradeFiles(cwd, filesToStage);
+    if (!hasStagedChanges(cwd)) {
+      console.log("[fullstack-cli] No upgrade changes to commit");
+      return false;
+    }
+    const message = commitMessage || `chore(upgrade): auto-upgrade by fullstack-cli
+
+- Sync template files
+- Cleanup package.json config
+- Upgrade @lark-apaas dependencies (if any)
+
+Auto-committed by fullstack-cli`;
+    gitCommit(message, cwd);
+    console.log(`[fullstack-cli] \u2713 Auto-committed ${changedFiles.length} changed file(s)`);
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to auto-commit changes: ${message}`);
+  }
+}
+
+// src/utils/package-json.ts
+import fs8 from "fs";
+import path6 from "path";
+function readPackageJson(cwd = process.cwd()) {
+  const pkgPath = path6.join(cwd, "package.json");
+  if (!fs8.existsSync(pkgPath)) {
+    throw new Error(`package.json not found at ${pkgPath}`);
+  }
+  const content = fs8.readFileSync(pkgPath, "utf-8");
+  return JSON.parse(content);
+}
+function writePackageJson(pkg2, cwd = process.cwd()) {
+  const pkgPath = path6.join(cwd, "package.json");
+  const content = JSON.stringify(pkg2, null, 2) + "\n";
+  fs8.writeFileSync(pkgPath, content, "utf-8");
+}
+function removeUpgradeScript(pkg2) {
+  if (!pkg2.scripts?.upgrade) {
+    return false;
+  }
+  delete pkg2.scripts.upgrade;
+  return true;
+}
+function cleanDevScript(pkg2) {
+  if (!pkg2.scripts?.dev) {
+    return false;
+  }
+  const originalDev = pkg2.scripts.dev;
+  const cleanedDev = originalDev.replace(/npm\s+run\s+upgrade\s*&&\s*/g, "").replace(/npm\s+run\s+upgrade\s*$/g, "").trim();
+  if (cleanedDev !== originalDev) {
+    pkg2.scripts.dev = cleanedDev;
+    return true;
+  }
+  return false;
+}
+function cleanupPackageJson(cwd = process.cwd()) {
+  try {
+    const pkg2 = readPackageJson(cwd);
+    let changed = false;
+    if (removeUpgradeScript(pkg2)) {
+      console.log("[fullstack-cli] \u2713 Removed scripts.upgrade");
+      changed = true;
+    }
+    if (cleanDevScript(pkg2)) {
+      console.log("[fullstack-cli] \u2713 Cleaned scripts.dev (removed npm run upgrade)");
+      changed = true;
+    }
+    if (changed) {
+      writePackageJson(pkg2, cwd);
+    }
+    return changed;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.log(`[fullstack-cli] \u26A0 Could not cleanup package.json: ${message}`);
+    return false;
+  }
+}
+
+// src/commands/upgrade/shared/utils.ts
+import path7 from "path";
+import fs9 from "fs";
+import { fileURLToPath as fileURLToPath4 } from "url";
+function getCliVersion() {
+  try {
+    const __filename = fileURLToPath4(import.meta.url);
+    const __dirname2 = path7.dirname(__filename);
+    const pkgPath = path7.resolve(__dirname2, "../../../package.json");
+    const pkgContent = fs9.readFileSync(pkgPath, "utf-8");
+    const pkg2 = JSON.parse(pkgContent);
+    return pkg2.version || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+// src/commands/upgrade/get-upgrade-files.ts
+function getUpgradeFilesToStage(disableGenOpenapi = true) {
+  const syncConfig2 = genSyncConfig({ disableGenOpenapi });
+  const filesToStage = /* @__PURE__ */ new Set();
+  syncConfig2.sync.forEach((rule) => {
+    if (rule.type === "file" || rule.type === "directory" || rule.type === "merge-json") {
+      filesToStage.add(rule.to);
+    } else if (rule.type === "remove-line" || rule.type === "add-line") {
+      filesToStage.add(rule.to);
+    } else if (rule.type === "add-script") {
+      filesToStage.add("package.json");
+    } else if (rule.type === "delete-file" || rule.type === "delete-directory") {
+      filesToStage.add(rule.to);
+    }
+  });
+  filesToStage.add("package.json");
+  filesToStage.add("package-lock.json");
+  return Array.from(filesToStage);
+}
+
+// src/commands/upgrade/run.handler.ts
+async function run3(options = {}) {
+  const userProjectRoot = process.env.INIT_CWD || process.cwd();
+  console.log("[fullstack-cli] Starting upgrade...");
+  try {
+    console.log("[fullstack-cli] Step 1/3: Syncing template files...");
+    await run2({ disableGenOpenapi: options.disableGenOpenapi ?? true });
+    console.log("[fullstack-cli] Step 2/3: Cleaning up package.json...");
+    const cleaned = cleanupPackageJson(userProjectRoot);
+    if (!cleaned) {
+      console.log("[fullstack-cli] \u25CB No cleanup needed");
+    }
+    const shouldCommit = options.commit ?? true;
+    if (shouldCommit) {
+      console.log("[fullstack-cli] Step 3/3: Committing changes...");
+      const version = getCliVersion();
+      const filesToStage = getUpgradeFilesToStage(options.disableGenOpenapi ?? true);
+      autoCommitUpgradeChanges(version, userProjectRoot, filesToStage);
+    } else {
+      console.log("[fullstack-cli] Step 3/3: Skipping commit (--no-commit flag)");
+    }
+    console.log("[fullstack-cli] Upgrade completed successfully \u2705");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("[fullstack-cli] Failed to upgrade:", message);
+    process.exit(1);
+  }
+}
+
+// src/commands/upgrade/deps/run.handler.ts
+import { spawnSync as spawnSync3 } from "child_process";
+function findLarkAapaasPackages(cwd, filterPackages) {
+  const pkg2 = readPackageJson(cwd);
+  const allPackages = /* @__PURE__ */ new Set();
+  if (pkg2.dependencies) {
+    Object.keys(pkg2.dependencies).forEach((name) => {
+      if (name.startsWith("@lark-apaas/")) {
+        allPackages.add(name);
+      }
+    });
+  }
+  if (pkg2.devDependencies) {
+    Object.keys(pkg2.devDependencies).forEach((name) => {
+      if (name.startsWith("@lark-apaas/")) {
+        allPackages.add(name);
+      }
+    });
+  }
+  const packages = Array.from(allPackages);
+  if (filterPackages) {
+    const filter = new Set(filterPackages.split(",").map((p) => p.trim()));
+    return packages.filter((p) => filter.has(p));
+  }
+  return packages;
+}
+function upgradePackages(packages, version, cwd) {
+  if (version) {
+    console.log(`[fullstack-cli] Upgrading to version ${version}...`);
+    packages.forEach((pkg2) => {
+      const target = `${pkg2}@${version}`;
+      console.log(`[fullstack-cli]   Installing ${target}...`);
+      const result = spawnSync3("npm", ["install", target], {
+        cwd,
+        stdio: "inherit"
+      });
+      if (result.error || result.status !== 0) {
+        throw new Error(`Failed to install ${target}`);
+      }
+    });
+  } else {
+    console.log("[fullstack-cli] Upgrading to latest compatible versions...");
+    packages.forEach((pkg2) => {
+      console.log(`[fullstack-cli]   Updating ${pkg2}...`);
+      const result = spawnSync3("npm", ["update", pkg2], {
+        cwd,
+        stdio: "inherit"
+      });
+      if (result.error || result.status !== 0) {
+        throw new Error(`Failed to update ${pkg2}`);
+      }
+    });
+  }
+}
+async function run4(options = {}) {
+  const cwd = process.env.INIT_CWD || process.cwd();
+  console.log("[fullstack-cli] Starting dependencies upgrade...");
+  try {
+    console.log("[fullstack-cli] Step 1/2: Scanning @lark-apaas dependencies...");
+    const packages = findLarkAapaasPackages(cwd, options.packages);
+    if (packages.length === 0) {
+      console.log("[fullstack-cli] No @lark-apaas packages found");
+      return;
+    }
+    console.log(`[fullstack-cli] Found ${packages.length} @lark-apaas package(s):`);
+    packages.forEach((p) => console.log(`  - ${p}`));
+    console.log("[fullstack-cli] Step 2/2: Upgrading packages...");
+    upgradePackages(packages, options.version, cwd);
+    console.log(`[fullstack-cli] \u2713 Successfully upgraded ${packages.length} package(s)`);
+    console.log("[fullstack-cli] Dependencies upgrade completed successfully \u2705");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("[fullstack-cli] Failed to upgrade dependencies:", message);
+    process.exit(1);
+  }
+}
+
+// src/commands/upgrade/deps/index.ts
+var depsCommand = {
+  name: "deps",
+  description: "Upgrade @lark-apaas dependencies",
+  register(parentCommand) {
+    parentCommand.command(this.name).description(this.description).option("--version <version>", "Upgrade to specific version").option("--packages <packages>", "Only upgrade specific packages (comma-separated)").action(async (options) => {
+      await run4(options);
+    });
+  }
+};
+
+// src/commands/upgrade/index.ts
+var upgradeCommand = {
+  name: "upgrade",
+  description: "Upgrade template files and auto-commit changes",
+  register(program) {
+    const upgradeCmd = program.command(this.name).description(this.description).option("--disable-gen-openapi", "Disable generating openapi.ts").option("--no-commit", "Skip auto-commit changes").action(async (options) => {
+      await run3(options);
+    });
+    depsCommand.register(upgradeCmd);
+  }
+};
+
+// src/commands/action-plugin/utils.ts
+import fs10 from "fs";
+import path8 from "path";
+import { spawnSync as spawnSync4, execSync as execSync2 } from "child_process";
+function parsePluginName(input) {
+  const match = input.match(/^(@[^/]+\/[^@]+)(?:@(.+))?$/);
+  if (!match) {
+    throw new Error(
+      `Invalid plugin name format: ${input}. Expected format: @scope/name or @scope/name@version`
+    );
+  }
+  return {
+    name: match[1],
+    version: match[2] || "latest"
+  };
+}
+function getProjectRoot() {
+  return process.cwd();
+}
+function getPackageJsonPath() {
+  return path8.join(getProjectRoot(), "package.json");
+}
+function getPluginPath(pluginName) {
+  return path8.join(getProjectRoot(), "node_modules", pluginName);
+}
+function readPackageJson2() {
+  const pkgPath = getPackageJsonPath();
+  if (!fs10.existsSync(pkgPath)) {
+    throw new Error("package.json not found in current directory");
+  }
+  try {
+    const content = fs10.readFileSync(pkgPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    throw new Error("Failed to parse package.json");
+  }
+}
+function writePackageJson2(pkg2) {
+  const pkgPath = getPackageJsonPath();
+  fs10.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+}
+function readActionPlugins() {
+  const pkg2 = readPackageJson2();
+  return pkg2.actionPlugins || {};
 }
 function writeActionPlugins(plugins) {
-  const pkg2 = readPackageJson();
+  const pkg2 = readPackageJson2();
   pkg2.actionPlugins = plugins;
-  writePackageJson(pkg2);
+  writePackageJson2(pkg2);
 }
 function isPluginInstalled(pluginName) {
   const plugins = readActionPlugins();
@@ -2227,7 +3222,7 @@ function getInstalledPluginVersion(pluginName) {
 }
 function npmInstall(tgzPath) {
   console.log(`[action-plugin] Running npm install ${tgzPath}...`);
-  const result = spawnSync2("npm", ["install", tgzPath, "--no-save", "--no-package-lock", "--ignore-scripts"], {
+  const result = spawnSync4("npm", ["install", tgzPath, "--no-save", "--no-package-lock", "--ignore-scripts"], {
     cwd: getProjectRoot(),
     stdio: "inherit"
   });
@@ -2239,12 +3234,12 @@ function npmInstall(tgzPath) {
   }
 }
 function getPackageVersion(pluginName) {
-  const pkgJsonPath = path5.join(getPluginPath(pluginName), "package.json");
-  if (!fs7.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path8.join(getPluginPath(pluginName), "package.json");
+  if (!fs10.existsSync(pkgJsonPath)) {
     return null;
   }
   try {
-    const content = fs7.readFileSync(pkgJsonPath, "utf-8");
+    const content = fs10.readFileSync(pkgJsonPath, "utf-8");
     const pkg2 = JSON.parse(content);
     return pkg2.version || null;
   } catch {
@@ -2252,49 +3247,49 @@ function getPackageVersion(pluginName) {
   }
 }
 function readPluginPackageJson(pluginPath) {
-  const pkgJsonPath = path5.join(pluginPath, "package.json");
-  if (!fs7.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path8.join(pluginPath, "package.json");
+  if (!fs10.existsSync(pkgJsonPath)) {
     return null;
   }
   try {
-    const content = fs7.readFileSync(pkgJsonPath, "utf-8");
+    const content = fs10.readFileSync(pkgJsonPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function extractTgzToNodeModules(tgzPath, pluginName) {
-  const nodeModulesPath = path5.join(getProjectRoot(), "node_modules");
-  const targetDir = path5.join(nodeModulesPath, pluginName);
-  const scopeDir = path5.dirname(targetDir);
-  if (!fs7.existsSync(scopeDir)) {
-    fs7.mkdirSync(scopeDir, { recursive: true });
+  const nodeModulesPath = path8.join(getProjectRoot(), "node_modules");
+  const targetDir = path8.join(nodeModulesPath, pluginName);
+  const scopeDir = path8.dirname(targetDir);
+  if (!fs10.existsSync(scopeDir)) {
+    fs10.mkdirSync(scopeDir, { recursive: true });
   }
-  if (fs7.existsSync(targetDir)) {
-    fs7.rmSync(targetDir, { recursive: true });
+  if (fs10.existsSync(targetDir)) {
+    fs10.rmSync(targetDir, { recursive: true });
   }
-  const tempDir = path5.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
-  if (fs7.existsSync(tempDir)) {
-    fs7.rmSync(tempDir, { recursive: true });
+  const tempDir = path8.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
+  if (fs10.existsSync(tempDir)) {
+    fs10.rmSync(tempDir, { recursive: true });
   }
-  fs7.mkdirSync(tempDir, { recursive: true });
+  fs10.mkdirSync(tempDir, { recursive: true });
   try {
-    execSync(`tar -xzf "${tgzPath}" -C "${tempDir}"`, { stdio: "pipe" });
-    const extractedDir = path5.join(tempDir, "package");
-    if (fs7.existsSync(extractedDir)) {
-      fs7.renameSync(extractedDir, targetDir);
+    execSync2(`tar -xzf "${tgzPath}" -C "${tempDir}"`, { stdio: "pipe" });
+    const extractedDir = path8.join(tempDir, "package");
+    if (fs10.existsSync(extractedDir)) {
+      fs10.renameSync(extractedDir, targetDir);
     } else {
-      const files = fs7.readdirSync(tempDir);
+      const files = fs10.readdirSync(tempDir);
       if (files.length === 1) {
-        fs7.renameSync(path5.join(tempDir, files[0]), targetDir);
+        fs10.renameSync(path8.join(tempDir, files[0]), targetDir);
       } else {
         throw new Error("Unexpected tgz structure");
       }
     }
     return targetDir;
   } finally {
-    if (fs7.existsSync(tempDir)) {
-      fs7.rmSync(tempDir, { recursive: true });
+    if (fs10.existsSync(tempDir)) {
+      fs10.rmSync(tempDir, { recursive: true });
     }
   }
 }
@@ -2303,10 +3298,10 @@ function checkMissingPeerDeps(peerDeps) {
     return [];
   }
   const missing = [];
-  const nodeModulesPath = path5.join(getProjectRoot(), "node_modules");
+  const nodeModulesPath = path8.join(getProjectRoot(), "node_modules");
   for (const [depName, _version] of Object.entries(peerDeps)) {
-    const depPath = path5.join(nodeModulesPath, depName);
-    if (!fs7.existsSync(depPath)) {
+    const depPath = path8.join(nodeModulesPath, depName);
+    if (!fs10.existsSync(depPath)) {
       missing.push(depName);
     }
   }
@@ -2317,7 +3312,7 @@ function installMissingDeps(deps) {
     return;
   }
   console.log(`[action-plugin] Installing missing dependencies: ${deps.join(", ")}`);
-  const result = spawnSync2("npm", ["install", ...deps, "--no-save", "--no-package-lock"], {
+  const result = spawnSync4("npm", ["install", ...deps, "--no-save", "--no-package-lock"], {
     cwd: getProjectRoot(),
     stdio: "inherit"
   });
@@ -2330,40 +3325,16 @@ function installMissingDeps(deps) {
 }
 function removePluginDirectory(pluginName) {
   const pluginPath = getPluginPath(pluginName);
-  if (fs7.existsSync(pluginPath)) {
-    fs7.rmSync(pluginPath, { recursive: true });
+  if (fs10.existsSync(pluginPath)) {
+    fs10.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 fs8 from "fs";
-import path6 from "path";
-
-// src/utils/http-client.ts
-import { HttpClient } from "@lark-apaas/http-client";
-var clientInstance = null;
-function getHttpClient() {
-  if (!clientInstance) {
-    clientInstance = new HttpClient({
-      timeout: 3e4,
-      platform: {
-        enabled: true
-      }
-    });
-    const canaryEnv = process.env.FORCE_FRAMEWORK_CLI_CANARY_ENV;
-    if (canaryEnv) {
-      clientInstance.interceptors.request.use((req) => {
-        req.headers["x-tt-env"] = canaryEnv;
-        return req;
-      });
-    }
-  }
-  return clientInstance;
-}
-
-// src/commands/action-plugin/api-client.ts
+import fs11 from "fs";
+import path9 from "path";
 var PLUGIN_CACHE_DIR = "node_modules/.cache/fullstack-cli/plugins";
 async function getPluginVersions(keys, latestOnly = true) {
   const client = getHttpClient();
@@ -2427,19 +3398,34 @@ async function downloadFromPublic(downloadURL) {
   return Buffer.from(arrayBuffer);
 }
 function getPluginCacheDir() {
-  return path6.join(process.cwd(), PLUGIN_CACHE_DIR);
+  return path9.join(process.cwd(), PLUGIN_CACHE_DIR);
 }
 function ensureCacheDir() {
   const cacheDir = getPluginCacheDir();
-  if (!fs8.existsSync(cacheDir)) {
-    fs8.mkdirSync(cacheDir, { recursive: true });
+  if (!fs11.existsSync(cacheDir)) {
+    fs11.mkdirSync(cacheDir, { recursive: true });
   }
 }
 function getTempFilePath(pluginKey, version) {
   ensureCacheDir();
   const safeKey = pluginKey.replace(/[/@]/g, "_");
-  const filename = `${safeKey}-${version}.tgz`;
-  return path6.join(getPluginCacheDir(), filename);
+  const filename = `${safeKey}@${version}.tgz`;
+  return path9.join(getPluginCacheDir(), filename);
+}
+var MAX_RETRIES = 2;
+async function withRetry(operation, description, maxRetries = MAX_RETRIES) {
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < maxRetries) {
+        console.log(`[action-plugin] ${description} failed, retrying (${attempt + 1}/${maxRetries})...`);
+      }
+    }
+  }
+  throw lastError;
 }
 async function downloadPlugin(pluginKey, requestedVersion) {
   console.log(`[action-plugin] Fetching plugin info for ${pluginKey}@${requestedVersion}...`);
@@ -2449,13 +3435,19 @@ async function downloadPlugin(pluginKey, requestedVersion) {
   let tgzBuffer;
   if (pluginInfo.downloadApproach === "inner") {
     console.log(`[action-plugin] Downloading from inner API...`);
-    tgzBuffer = await downloadFromInner(pluginKey, pluginInfo.version);
+    tgzBuffer = await withRetry(
+      () => downloadFromInner(pluginKey, pluginInfo.version),
+      "Download"
+    );
   } else {
     console.log(`[action-plugin] Downloading from public URL...`);
-    tgzBuffer = await downloadFromPublic(pluginInfo.downloadURL);
+    tgzBuffer = await withRetry(
+      () => downloadFromPublic(pluginInfo.downloadURL),
+      "Download"
+    );
   }
   const tgzPath = getTempFilePath(pluginKey, pluginInfo.version);
-  fs8.writeFileSync(tgzPath, tgzBuffer);
+  fs11.writeFileSync(tgzPath, tgzBuffer);
   console.log(`[action-plugin] Downloaded to ${tgzPath} (${(tgzBuffer.length / 1024).toFixed(2)} KB)`);
   return {
     tgzPath,
@@ -2464,25 +3456,99 @@ async function downloadPlugin(pluginKey, requestedVersion) {
   };
 }
 function cleanupTempFile(tgzPath) {
-  try {
-    if (fs8.existsSync(tgzPath)) {
-      fs8.unlinkSync(tgzPath);
+}
+function getCachePath(pluginKey, version) {
+  ensureCacheDir();
+  const safeKey = pluginKey.replace(/[/@]/g, "_");
+  const filename = `${safeKey}@${version}.tgz`;
+  return path9.join(getPluginCacheDir(), filename);
+}
+function hasCachedPlugin(pluginKey, version) {
+  const cachePath = getCachePath(pluginKey, version);
+  return fs11.existsSync(cachePath);
+}
+function listCachedPlugins() {
+  const cacheDir = getPluginCacheDir();
+  if (!fs11.existsSync(cacheDir)) {
+    return [];
+  }
+  const files = fs11.readdirSync(cacheDir);
+  const result = [];
+  for (const file of files) {
+    if (!file.endsWith(".tgz")) continue;
+    const match = file.match(/^(.+)@(.+)\.tgz$/);
+    if (!match) continue;
+    const [, rawName, version] = match;
+    const name = rawName.replace(/^_/, "@").replace(/_/, "/");
+    const filePath = path9.join(cacheDir, file);
+    const stat = fs11.statSync(filePath);
+    result.push({
+      name,
+      version,
+      filePath,
+      size: stat.size,
+      mtime: stat.mtime
+    });
+  }
+  return result;
+}
+function cleanAllCache() {
+  const cacheDir = getPluginCacheDir();
+  if (!fs11.existsSync(cacheDir)) {
+    return 0;
+  }
+  const files = fs11.readdirSync(cacheDir);
+  let count = 0;
+  for (const file of files) {
+    if (file.endsWith(".tgz")) {
+      fs11.unlinkSync(path9.join(cacheDir, file));
+      count++;
     }
-  } catch {
   }
+  return count;
+}
+function cleanPluginCache(pluginKey, version) {
+  const cacheDir = getPluginCacheDir();
+  if (!fs11.existsSync(cacheDir)) {
+    return 0;
+  }
+  const safeKey = pluginKey.replace(/[/@]/g, "_");
+  const files = fs11.readdirSync(cacheDir);
+  let count = 0;
+  for (const file of files) {
+    if (version) {
+      if (file === `${safeKey}@${version}.tgz`) {
+        fs11.unlinkSync(path9.join(cacheDir, file));
+        count++;
+      }
+    } else {
+      if (file.startsWith(`${safeKey}@`) && file.endsWith(".tgz")) {
+        fs11.unlinkSync(path9.join(cacheDir, file));
+        count++;
+      }
+    }
+  }
+  return count;
 }
 
 // src/commands/action-plugin/init.handler.ts
 async function installOneForInit(name, version) {
-  let tgzPath;
   try {
     const installedVersion = getPackageVersion(name);
     if (installedVersion === version) {
       return { name, version, success: true, skipped: true };
     }
-    console.log(`[action-plugin] Installing ${name}@${version}...`);
-    const downloadResult = await downloadPlugin(name, version);
-    tgzPath = downloadResult.tgzPath;
+    let tgzPath;
+    let fromCache = false;
+    if (hasCachedPlugin(name, version)) {
+      console.log(`[action-plugin] \u21BB Restoring ${name}@${version} from cache...`);
+      tgzPath = getCachePath(name, version);
+      fromCache = true;
+    } else {
+      console.log(`[action-plugin] \u2193 Downloading ${name}@${version}...`);
+      const downloadResult = await downloadPlugin(name, version);
+      tgzPath = downloadResult.tgzPath;
+    }
     const pluginDir = extractTgzToNodeModules(tgzPath, name);
     const pluginPkg = readPluginPackageJson(pluginDir);
     if (pluginPkg?.peerDependencies) {
@@ -2491,16 +3557,13 @@ async function installOneForInit(name, version) {
         installMissingDeps(missingDeps);
       }
     }
-    console.log(`[action-plugin] \u2713 Installed ${name}@${version}`);
+    const source = fromCache ? "from cache" : "downloaded";
+    console.log(`[action-plugin] \u2713 Installed ${name}@${version} (${source})`);
     return { name, version, success: true };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error(`[action-plugin] \u2717 Failed to install ${name}: ${message}`);
     return { name, version, success: false, error: message };
-  } finally {
-    if (tgzPath) {
-      cleanupTempFile(tgzPath);
-    }
   }
 }
 async function init() {
@@ -2546,7 +3609,6 @@ function syncActionPluginsRecord(name, version) {
   }
 }
 async function installOne(nameWithVersion) {
-  let tgzPath;
   const { name, version: requestedVersion } = parsePluginName(nameWithVersion);
   try {
     console.log(`[action-plugin] Installing ${name}@${requestedVersion}...`);
@@ -2555,20 +3617,35 @@ async function installOne(nameWithVersion) {
       if (actualVersion === requestedVersion) {
         console.log(`[action-plugin] Plugin ${name}@${requestedVersion} is already installed`);
         syncActionPluginsRecord(name, actualVersion);
+        reportCreateInstanceEvent(name, actualVersion).catch(() => {
+        });
         return { name, version: actualVersion, success: true, skipped: true };
       }
     }
-    if (actualVersion && requestedVersion === "latest") {
+    let targetVersion = requestedVersion;
+    if (requestedVersion === "latest") {
       const latestInfo = await getPluginVersion(name, "latest");
-      if (actualVersion === latestInfo.version) {
+      targetVersion = latestInfo.version;
+      if (actualVersion === targetVersion) {
         console.log(`[action-plugin] Plugin ${name} is already up to date (version: ${actualVersion})`);
         syncActionPluginsRecord(name, actualVersion);
+        reportCreateInstanceEvent(name, actualVersion).catch(() => {
+        });
         return { name, version: actualVersion, success: true, skipped: true };
       }
-      console.log(`[action-plugin] Found newer version: ${latestInfo.version} (installed: ${actualVersion})`);
+      console.log(`[action-plugin] Found newer version: ${targetVersion} (installed: ${actualVersion || "none"})`);
+    }
+    let tgzPath;
+    let fromCache = false;
+    if (hasCachedPlugin(name, targetVersion)) {
+      console.log(`[action-plugin] \u21BB Using cached ${name}@${targetVersion}...`);
+      tgzPath = getCachePath(name, targetVersion);
+      fromCache = true;
+    } else {
+      console.log(`[action-plugin] \u2193 Downloading ${name}@${targetVersion}...`);
+      const downloadResult = await downloadPlugin(name, requestedVersion);
+      tgzPath = downloadResult.tgzPath;
     }
-    const downloadResult = await downloadPlugin(name, requestedVersion);
-    tgzPath = downloadResult.tgzPath;
     console.log(`[action-plugin] Extracting to node_modules...`);
     const pluginDir = extractTgzToNodeModules(tgzPath, name);
     const pluginPkg = readPluginPackageJson(pluginDir);
@@ -2578,20 +3655,21 @@ async function installOne(nameWithVersion) {
         installMissingDeps(missingDeps);
       }
     }
-    const installedVersion = getPackageVersion(name) || downloadResult.version;
+    const installedVersion = getPackageVersion(name) || targetVersion;
     const plugins = readActionPlugins();
     plugins[name] = installedVersion;
     writeActionPlugins(plugins);
-    console.log(`[action-plugin] Successfully installed ${name}@${installedVersion}`);
+    const source = fromCache ? "from cache" : "downloaded";
+    console.log(`[action-plugin] Successfully installed ${name}@${installedVersion} (${source})`);
+    reportInstallEvent(name, installedVersion).catch(() => {
+    });
+    reportCreateInstanceEvent(name, installedVersion).catch(() => {
+    });
     return { name, version: installedVersion, success: true };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error(`[action-plugin] Failed to install ${name}: ${message}`);
     return { name, version: requestedVersion, success: false, error: message };
-  } finally {
-    if (tgzPath) {
-      cleanupTempFile(tgzPath);
-    }
   }
 }
 async function install(namesWithVersion) {
@@ -2745,6 +3823,58 @@ async function list() {
   }
 }
 
+// src/commands/action-plugin/cache.handler.ts
+async function cacheList() {
+  const cached = listCachedPlugins();
+  if (cached.length === 0) {
+    console.log("[action-plugin] No cached plugins found");
+    return;
+  }
+  console.log("[action-plugin] Cached plugins:\n");
+  console.log("  Name                                  Version     Size       Modified");
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  let totalSize = 0;
+  for (const plugin of cached) {
+    const name = plugin.name.padEnd(38);
+    const version = plugin.version.padEnd(10);
+    const size = formatSize(plugin.size).padEnd(9);
+    const mtime = plugin.mtime.toISOString().replace("T", " ").slice(0, 19);
+    console.log(`  ${name}  ${version}  ${size}  ${mtime}`);
+    totalSize += plugin.size;
+  }
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log(`  Total: ${cached.length} cached file(s), ${formatSize(totalSize)}`);
+}
+async function cacheClean(pluginName, version) {
+  let count;
+  if (pluginName) {
+    console.log(`[action-plugin] Cleaning cache for ${pluginName}${version ? `@${version}` : ""}...`);
+    count = cleanPluginCache(pluginName, version);
+    if (count === 0) {
+      console.log(`[action-plugin] No cached files found for ${pluginName}${version ? `@${version}` : ""}`);
+    } else {
+      console.log(`[action-plugin] Cleaned ${count} cached file(s)`);
+    }
+  } else {
+    console.log("[action-plugin] Cleaning all cached plugins...");
+    count = cleanAllCache();
+    if (count === 0) {
+      console.log("[action-plugin] No cached files found");
+    } else {
+      console.log(`[action-plugin] Cleaned ${count} cached file(s)`);
+    }
+  }
+}
+function formatSize(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  } else if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  } else {
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  }
+}
+
 // src/commands/action-plugin/index.ts
 var initCommand = {
   name: "init",
@@ -2795,46 +3925,65 @@ var listCommand = {
     });
   }
 };
+var cacheListCommand = {
+  name: "cache-list",
+  description: "List all cached plugin packages",
+  register(program) {
+    program.command(this.name).description(this.description).action(async () => {
+      await cacheList();
+    });
+  }
+};
+var cacheCleanCommand = {
+  name: "cache-clean",
+  description: "Clean cached plugin packages",
+  register(program) {
+    program.command(this.name).description(this.description).argument("[name]", "Plugin name to clean (e.g., @office/feishu-create-group). If not provided, clean all cache.").option("-v, --version <version>", "Specific version to clean").action(async (name, options) => {
+      await cacheClean(name, options.version);
+    });
+  }
+};
 var actionPluginCommandGroup = {
   name: "action-plugin",
   description: "Manage action plugins",
-  commands: [initCommand, installCommand, updateCommand, removeCommand, listCommand]
+  commands: [initCommand, installCommand, updateCommand, removeCommand, listCommand, cacheListCommand, cacheCleanCommand]
 };
 
 // src/commands/capability/utils.ts
-import fs9 from "fs";
-import path7 from "path";
+import fs12 from "fs";
+import { createRequire as createRequire2 } from "module";
+import path10 from "path";
 var CAPABILITIES_DIR = "server/capabilities";
 function getProjectRoot2() {
   return process.cwd();
 }
 function getCapabilitiesDir() {
-  return path7.join(getProjectRoot2(), CAPABILITIES_DIR);
+  return path10.join(getProjectRoot2(), CAPABILITIES_DIR);
 }
 function getCapabilityPath(id) {
-  return path7.join(getCapabilitiesDir(), `${id}.json`);
+  return path10.join(getCapabilitiesDir(), `${id}.json`);
 }
 function getPluginManifestPath(pluginKey) {
-  return path7.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
+  return path10.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
 }
 function capabilitiesDirExists() {
-  return fs9.existsSync(getCapabilitiesDir());
+  return fs12.existsSync(getCapabilitiesDir());
 }
 function listCapabilityIds() {
   const dir = getCapabilitiesDir();
-  if (!fs9.existsSync(dir)) {
+  if (!fs12.existsSync(dir)) {
     return [];
   }
-  const files = fs9.readdirSync(dir);
+  const files = fs12.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 (!fs9.existsSync(filePath)) {
+  if (!fs12.existsSync(filePath)) {
     throw new Error(`Capability not found: ${id}`);
   }
   try {
-    const content = fs9.readFileSync(filePath, "utf-8");
+    const content = fs12.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -2861,11 +4010,11 @@ function readAllCapabilities() {
 }
 function readPluginManifest(pluginKey) {
   const manifestPath = getPluginManifestPath(pluginKey);
-  if (!fs9.existsSync(manifestPath)) {
+  if (!fs12.existsSync(manifestPath)) {
     throw new Error(`Plugin not installed: ${pluginKey} (manifest.json not found)`);
   }
   try {
-    const content = fs9.readFileSync(manifestPath, "utf-8");
+    const content = fs12.readFileSync(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -2882,7 +4031,10 @@ function hasValidParamsSchema(paramsSchema) {
 }
 async function loadPlugin(pluginKey) {
   try {
-    const pluginPackage = (await import(pluginKey)).default;
+    const userRequire = createRequire2(path10.join(getProjectRoot2(), "package.json"));
+    const resolvedPath = userRequire.resolve(pluginKey);
+    const pluginModule = await import(resolvedPath);
+    const pluginPackage = pluginModule.default ?? pluginModule;
     if (!pluginPackage || typeof pluginPackage.create !== "function") {
       throw new Error(`Plugin ${pluginKey} does not export a valid create function`);
     }
@@ -2976,121 +4128,420 @@ function logError(message) {
   console.error(`[capability] Error: ${message}`);
 }
 
-// src/commands/capability/list.handler.ts
-async function list2(options) {
-  try {
-    if (!capabilitiesDirExists()) {
-      logError("server/capabilities directory not found");
-      process.exit(1);
+// src/commands/capability/list.handler.ts
+async function list2(options) {
+  try {
+    if (!capabilitiesDirExists()) {
+      logError("server/capabilities directory not found");
+      process.exit(1);
+    }
+    if (options.id) {
+      await listSingle(options.id, options.summary);
+    } else {
+      await listAll(options.summary);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logError(message);
+    process.exit(1);
+  }
+}
+async function listSingle(id, summary) {
+  const capability = readCapability(id);
+  if (summary) {
+    printJson(capability);
+  } else {
+    const hydrated = await hydrateCapability(capability);
+    printJson(hydrated);
+  }
+}
+async function listAll(summary) {
+  const capabilities = readAllCapabilities();
+  if (capabilities.length === 0) {
+    printJson([]);
+    return;
+  }
+  if (summary) {
+    printJson(capabilities);
+  } else {
+    const hydrated = [];
+    for (const capability of capabilities) {
+      const result = await hydrateCapability(capability);
+      hydrated.push(result);
+    }
+    printJson(hydrated);
+  }
+}
+
+// src/commands/capability/index.ts
+var listCommand2 = {
+  name: "list",
+  description: "List capability configurations",
+  aliases: ["ls"],
+  register(program) {
+    program.command(this.name).alias("ls").description(this.description).option("--summary", "Return raw capability config (without hydration)").option("--id <id>", "Specify capability ID").action(async (options) => {
+      await list2(options);
+    });
+  }
+};
+var capabilityCommandGroup = {
+  name: "capability",
+  description: "Manage capability configurations",
+  commands: [listCommand2]
+};
+
+// src/commands/component/add.handler.ts
+import { execFile } from "child_process";
+
+// src/commands/component/registry-preparer.ts
+import fs13 from "fs";
+import path11 from "path";
+import os from "os";
+
+// src/commands/component/service.ts
+import { mapValues } from "es-toolkit";
+
+// src/commands/component/utils.ts
+import createDebug from "debug";
+var debug = createDebug("component");
+
+// src/commands/component/service.ts
+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(",")}`
+  );
+  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}`);
+  }
+  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 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: {}
+      }
+    ]
+  });
+}
+
+// src/commands/component/registry-preparer.ts
+var REGISTRY_TEMP_DIR = path11.join(os.tmpdir(), "miaoda-registry");
+function parseComponentKey(key) {
+  const match = key.match(/^@([^/]+)\/(.+)$/);
+  if (!match) {
+    throw new Error(
+      `Invalid component key format: ${key}. Expected format: @scope/name`
+    );
+  }
+  return { scope: match[1], name: match[2] };
+}
+function getLocalRegistryPath(key) {
+  const { scope, name } = parseComponentKey(key);
+  return path11.join(REGISTRY_TEMP_DIR, scope, `${name}.json`);
+}
+function ensureDir(dirPath) {
+  if (!fs13.existsSync(dirPath)) {
+    fs13.mkdirSync(dirPath, { recursive: true });
+  }
+}
+async function prepareRecursive(key, visited) {
+  if (visited.has(key)) {
+    debug("\u8DF3\u8FC7\u5DF2\u5904\u7406\u7684\u7EC4\u4EF6: %s", key);
+    return;
+  }
+  visited.add(key);
+  debug("\u5904\u7406\u7EC4\u4EF6: %s", key);
+  debug("\u83B7\u53D6\u7EC4\u4EF6\u4E0B\u8F7D\u4FE1\u606F...");
+  const infoMap = await getComponents([key]);
+  const info = infoMap[key];
+  debug("\u7EC4\u4EF6\u4FE1\u606F: %o", info);
+  if (!info) {
+    throw new Error(`Component not found: ${key}`);
+  }
+  if (info.status !== "active") {
+    throw new Error(`Component is not active: ${key}`);
+  }
+  debug("\u4E0B\u8F7D registry item: %s", info.downloadURL);
+  const registryItem = await getRegistryItem(info.downloadURL);
+  debug("registry item \u5185\u5BB9: %o", registryItem);
+  const deps = registryItem.registryDependencies || [];
+  debug("\u4F9D\u8D56\u5217\u8868: %o", deps);
+  for (const dep of deps) {
+    await prepareRecursive(dep, visited);
+  }
+  const rewrittenItem = {
+    ...registryItem,
+    registryDependencies: deps.map((dep) => getLocalRegistryPath(dep))
+  };
+  const localPath = getLocalRegistryPath(key);
+  ensureDir(path11.dirname(localPath));
+  fs13.writeFileSync(localPath, JSON.stringify(rewrittenItem, null, 2), "utf-8");
+  debug("\u4FDD\u5B58\u5230: %s", localPath);
+}
+async function prepareComponentRegistryItems(id) {
+  const visited = /* @__PURE__ */ new Set();
+  await prepareRecursive(id, visited);
+  return getLocalRegistryPath(id);
+}
+function cleanupTempDir() {
+  try {
+    if (fs13.existsSync(REGISTRY_TEMP_DIR)) {
+      fs13.rmSync(REGISTRY_TEMP_DIR, { recursive: true, force: true });
+    }
+  } catch {
+  }
+}
+function getDownloadedRegistryItem(itemId) {
+  const localPath = getLocalRegistryPath(itemId);
+  if (!fs13.existsSync(localPath)) {
+    return null;
+  }
+  const content = fs13.readFileSync(localPath, "utf-8");
+  return JSON.parse(content);
+}
+
+// src/commands/component/shadcn-executor.ts
+import * as pty from "@lydell/node-pty";
+function parseOutput(output) {
+  const state = {
+    currentSection: null,
+    files: /* @__PURE__ */ new Set()
+  };
+  const lines = output.split("\n");
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (/Created \d+ files?:/.test(trimmedLine)) {
+      state.currentSection = "created";
+      continue;
     }
-    if (options.id) {
-      await listSingle(options.id, options.summary);
-    } else {
-      await listAll(options.summary);
+    if (/Updated \d+ files?:/.test(trimmedLine)) {
+      state.currentSection = "updated";
+      continue;
+    }
+    if (/Skipped \d+ files?:/.test(trimmedLine)) {
+      state.currentSection = "skipped";
+      continue;
+    }
+    if (state.currentSection && trimmedLine.startsWith("- ")) {
+      const filePath = trimmedLine.slice(2).trim();
+      if (filePath && filePath.includes("/")) {
+        state.files.add(filePath);
+      }
+    }
+    if (state.currentSection && trimmedLine.length > 1 && !trimmedLine.startsWith("- ")) {
+      state.currentSection = null;
     }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    logError(message);
-    process.exit(1);
   }
+  return Array.from(state.files);
 }
-async function listSingle(id, summary) {
-  const capability = readCapability(id);
-  if (summary) {
-    printJson(capability);
-  } else {
-    const hydrated = await hydrateCapability(capability);
-    printJson(hydrated);
-  }
+function toFileInfo(filePath) {
+  const name = filePath.split("/").pop() || filePath;
+  return { name, path: filePath };
 }
-async function listAll(summary) {
-  const capabilities = readAllCapabilities();
-  if (capabilities.length === 0) {
-    printJson([]);
-    return;
+var PROMPT_PATTERNS = [
+  // 文件覆盖确认 - 回答 n（不覆盖）
+  { pattern: /overwrite/i, answer: "n\n" },
+  // 主题/样式选择 - 回答 n（不安装额外主题）
+  { pattern: /theme/i, answer: "n\n" },
+  { pattern: /style/i, answer: "n\n" },
+  // 继续确认 - 回答 y
+  { pattern: /continue\?/i, answer: "y\n" },
+  { pattern: /proceed\?/i, answer: "y\n" }
+];
+async function executeShadcnAdd(registryItemPath) {
+  return new Promise((resolve2) => {
+    let output = "";
+    const args = ["--yes", "shadcn@3.8.2", "add", registryItemPath];
+    const ptyProcess = pty.spawn("npx", args, {
+      name: "xterm-color",
+      cols: 120,
+      rows: 30,
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        // 禁用颜色输出以便解析
+        NO_COLOR: "1",
+        FORCE_COLOR: "0"
+      }
+    });
+    ptyProcess.onData((data) => {
+      output += data;
+      for (const { pattern, answer } of PROMPT_PATTERNS) {
+        if (pattern.test(data)) {
+          ptyProcess.write(answer);
+          return;
+        }
+      }
+    });
+    const timeoutId = setTimeout(() => {
+      ptyProcess.kill();
+      resolve2({
+        success: false,
+        files: [],
+        error: "\u6267\u884C\u8D85\u65F6"
+      });
+    }, 3 * 60 * 1e3);
+    ptyProcess.onExit(({ exitCode }) => {
+      clearTimeout(timeoutId);
+      const success = exitCode === 0;
+      const filePaths = parseOutput(output);
+      const files = filePaths.map(toFileInfo);
+      resolve2({
+        success,
+        files,
+        error: success ? void 0 : output || `Process exited with code ${exitCode}`
+      });
+    });
+  });
+}
+
+// src/commands/component/add.handler.ts
+function runActionPluginInit() {
+  return new Promise((resolve2) => {
+    execFile("fullstack-cli", ["action-plugin", "init"], { cwd: process.cwd(), stdio: "ignore" }, (error) => {
+      if (error) {
+        debug("action-plugin init \u5931\u8D25: %s", error.message);
+      }
+      resolve2();
+    });
+  });
+}
+function printResult(result) {
+  console.log(JSON.stringify(result, null, 2));
+}
+async function addComponent(key) {
+  debug("\u5F00\u59CB\u5B89\u88C5\u7EC4\u4EF6: %s", key);
+  debug("\u51C6\u5907 registry items...");
+  const registryItemPath = await prepareComponentRegistryItems(key);
+  debug("registry item \u8DEF\u5F84: %s", registryItemPath);
+  const registryItem = getDownloadedRegistryItem(key);
+  debug("\u83B7\u53D6\u5230 registry item: %o", registryItem);
+  debug("\u6267\u884C shadcn add...");
+  const executeResult = await executeShadcnAdd(registryItemPath);
+  debug("shadcn \u6267\u884C\u7ED3\u679C: %o", executeResult);
+  if (!executeResult.success) {
+    throw new Error(executeResult.error || "\u5B89\u88C5\u5931\u8D25\uFF0C\u672A\u77E5\u539F\u56E0");
   }
-  if (summary) {
-    printJson(capabilities);
-  } else {
-    const hydrated = [];
-    for (const capability of capabilities) {
-      const result = await hydrateCapability(capability);
-      hydrated.push(result);
-    }
-    printJson(hydrated);
+  return {
+    success: true,
+    name: key,
+    description: registryItem?.description || "",
+    files: executeResult.files,
+    docs: registryItem?.docs || ""
+  };
+}
+async function add(key) {
+  try {
+    const result = await addComponent(key);
+    printResult(result);
+    void sendInstallEvent(key);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "\u5B89\u88C5\u5931\u8D25\uFF0C\u539F\u56E0\u672A\u77E5";
+    printResult({
+      success: false,
+      errors: [{ message: errorMessage }]
+    });
+  } finally {
+    await runActionPluginInit();
+    cleanupTempDir();
   }
 }
 
-// src/commands/capability/index.ts
-var listCommand2 = {
-  name: "list",
-  description: "List capability configurations",
-  aliases: ["ls"],
+// src/commands/component/index.ts
+var addCommand = {
+  name: "add",
+  description: "\u5B89\u88C5\u5999\u642D\u7EC4\u4EF6\u5E02\u573A\u4E2D\u7684\u7EC4\u4EF6",
   register(program) {
-    program.command(this.name).alias("ls").description(this.description).option("--summary", "Return raw capability config (without hydration)").option("--id <id>", "Specify capability ID").action(async (options) => {
-      await list2(options);
+    program.command(this.name).description(this.description).argument("<component>", "\u7EC4\u4EF6 ID (\u4F8B\u5982 @miaoda/button)").action(async (component) => {
+      await add(component);
     });
   }
 };
-var capabilityCommandGroup = {
-  name: "capability",
-  description: "Manage capability configurations",
-  commands: [listCommand2]
+var componentCommandGroup = {
+  name: "component",
+  description: "\u7EC4\u4EF6\u76F8\u5173\u547D\u4EE4",
+  commands: [addCommand]
 };
 
 // src/commands/migration/version-manager.ts
-import fs10 from "fs";
-import path8 from "path";
+import fs14 from "fs";
+import path12 from "path";
 var PACKAGE_JSON = "package.json";
 var VERSION_FIELD = "migrationVersion";
 function getPackageJsonPath2() {
-  return path8.join(process.cwd(), PACKAGE_JSON);
+  return path12.join(process.cwd(), PACKAGE_JSON);
 }
 function getCurrentVersion() {
   const pkgPath = getPackageJsonPath2();
-  if (!fs10.existsSync(pkgPath)) {
+  if (!fs14.existsSync(pkgPath)) {
     throw new Error("package.json not found");
   }
-  const pkg2 = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
   return pkg2[VERSION_FIELD] ?? 0;
 }
 function setCurrentVersion(version) {
   const pkgPath = getPackageJsonPath2();
-  const pkg2 = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
   pkg2[VERSION_FIELD] = version;
-  fs10.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  fs14.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/detector.ts
-import fs12 from "fs";
-import path10 from "path";
+import fs16 from "fs";
+import path14 from "path";
 
 // src/commands/migration/versions/v001_capability/utils.ts
-import fs11 from "fs";
-import path9 from "path";
+import fs15 from "fs";
+import path13 from "path";
 var CAPABILITIES_DIR2 = "server/capabilities";
 function getProjectRoot3() {
   return process.cwd();
 }
 function getCapabilitiesDir2() {
-  return path9.join(getProjectRoot3(), CAPABILITIES_DIR2);
+  return path13.join(getProjectRoot3(), CAPABILITIES_DIR2);
 }
 function getPluginManifestPath2(pluginKey) {
-  return path9.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
+  return path13.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/detector.ts
 function detectJsonMigration() {
   const capabilitiesDir = getCapabilitiesDir2();
-  const oldFilePath = path10.join(capabilitiesDir, "capabilities.json");
-  if (!fs12.existsSync(oldFilePath)) {
+  const oldFilePath = path14.join(capabilitiesDir, "capabilities.json");
+  if (!fs16.existsSync(oldFilePath)) {
     return {
       needsMigration: false,
       reason: "capabilities.json not found"
     };
   }
   try {
-    const content = fs12.readFileSync(oldFilePath, "utf-8");
+    const content = fs16.readFileSync(oldFilePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!Array.isArray(parsed)) {
       return {
@@ -3141,8 +4592,8 @@ async function check(options) {
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
-import fs13 from "fs";
-import path11 from "path";
+import fs17 from "fs";
+import path15 from "path";
 
 // src/commands/migration/versions/v001_capability/mapping.ts
 var DEFAULT_PLUGIN_VERSION = "1.0.0";
@@ -3372,18 +4823,18 @@ function transformCapabilities(oldCapabilities) {
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
 function loadExistingCapabilities() {
   const capabilitiesDir = getCapabilitiesDir2();
-  if (!fs13.existsSync(capabilitiesDir)) {
+  if (!fs17.existsSync(capabilitiesDir)) {
     return [];
   }
-  const files = fs13.readdirSync(capabilitiesDir);
+  const files = fs17.readdirSync(capabilitiesDir);
   const capabilities = [];
   for (const file of files) {
     if (file === "capabilities.json" || !file.endsWith(".json")) {
       continue;
     }
     try {
-      const filePath = path11.join(capabilitiesDir, file);
-      const content = fs13.readFileSync(filePath, "utf-8");
+      const filePath = path15.join(capabilitiesDir, file);
+      const content = fs17.readFileSync(filePath, "utf-8");
       const capability = JSON.parse(content);
       if (capability.id && capability.pluginKey) {
         capabilities.push(capability);
@@ -3441,9 +4892,9 @@ async function migrateJsonFiles(options) {
   }
   const capabilitiesDir = getCapabilitiesDir2();
   for (const cap of newCapabilities) {
-    const filePath = path11.join(capabilitiesDir, `${cap.id}.json`);
+    const filePath = path15.join(capabilitiesDir, `${cap.id}.json`);
     const content = JSON.stringify(cap, null, 2);
-    fs13.writeFileSync(filePath, content, "utf-8");
+    fs17.writeFileSync(filePath, content, "utf-8");
     console.log(`   \u2713 Created: ${cap.id}.json`);
   }
   return {
@@ -3455,11 +4906,11 @@ async function migrateJsonFiles(options) {
 }
 
 // src/commands/migration/versions/v001_capability/plugin-installer/detector.ts
-import fs14 from "fs";
+import fs18 from "fs";
 function isPluginInstalled2(pluginKey) {
   const actionPlugins = readActionPlugins();
   const manifestPath = getPluginManifestPath2(pluginKey);
-  return fs14.existsSync(manifestPath) && !!actionPlugins[pluginKey];
+  return fs18.existsSync(manifestPath) && !!actionPlugins[pluginKey];
 }
 function detectPluginsToInstall(capabilities) {
   const pluginKeys = /* @__PURE__ */ new Set();
@@ -3535,12 +4986,12 @@ async function installPlugins(capabilities, options) {
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/index.ts
-import path13 from "path";
+import path17 from "path";
 import { Project as Project3 } from "ts-morph";
 
 // src/commands/migration/versions/v001_capability/code-migrator/scanner.ts
-import fs15 from "fs";
-import path12 from "path";
+import fs19 from "fs";
+import path16 from "path";
 var EXCLUDED_DIRS = [
   "node_modules",
   "dist",
@@ -3555,9 +5006,9 @@ var EXCLUDED_PATTERNS = [
   /\.d\.ts$/
 ];
 function scanDirectory(dir, files = []) {
-  const entries = fs15.readdirSync(dir, { withFileTypes: true });
+  const entries = fs19.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path12.join(dir, entry.name);
+    const fullPath = path16.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (EXCLUDED_DIRS.includes(entry.name)) {
         continue;
@@ -3573,14 +5024,14 @@ function scanDirectory(dir, files = []) {
   return files;
 }
 function scanServerFiles() {
-  const serverDir = path12.join(getProjectRoot3(), "server");
-  if (!fs15.existsSync(serverDir)) {
+  const serverDir = path16.join(getProjectRoot3(), "server");
+  if (!fs19.existsSync(serverDir)) {
     return [];
   }
   return scanDirectory(serverDir);
 }
 function hasCapabilityImport(filePath) {
-  const content = fs15.readFileSync(filePath, "utf-8");
+  const content = fs19.readFileSync(filePath, "utf-8");
   return /import\s+.*from\s+['"][^'"]*capabilities[^'"]*['"]/.test(content);
 }
 function scanFilesToMigrate() {
@@ -3957,7 +5408,7 @@ function analyzeFile(project, filePath, actionNameMap) {
   const callSites = analyzeCallSites(sourceFile, imports);
   const classInfo = analyzeClass(sourceFile);
   const { canMigrate, reason } = canAutoMigrate(classInfo);
-  const relativePath = path13.relative(getProjectRoot3(), filePath);
+  const relativePath = path17.relative(getProjectRoot3(), filePath);
   return {
     filePath: relativePath,
     imports,
@@ -3968,7 +5419,7 @@ function analyzeFile(project, filePath, actionNameMap) {
   };
 }
 function migrateFile(project, analysis, dryRun) {
-  const absolutePath = path13.join(getProjectRoot3(), analysis.filePath);
+  const absolutePath = path17.join(getProjectRoot3(), analysis.filePath);
   if (!analysis.canAutoMigrate) {
     return {
       filePath: analysis.filePath,
@@ -4071,17 +5522,17 @@ function getSuggestion(analysis) {
 }
 
 // src/commands/migration/versions/v001_capability/cleanup.ts
-import fs16 from "fs";
-import path14 from "path";
+import fs20 from "fs";
+import path18 from "path";
 function cleanupOldFiles(capabilities, dryRun) {
   const deletedFiles = [];
   const errors = [];
   const capabilitiesDir = getCapabilitiesDir2();
-  const oldJsonPath = path14.join(capabilitiesDir, "capabilities.json");
-  if (fs16.existsSync(oldJsonPath)) {
+  const oldJsonPath = path18.join(capabilitiesDir, "capabilities.json");
+  if (fs20.existsSync(oldJsonPath)) {
     try {
       if (!dryRun) {
-        fs16.unlinkSync(oldJsonPath);
+        fs20.unlinkSync(oldJsonPath);
       }
       deletedFiles.push("capabilities.json");
     } catch (error) {
@@ -4089,11 +5540,11 @@ function cleanupOldFiles(capabilities, dryRun) {
     }
   }
   for (const cap of capabilities) {
-    const tsFilePath = path14.join(capabilitiesDir, `${cap.id}.ts`);
-    if (fs16.existsSync(tsFilePath)) {
+    const tsFilePath = path18.join(capabilitiesDir, `${cap.id}.ts`);
+    if (fs20.existsSync(tsFilePath)) {
       try {
         if (!dryRun) {
-          fs16.unlinkSync(tsFilePath);
+          fs20.unlinkSync(tsFilePath);
         }
         deletedFiles.push(`${cap.id}.ts`);
       } catch (error) {
@@ -4109,8 +5560,8 @@ function cleanupOldFiles(capabilities, dryRun) {
 }
 
 // src/commands/migration/versions/v001_capability/report-generator.ts
-import fs17 from "fs";
-import path15 from "path";
+import fs21 from "fs";
+import path19 from "path";
 var REPORT_FILE = "capability-migration-report.md";
 function printSummary(result) {
   const { jsonMigration, pluginInstallation, codeMigration, cleanup } = result;
@@ -4273,15 +5724,15 @@ async function generateReport(result) {
   }
   lines.push("");
   const logDir = process.env.LOG_DIR || "logs";
-  if (!fs17.existsSync(logDir)) {
+  if (!fs21.existsSync(logDir)) {
     return;
   }
-  const reportDir = path15.join(logDir, "migration");
-  if (!fs17.existsSync(reportDir)) {
-    fs17.mkdirSync(reportDir, { recursive: true });
+  const reportDir = path19.join(logDir, "migration");
+  if (!fs21.existsSync(reportDir)) {
+    fs21.mkdirSync(reportDir, { recursive: true });
   }
-  const reportPath = path15.join(reportDir, REPORT_FILE);
-  fs17.writeFileSync(reportPath, lines.join("\n"), "utf-8");
+  const reportPath = path19.join(reportDir, REPORT_FILE);
+  fs21.writeFileSync(reportPath, lines.join("\n"), "utf-8");
   console.log(`\u{1F4C4} Report generated: ${reportPath}`);
 }
 
@@ -4458,7 +5909,7 @@ function buildResult(jsonMigration, pluginInstallation, codeMigration, cleanup)
 }
 
 // src/commands/migration/versions/v001_capability/run.ts
-async function run3(options) {
+async function run5(options) {
   try {
     const migrationOptions = {
       dryRun: options.dryRun ?? false
@@ -4523,7 +5974,7 @@ var v001CapabilityMigration = {
   name: "capability",
   description: "Migrate capability configurations from old format (capabilities.json array) to new format (individual JSON files)",
   check,
-  run: run3
+  run: run5
 };
 
 // src/commands/migration/versions/index.ts
@@ -4813,10 +6264,10 @@ var migrationCommand = {
 };
 
 // src/commands/read-logs/index.ts
-import path16 from "path";
+import path20 from "path";
 
 // src/commands/read-logs/std-utils.ts
-import fs18 from "fs";
+import fs22 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;
@@ -4846,11 +6297,11 @@ function stripPrefixFromStdLine(line) {
   return `[${time}] ${content}`;
 }
 function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarker) {
-  const stat = fs18.statSync(filePath);
+  const stat = fs22.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], markerFound: false, totalLinesCount: 0 };
   }
-  const fd = fs18.openSync(filePath, "r");
+  const fd = fs22.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -4864,7 +6315,7 @@ function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarke
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs18.readSync(fd, buffer, 0, length, position);
+      fs22.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -4906,7 +6357,7 @@ function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarke
       }
     }
   } finally {
-    fs18.closeSync(fd);
+    fs22.closeSync(fd);
   }
   return { lines: collected.reverse(), markerFound, totalLinesCount };
 }
@@ -4927,21 +6378,21 @@ function readServerStdSegment(filePath, maxLines, offset) {
 }
 
 // src/commands/read-logs/tail.ts
-import fs19 from "fs";
+import fs23 from "fs";
 function fileExists(filePath) {
   try {
-    fs19.accessSync(filePath, fs19.constants.F_OK | fs19.constants.R_OK);
+    fs23.accessSync(filePath, fs23.constants.F_OK | fs23.constants.R_OK);
     return true;
   } catch {
     return false;
   }
 }
 function readFileTailLines(filePath, maxLines) {
-  const stat = fs19.statSync(filePath);
+  const stat = fs23.statSync(filePath);
   if (stat.size === 0) {
     return [];
   }
-  const fd = fs19.openSync(filePath, "r");
+  const fd = fs23.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   const chunks = [];
   let position = stat.size;
@@ -4951,13 +6402,13 @@ function readFileTailLines(filePath, maxLines) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs19.readSync(fd, buffer, 0, length, position);
+      fs23.readSync(fd, buffer, 0, length, position);
       chunks.unshift(buffer.toString("utf8"));
       const chunkLines = buffer.toString("utf8").split("\n").length - 1;
       collectedLines += chunkLines;
     }
   } finally {
-    fs19.closeSync(fd);
+    fs23.closeSync(fd);
   }
   const content = chunks.join("");
   const allLines = content.split("\n");
@@ -4973,11 +6424,11 @@ function readFileTailLines(filePath, maxLines) {
   return allLines.slice(allLines.length - maxLines);
 }
 function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
-  const stat = fs19.statSync(filePath);
+  const stat = fs23.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs19.openSync(filePath, "r");
+  const fd = fs23.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -4989,7 +6440,7 @@ function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs19.readSync(fd, buffer, 0, length, position);
+      fs23.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -5020,7 +6471,7 @@ function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
       }
     }
   } finally {
-    fs19.closeSync(fd);
+    fs23.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -5033,13 +6484,19 @@ function readClientStdSegment(filePath, maxLines, offset) {
 function extractClientStdSegment(lines, maxLines, offset) {
   const bodyLines = lines.map(stripPrefixFromStdLine);
   const hotStartMarkers = [
+    // Webpack markers
     /file change detected\..*incremental compilation/i,
     /starting incremental compilation/i,
     /starting compilation/i,
     /\bcompiling\b/i,
-    /\brecompil/i
+    /\brecompil/i,
+    // Vite markers - format: "3:11:46 PM [vite] (client) hmr update ..."
+    /VITE v[\d.]+.*ready/i,
+    /\[vite\].*page reload/i,
+    /\[vite\].*hmr update/i
   ];
   const hotEndMarkers = [
+    // Webpack markers
     /file change detected\..*incremental compilation/i,
     /\bwebpack compiled\b/i,
     /compiled successfully/i,
@@ -5050,14 +6507,25 @@ function extractClientStdSegment(lines, maxLines, offset) {
     /\bhmr\b/i,
     /hot update/i,
     /\bhot reload\b/i,
-    /\bhmr update\b/i
+    /\bhmr update\b/i,
+    // Vite markers
+    /VITE v[\d.]+.*ready/i,
+    /\[vite\].*page reload/i,
+    /\[vite\].*hmr update/i,
+    /\[vite\].*hmr invalidate/i,
+    /\[vite\].*internal server error/i,
+    /\[vite\].*pre-transform error/i
   ];
   const compiledMarkers = [
+    // Webpack markers
     /\bwebpack compiled\b/i,
     /compiled successfully/i,
     /compiled with warnings/i,
     /compiled with errors/i,
-    /failed to compile/i
+    /failed to compile/i,
+    // Vite markers
+    /VITE v[\d.]+.*ready/i,
+    /\[vite\].*hmr update/i
   ];
   let startIndex = -1;
   for (let i = bodyLines.length - 1; i >= 0; i -= 1) {
@@ -5110,19 +6578,42 @@ function extractClientStdSegment(lines, maxLines, offset) {
   }
   const segment = startIndex === -1 ? bodyLines : bodyLines.slice(startIndex);
   if (segment.length === 0) {
-    return { lines: [], totalLinesCount: 0 };
+    return { lines: [], totalLinesCount: 0, allLines: [] };
   }
   const totalLinesCount = segment.length;
   const endExclusive = Math.max(0, segment.length - offset);
   const start = Math.max(0, endExclusive - maxLines);
   return {
     lines: segment.slice(start, endExclusive),
-    totalLinesCount
+    totalLinesCount,
+    allLines: segment
+  };
+}
+
+// src/commands/read-logs/dev.ts
+function readDevSegment(filePath, maxLines, offset) {
+  const marker = (line) => {
+    if (!line) return false;
+    if (line.includes("Dev session started")) return true;
+    return false;
+  };
+  const segment = readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, marker);
+  return { lines: segment.lines, totalLinesCount: segment.totalLinesCount };
+}
+
+// src/commands/read-logs/dev-std.ts
+function readDevStdSegment(filePath, maxLines, offset) {
+  const marker = (line) => {
+    if (!line) return false;
+    if (line.includes("Dev session started")) return true;
+    return false;
   };
+  const segment = readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, marker);
+  return { lines: segment.lines, totalLinesCount: segment.totalLinesCount };
 }
 
 // src/commands/read-logs/json-lines.ts
-import fs20 from "fs";
+import fs24 from "fs";
 function normalizePid(value) {
   if (typeof value === "number") {
     return String(value);
@@ -5173,11 +6664,11 @@ function buildWantedLevelSet(levels) {
   return set.size > 0 ? set : null;
 }
 function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
-  const stat = fs20.statSync(filePath);
+  const stat = fs24.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs20.openSync(filePath, "r");
+  const fd = fs24.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -5192,7 +6683,7 @@ function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs20.readSync(fd, buffer, 0, length, position);
+      fs24.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -5254,7 +6745,7 @@ function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs20.closeSync(fd);
+    fs24.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -5297,11 +6788,11 @@ function extractTraceId(obj) {
 function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
   const wanted = traceId.trim();
   if (!wanted) return { lines: [], totalLinesCount: 0 };
-  const stat = fs20.statSync(filePath);
+  const stat = fs24.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs20.openSync(filePath, "r");
+  const fd = fs24.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -5314,7 +6805,7 @@ function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs20.readSync(fd, buffer, 0, length, position);
+      fs24.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -5367,7 +6858,7 @@ function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs20.closeSync(fd);
+    fs24.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -5376,11 +6867,11 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
   if (!wantedLevelSet) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const stat = fs20.statSync(filePath);
+  const stat = fs24.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs20.openSync(filePath, "r");
+  const fd = fs24.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -5392,7 +6883,7 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs20.readSync(fd, buffer, 0, length, position);
+      fs24.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -5439,13 +6930,13 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs20.closeSync(fd);
+    fs24.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
 
 // src/commands/read-logs/index.ts
-var LOG_TYPES = ["server", "trace", "server-std", "client-std", "browser"];
+var LOG_TYPES = ["server", "trace", "server-std", "client-std", "dev", "dev-std", "install-dep-std", "browser"];
 function normalizeObjectKey(key) {
   return key.toLowerCase().replace(/_/g, "");
 }
@@ -5607,6 +7098,15 @@ async function readLatestLogLinesMeta(options) {
   if (options.type === "client-std") {
     return readClientStdSegment(filePath, maxLines, offset);
   }
+  if (options.type === "dev") {
+    return readDevSegment(filePath, maxLines, offset);
+  }
+  if (options.type === "dev-std") {
+    return readDevStdSegment(filePath, maxLines, offset);
+  }
+  if (options.type === "install-dep-std") {
+    return readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset);
+  }
   const traceId = typeof options.traceId === "string" ? options.traceId.trim() : "";
   if (traceId) {
     return readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels);
@@ -5623,12 +7123,21 @@ async function readLatestLogLinesMeta(options) {
   return { lines: [], totalLinesCount: 0 };
 }
 async function readLogsJsonResult(options) {
-  const { lines, totalLinesCount } = await readLatestLogLinesMeta(options);
-  if (options.type === "server-std" || options.type === "client-std") {
+  const { lines, totalLinesCount, allLines } = await readLatestLogLinesMeta(options);
+  if (options.type === "server-std" || options.type === "client-std" || options.type === "dev" || options.type === "dev-std" || options.type === "install-dep-std") {
+    const linesForErrorCheck = allLines ?? lines;
+    const stackTracePattern = /\bat\s+\S+\s+\([^)]+:\d+:\d+\)/;
+    const linesToFilter = allLines ?? lines;
+    const filteredLines = linesToFilter.filter((line) => !stackTracePattern.test(line));
+    const maxLines = options.maxLines ?? 30;
+    const offset = options.offset ?? 0;
+    const endExclusive = Math.max(0, filteredLines.length - offset);
+    const start = Math.max(0, endExclusive - maxLines);
+    const paginatedLogs = filteredLines.slice(start, endExclusive);
     return {
-      hasError: hasErrorInStdLines(lines),
-      totalLinesCount,
-      logs: lines
+      hasError: hasErrorInStdLines(linesForErrorCheck),
+      totalLinesCount: filteredLines.length,
+      logs: paginatedLogs
     };
   }
   const logs = [];
@@ -5655,25 +7164,34 @@ async function readLogsJsonResult(options) {
   };
 }
 function resolveLogFilePath(logDir, type) {
-  const base = path16.isAbsolute(logDir) ? logDir : path16.join(process.cwd(), logDir);
+  const base = path20.isAbsolute(logDir) ? logDir : path20.join(process.cwd(), logDir);
   if (type === "server") {
-    return path16.join(base, "server.log");
+    return path20.join(base, "server.log");
   }
   if (type === "trace") {
-    return path16.join(base, "trace.log");
+    return path20.join(base, "trace.log");
   }
   if (type === "server-std") {
-    return path16.join(base, "server.std.log");
+    return path20.join(base, "server.std.log");
   }
   if (type === "client-std") {
-    return path16.join(base, "client.std.log");
+    return path20.join(base, "client.std.log");
+  }
+  if (type === "dev") {
+    return path20.join(base, "dev.log");
+  }
+  if (type === "dev-std") {
+    return path20.join(base, "dev.std.log");
+  }
+  if (type === "install-dep-std") {
+    return path20.join(base, "install-dep.std.log");
   }
   if (type === "browser") {
-    return path16.join(base, "browser.log");
+    return path20.join(base, "browser.log");
   }
   throw new Error(`Unsupported log type: ${type}`);
 }
-async function run4(options) {
+async function run6(options) {
   const result = await readLogsJsonResult(options);
   process.stdout.write(JSON.stringify(result) + "\n");
 }
@@ -5715,7 +7233,7 @@ var readLogsCommand = {
         const offset = parseNonNegativeInt(rawOptions.offset, "--offset");
         const traceId = typeof rawOptions.traceId === "string" ? rawOptions.traceId : void 0;
         const levels = parseCommaSeparatedList(rawOptions.level);
-        await run4({ logDir, type, maxLines, offset, traceId, levels });
+        await run6({ logDir, type, maxLines, offset, traceId, levels });
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         process.stderr.write(message + "\n");
@@ -5725,23 +7243,342 @@ var readLogsCommand = {
   }
 };
 
+// src/commands/build/types.ts
+var SCENE_CONFIGS = {
+  pipeline: {
+    name: "pipeline",
+    requiredOptions: ["commitId"],
+    buildRequestBody: (opts) => ({ commitID: opts.commitId })
+  },
+  static: {
+    name: "static",
+    requiredOptions: [],
+    buildRequestBody: () => ({ commitID: "" })
+  }
+};
+var UPLOAD_STATIC_DEFAULTS = {
+  staticDir: "shared/static",
+  tosutilPath: "tosutil",
+  endpoint: "tos-cn-beijing.volces.com",
+  region: "cn-beijing"
+};
+
+// src/commands/build/api-client.ts
+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);
+  if (!response.ok || response.status !== 200) {
+    throw new Error(
+      `gen_artifact_upload_credential \u8BF7\u6C42\u5931\u8D25: ${response.status} ${response.statusText}`
+    );
+  }
+  return response.json();
+}
+async function getDefaultBucketId(appId) {
+  const client = getHttpClient();
+  const url = `/v1/app/${appId}/storage/inner/staticBucket`;
+  const response = await client.post(url, {});
+  if (!response.ok || response.status !== 200) {
+    throw new Error(
+      `getOrCreateStaticBucket \u8BF7\u6C42\u5931\u8D25: ${response.status} ${response.statusText}`
+    );
+  }
+  const data = await response.json();
+  if (data.status_code !== "0") {
+    throw new Error(`getOrCreateStaticBucket \u8FD4\u56DE\u5F02\u5E38, status_code: ${data.status_code}`);
+  }
+  const bucketId = data?.data?.bucketID;
+  if (!bucketId) {
+    throw new Error(`\u672A\u627E\u5230\u5E94\u7528 ${appId} \u7684\u9759\u6001\u8D44\u6E90\u5B58\u50A8\u6876`);
+  }
+  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, {});
+  if (!response.ok || response.status !== 200) {
+    throw new Error(
+      `preUploadStatic \u8BF7\u6C42\u5931\u8D25: ${response.status} ${response.statusText}`
+    );
+  }
+  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);
+  if (!response.ok || response.status !== 200) {
+    throw new Error(
+      `callbackStatic \u8BF7\u6C42\u5931\u8D25: ${response.status} ${response.statusText}`
+    );
+  }
+  return response.json();
+}
+
+// src/commands/build/get-token.handler.ts
+async function getToken(options) {
+  try {
+    const sceneConfig = SCENE_CONFIGS[options.scene];
+    if (!sceneConfig) {
+      const available = Object.keys(SCENE_CONFIGS).join(", ");
+      console.error(
+        `[build] Error: invalid scene "${options.scene}". Available scenes: ${available}`
+      );
+      process.exit(1);
+    }
+    for (const key of sceneConfig.requiredOptions) {
+      if (!options[key]) {
+        console.error(
+          `[build] Error: --${camelToKebab(key)} is required for scene "${options.scene}"`
+        );
+        process.exit(1);
+      }
+    }
+    const body = sceneConfig.buildRequestBody(options);
+    const response = await genArtifactUploadCredential(options.appId, body);
+    console.log(JSON.stringify(response));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[build] Error: ${message}`);
+    process.exit(1);
+  }
+}
+function camelToKebab(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+
+// src/commands/build/upload-static.handler.ts
+import * as fs25 from "fs";
+import * as path21 from "path";
+import { execFileSync } from "child_process";
+function readCredentialsFromEnv() {
+  const uploadPrefix = process.env.STATIC_UPLOAD_PREFIX;
+  const uploadID = process.env.STATIC_UPLOAD_ID;
+  const bucketId = process.env.STATIC_UPLOAD_BUCKET_ID;
+  const accessKeyID = process.env.STATIC_UPLOAD_AK;
+  const secretAccessKey = process.env.STATIC_UPLOAD_SK;
+  const sessionToken = process.env.STATIC_UPLOAD_TOKEN;
+  if (!uploadPrefix || !uploadID || !bucketId || !accessKeyID || !secretAccessKey || !sessionToken) {
+    return null;
+  }
+  return { uploadPrefix, uploadID, bucketId, accessKeyID, secretAccessKey, sessionToken };
+}
+var LOG_PREFIX = "[upload-static]";
+async function uploadStatic(options) {
+  try {
+    const {
+      appId,
+      staticDir = UPLOAD_STATIC_DEFAULTS.staticDir,
+      tosutilPath = UPLOAD_STATIC_DEFAULTS.tosutilPath,
+      endpoint = UPLOAD_STATIC_DEFAULTS.endpoint,
+      region = UPLOAD_STATIC_DEFAULTS.region
+    } = options;
+    const resolvedStaticDir = path21.resolve(staticDir);
+    if (!fs25.existsSync(resolvedStaticDir)) {
+      console.error(`${LOG_PREFIX} \u76EE\u5F55\u4E0D\u5B58\u5728: ${resolvedStaticDir}\uFF0C\u8DF3\u8FC7\u4E0A\u4F20`);
+      return;
+    }
+    if (isDirEmpty(resolvedStaticDir)) {
+      console.error(`${LOG_PREFIX} \u76EE\u5F55\u4E3A\u7A7A: ${resolvedStaticDir}\uFF0C\u8DF3\u8FC7\u4E0A\u4F20`);
+      return;
+    }
+    const resolvedTosutil = resolveTosutilPath(tosutilPath);
+    if (!resolvedTosutil) {
+      throw new Error(
+        `tosutil \u4E0D\u5B58\u5728: ${tosutilPath}\u3002\u8BF7\u786E\u4FDD tosutil \u5DF2\u5B89\u88C5\u5728\u7CFB\u7EDF PATH \u4E2D\u6216\u901A\u8FC7 --tosutil-path \u6307\u5B9A\u8DEF\u5F84\u3002`
+      );
+    }
+    let uploadPrefix;
+    let uploadID;
+    let bucketId;
+    let accessKeyID;
+    let secretAccessKey;
+    let sessionToken;
+    const envCredentials = readCredentialsFromEnv();
+    if (envCredentials) {
+      console.error(`${LOG_PREFIX} \u4F7F\u7528\u73AF\u5883\u53D8\u91CF\u4E2D\u7684\u4E0A\u4F20\u51ED\u8BC1`);
+      ({ uploadPrefix, uploadID, bucketId, accessKeyID, secretAccessKey, sessionToken } = envCredentials);
+    } else {
+      console.error(`${LOG_PREFIX} \u73AF\u5883\u53D8\u91CF\u672A\u8BBE\u7F6E\uFF0C\u8C03\u7528 preUploadStatic...`);
+      bucketId = await resolveBucketId(appId);
+      const preUploadResp = await fetchPreUpload(appId, bucketId);
+      const { uploadCredential } = preUploadResp.data;
+      ({ uploadPrefix, uploadID } = preUploadResp.data);
+      ({ AccessKeyID: accessKeyID, SecretAccessKey: secretAccessKey, SessionToken: sessionToken } = uploadCredential);
+    }
+    console.error(`${LOG_PREFIX} \u4E0A\u4F20\u76EE\u6807: ${uploadPrefix}`);
+    console.error(`${LOG_PREFIX} \u914D\u7F6E tosutil...`);
+    configureTosutil(resolvedTosutil, {
+      endpoint,
+      region,
+      accessKeyID,
+      secretAccessKey,
+      sessionToken
+    });
+    console.error(`${LOG_PREFIX} \u4E0A\u4F20 ${resolvedStaticDir} -> ${uploadPrefix}`);
+    uploadToTos(resolvedTosutil, resolvedStaticDir, uploadPrefix);
+    console.error(`${LOG_PREFIX} tosutil \u4E0A\u4F20\u5B8C\u6210`);
+    console.error(`${LOG_PREFIX} \u8C03\u7528 callbackStatic (uploadID: ${uploadID})...`);
+    const callbackResp = await uploadStaticAttachmentCallback(appId, bucketId, { uploadID });
+    if (callbackResp.status_code !== "0") {
+      throw new Error(`callbackStatic \u8FD4\u56DE\u5F02\u5E38, status_code: ${callbackResp.status_code}`);
+    }
+    const attachments = callbackResp.data?.attachments || [];
+    console.error(`${LOG_PREFIX} \u4E0A\u4F20\u5B8C\u6210\uFF0C\u5171 ${attachments.length} \u4E2A\u6587\u4EF6`);
+    console.log(JSON.stringify(callbackResp));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`${LOG_PREFIX} Error: ${message}`);
+    process.exit(1);
+  }
+}
+function resolveTosutilPath(tosutilPath) {
+  if (path21.isAbsolute(tosutilPath)) {
+    return fs25.existsSync(tosutilPath) ? tosutilPath : null;
+  }
+  try {
+    const resolved = execFileSync("which", [tosutilPath], { encoding: "utf-8" }).trim();
+    return resolved || null;
+  } catch {
+    return null;
+  }
+}
+async function fetchPreUpload(appId, bucketId) {
+  const response = await preUploadStaticAttachment(appId, bucketId);
+  if (response.status_code !== "0") {
+    throw new Error(`preUploadStatic \u8FD4\u56DE\u5F02\u5E38, status_code: ${response.status_code}`);
+  }
+  const { uploadPrefix, uploadID, uploadCredential } = response.data || {};
+  if (!uploadPrefix || !uploadID) {
+    throw new Error("preUploadStatic \u8FD4\u56DE\u6570\u636E\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11 uploadPrefix \u6216 uploadID");
+  }
+  if (!uploadCredential?.AccessKeyID || !uploadCredential?.SecretAccessKey || !uploadCredential?.SessionToken) {
+    throw new Error("preUploadStatic \u8FD4\u56DE\u7684\u51ED\u8BC1\u5B57\u6BB5\u4E0D\u5B8C\u6574");
+  }
+  return response;
+}
+function configureTosutil(tosutilPath, config) {
+  const { endpoint, region, accessKeyID, secretAccessKey, sessionToken } = config;
+  execFileSync(
+    tosutilPath,
+    ["config", "-e", endpoint, "-i", accessKeyID, "-k", secretAccessKey, "-t", sessionToken, "-re", region],
+    { stdio: "pipe" }
+  );
+}
+function uploadToTos(tosutilPath, sourceDir, destUrl) {
+  execFileSync(
+    tosutilPath,
+    ["cp", sourceDir, destUrl, "-r", "-flat", "-j", "5", "-p", "3", "-ps", "10485760", "-f"],
+    { stdio: "inherit" }
+  );
+}
+async function resolveBucketId(appId) {
+  console.error(`${LOG_PREFIX} \u83B7\u53D6\u9ED8\u8BA4\u5B58\u50A8\u6876...`);
+  const bucketId = await getDefaultBucketId(appId);
+  console.error(`${LOG_PREFIX} \u9ED8\u8BA4\u5B58\u50A8\u6876: ${bucketId}`);
+  return bucketId;
+}
+function isDirEmpty(dirPath) {
+  const entries = fs25.readdirSync(dirPath);
+  return entries.length === 0;
+}
+
+// src/commands/build/pre-upload-static.handler.ts
+var LOG_PREFIX2 = "[pre-upload-static]";
+function shellEscape(value) {
+  return value.replace(/["\\`$]/g, "\\$&");
+}
+async function preUploadStatic(options) {
+  try {
+    const { appId } = options;
+    console.error(`${LOG_PREFIX2} \u83B7\u53D6\u9ED8\u8BA4\u5B58\u50A8\u6876...`);
+    const bucketId = await getDefaultBucketId(appId);
+    console.error(`${LOG_PREFIX2} \u9ED8\u8BA4\u5B58\u50A8\u6876: ${bucketId}`);
+    console.error(`${LOG_PREFIX2} \u8C03\u7528 preUploadStatic...`);
+    const response = await preUploadStaticAttachment(appId, bucketId);
+    if (response.status_code !== "0") {
+      console.error(`${LOG_PREFIX2} preUploadStatic \u8FD4\u56DE\u5F02\u5E38, status_code: ${response.status_code}`);
+      return;
+    }
+    const { downloadURLPrefix, uploadPrefix, uploadID, uploadCredential } = response.data || {};
+    if (!downloadURLPrefix || !uploadPrefix || !uploadID) {
+      console.error(`${LOG_PREFIX2} preUploadStatic \u8FD4\u56DE\u6570\u636E\u4E0D\u5B8C\u6574`);
+      return;
+    }
+    if (!uploadCredential?.AccessKeyID || !uploadCredential?.SecretAccessKey || !uploadCredential?.SessionToken) {
+      console.error(`${LOG_PREFIX2} preUploadStatic \u8FD4\u56DE\u7684\u51ED\u8BC1\u5B57\u6BB5\u4E0D\u5B8C\u6574`);
+      return;
+    }
+    console.log(`export STATIC_ASSETS_BASE_URL="${shellEscape(downloadURLPrefix)}"`);
+    console.log(`export STATIC_UPLOAD_PREFIX="${shellEscape(uploadPrefix)}"`);
+    console.log(`export STATIC_UPLOAD_ID="${shellEscape(uploadID)}"`);
+    console.log(`export STATIC_UPLOAD_AK="${shellEscape(uploadCredential.AccessKeyID)}"`);
+    console.log(`export STATIC_UPLOAD_SK="${shellEscape(uploadCredential.SecretAccessKey)}"`);
+    console.log(`export STATIC_UPLOAD_TOKEN="${shellEscape(uploadCredential.SessionToken)}"`);
+    console.log(`export STATIC_UPLOAD_BUCKET_ID="${shellEscape(bucketId)}"`);
+    console.error(`${LOG_PREFIX2} \u73AF\u5883\u53D8\u91CF\u5DF2\u8F93\u51FA`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`${LOG_PREFIX2} Warning: ${message}`);
+  }
+}
+
+// src/commands/build/index.ts
+var getTokenCommand = {
+  name: "get-token",
+  description: "Get artifact upload credential (STI token)",
+  register(program) {
+    program.command(this.name).description(this.description).requiredOption("--app-id <id>", "Application ID").requiredOption("--scene <scene>", "Build scene (pipeline, static)").option("--commit-id <id>", "Git commit ID (required for pipeline scene)").action(async (options) => {
+      await getToken(options);
+    });
+  }
+};
+var uploadStaticCommand = {
+  name: "upload-static",
+  description: "Upload shared/static files to TOS",
+  register(program) {
+    program.command(this.name).description(this.description).requiredOption("--app-id <id>", "Application ID").option("--static-dir <dir>", "Static files directory", UPLOAD_STATIC_DEFAULTS.staticDir).option("--tosutil-path <path>", "Path to tosutil binary", UPLOAD_STATIC_DEFAULTS.tosutilPath).option("--endpoint <endpoint>", "TOS endpoint", UPLOAD_STATIC_DEFAULTS.endpoint).option("--region <region>", "TOS region", UPLOAD_STATIC_DEFAULTS.region).action(async (options) => {
+      await uploadStatic(options);
+    });
+  }
+};
+var preUploadStaticCommand = {
+  name: "pre-upload-static",
+  description: "Get TOS upload info and output as env vars for build.sh eval",
+  register(program) {
+    program.command(this.name).description(this.description).requiredOption("--app-id <id>", "Application ID").action(async (options) => {
+      await preUploadStatic(options);
+    });
+  }
+};
+var buildCommandGroup = {
+  name: "build",
+  description: "Build related commands",
+  commands: [getTokenCommand, uploadStaticCommand, preUploadStaticCommand]
+};
+
 // src/commands/index.ts
 var commands = [
   genDbSchemaCommand,
   syncCommand,
+  upgradeCommand,
   actionPluginCommandGroup,
   capabilityCommandGroup,
+  componentCommandGroup,
   migrationCommand,
-  readLogsCommand
+  readLogsCommand,
+  buildCommandGroup
 ];
 
 // src/index.ts
-var envPath = path17.join(process.cwd(), ".env");
-if (fs21.existsSync(envPath)) {
+var envPath = path22.join(process.cwd(), ".env");
+if (fs26.existsSync(envPath)) {
   dotenvConfig({ path: envPath });
 }
-var __dirname = path17.dirname(fileURLToPath4(import.meta.url));
-var pkg = JSON.parse(fs21.readFileSync(path17.join(__dirname, "../package.json"), "utf-8"));
+var __dirname = path22.dirname(fileURLToPath5(import.meta.url));
+var pkg = JSON.parse(fs26.readFileSync(path22.join(__dirname, "../package.json"), "utf-8"));
 var cli = new FullstackCLI(pkg.version);
 cli.useAll(commands);
 cli.run();