@lark-apaas/fullstack-cli 1.1.22-alpha.6 → 1.1.22-alpha.8

package/dist/index.js

@@ -1,7 +1,7 @@
 // src/index.ts
-import fs25 from "fs";
-import path21 from "path";
-import { fileURLToPath as fileURLToPath5 } from "url";
+import fs22 from "fs";
+import path18 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 import { config as dotenvConfig } from "dotenv";
 
 // src/cli.ts
@@ -2419,357 +2419,10 @@ var syncCommand = {
   }
 };
 
-// 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/utils/git.ts
-import { execSync, spawnSync as spawnSync2 } from "child_process";
+// src/commands/action-plugin/utils.ts
 import fs7 from "fs";
 import path5 from "path";
-function isGitRepository(cwd = process.cwd()) {
-  try {
-    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 {
-    return false;
-  }
-}
-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 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);
-    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 v${version}`;
-    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") {
-      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";
+import { spawnSync as spawnSync2, execSync } from "child_process";
 function parsePluginName(input) {
   const match = input.match(/^(@[^/]+\/[^@]+)(?:@(.+))?$/);
   if (!match) {
@@ -2786,35 +2439,35 @@ function getProjectRoot() {
   return process.cwd();
 }
 function getPackageJsonPath() {
-  return path8.join(getProjectRoot(), "package.json");
+  return path5.join(getProjectRoot(), "package.json");
 }
 function getPluginPath(pluginName) {
-  return path8.join(getProjectRoot(), "node_modules", pluginName);
+  return path5.join(getProjectRoot(), "node_modules", pluginName);
 }
-function readPackageJson2() {
+function readPackageJson() {
   const pkgPath = getPackageJsonPath();
-  if (!fs10.existsSync(pkgPath)) {
+  if (!fs7.existsSync(pkgPath)) {
     throw new Error("package.json not found in current directory");
   }
   try {
-    const content = fs10.readFileSync(pkgPath, "utf-8");
+    const content = fs7.readFileSync(pkgPath, "utf-8");
     return JSON.parse(content);
   } catch {
     throw new Error("Failed to parse package.json");
   }
 }
-function writePackageJson2(pkg2) {
+function writePackageJson(pkg2) {
   const pkgPath = getPackageJsonPath();
-  fs10.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  fs7.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
 }
 function readActionPlugins() {
-  const pkg2 = readPackageJson2();
+  const pkg2 = readPackageJson();
   return pkg2.actionPlugins || {};
 }
 function writeActionPlugins(plugins) {
-  const pkg2 = readPackageJson2();
+  const pkg2 = readPackageJson();
   pkg2.actionPlugins = plugins;
-  writePackageJson2(pkg2);
+  writePackageJson(pkg2);
 }
 function isPluginInstalled(pluginName) {
   const plugins = readActionPlugins();
@@ -2826,7 +2479,7 @@ function getInstalledPluginVersion(pluginName) {
 }
 function npmInstall(tgzPath) {
   console.log(`[action-plugin] Running npm install ${tgzPath}...`);
-  const result = spawnSync4("npm", ["install", tgzPath, "--no-save", "--no-package-lock", "--ignore-scripts"], {
+  const result = spawnSync2("npm", ["install", tgzPath, "--no-save", "--no-package-lock", "--ignore-scripts"], {
     cwd: getProjectRoot(),
     stdio: "inherit"
   });
@@ -2838,12 +2491,12 @@ function npmInstall(tgzPath) {
   }
 }
 function getPackageVersion(pluginName) {
-  const pkgJsonPath = path8.join(getPluginPath(pluginName), "package.json");
-  if (!fs10.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path5.join(getPluginPath(pluginName), "package.json");
+  if (!fs7.existsSync(pkgJsonPath)) {
     return null;
   }
   try {
-    const content = fs10.readFileSync(pkgJsonPath, "utf-8");
+    const content = fs7.readFileSync(pkgJsonPath, "utf-8");
     const pkg2 = JSON.parse(content);
     return pkg2.version || null;
   } catch {
@@ -2851,49 +2504,49 @@ function getPackageVersion(pluginName) {
   }
 }
 function readPluginPackageJson(pluginPath) {
-  const pkgJsonPath = path8.join(pluginPath, "package.json");
-  if (!fs10.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path5.join(pluginPath, "package.json");
+  if (!fs7.existsSync(pkgJsonPath)) {
     return null;
   }
   try {
-    const content = fs10.readFileSync(pkgJsonPath, "utf-8");
+    const content = fs7.readFileSync(pkgJsonPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function extractTgzToNodeModules(tgzPath, pluginName) {
-  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 });
+  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 });
   }
-  if (fs10.existsSync(targetDir)) {
-    fs10.rmSync(targetDir, { recursive: true });
+  if (fs7.existsSync(targetDir)) {
+    fs7.rmSync(targetDir, { recursive: true });
   }
-  const tempDir = path8.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
-  if (fs10.existsSync(tempDir)) {
-    fs10.rmSync(tempDir, { recursive: true });
+  const tempDir = path5.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
+  if (fs7.existsSync(tempDir)) {
+    fs7.rmSync(tempDir, { recursive: true });
   }
-  fs10.mkdirSync(tempDir, { recursive: true });
+  fs7.mkdirSync(tempDir, { recursive: true });
   try {
-    execSync2(`tar -xzf "${tgzPath}" -C "${tempDir}"`, { stdio: "pipe" });
-    const extractedDir = path8.join(tempDir, "package");
-    if (fs10.existsSync(extractedDir)) {
-      fs10.renameSync(extractedDir, targetDir);
+    execSync(`tar -xzf "${tgzPath}" -C "${tempDir}"`, { stdio: "pipe" });
+    const extractedDir = path5.join(tempDir, "package");
+    if (fs7.existsSync(extractedDir)) {
+      fs7.renameSync(extractedDir, targetDir);
     } else {
-      const files = fs10.readdirSync(tempDir);
+      const files = fs7.readdirSync(tempDir);
       if (files.length === 1) {
-        fs10.renameSync(path8.join(tempDir, files[0]), targetDir);
+        fs7.renameSync(path5.join(tempDir, files[0]), targetDir);
       } else {
         throw new Error("Unexpected tgz structure");
       }
     }
     return targetDir;
   } finally {
-    if (fs10.existsSync(tempDir)) {
-      fs10.rmSync(tempDir, { recursive: true });
+    if (fs7.existsSync(tempDir)) {
+      fs7.rmSync(tempDir, { recursive: true });
     }
   }
 }
@@ -2902,10 +2555,10 @@ function checkMissingPeerDeps(peerDeps) {
     return [];
   }
   const missing = [];
-  const nodeModulesPath = path8.join(getProjectRoot(), "node_modules");
+  const nodeModulesPath = path5.join(getProjectRoot(), "node_modules");
   for (const [depName, _version] of Object.entries(peerDeps)) {
-    const depPath = path8.join(nodeModulesPath, depName);
-    if (!fs10.existsSync(depPath)) {
+    const depPath = path5.join(nodeModulesPath, depName);
+    if (!fs7.existsSync(depPath)) {
       missing.push(depName);
     }
   }
@@ -2916,7 +2569,7 @@ function installMissingDeps(deps) {
     return;
   }
   console.log(`[action-plugin] Installing missing dependencies: ${deps.join(", ")}`);
-  const result = spawnSync4("npm", ["install", ...deps, "--no-save", "--no-package-lock"], {
+  const result = spawnSync2("npm", ["install", ...deps, "--no-save", "--no-package-lock"], {
     cwd: getProjectRoot(),
     stdio: "inherit"
   });
@@ -2929,16 +2582,84 @@ function installMissingDeps(deps) {
 }
 function removePluginDirectory(pluginName) {
   const pluginPath = getPluginPath(pluginName);
-  if (fs10.existsSync(pluginPath)) {
-    fs10.rmSync(pluginPath, { recursive: true });
+  if (fs7.existsSync(pluginPath)) {
+    fs7.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 fs11 from "fs";
-import path9 from "path";
+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/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;
+  }
+}
+async function reportInstallEvent(pluginKey, version) {
+  await reportEvents([
+    {
+      resourceType: "plugin",
+      resourceKey: pluginKey,
+      eventType: "install",
+      details: { version }
+    }
+  ]);
+}
+async function reportCreateInstanceEvent(pluginKey, version) {
+  await reportEvents([
+    {
+      resourceType: "plugin",
+      resourceKey: pluginKey,
+      eventType: "create_instance",
+      details: { version }
+    }
+  ]);
+}
+
+// src/commands/action-plugin/api-client.ts
 var PLUGIN_CACHE_DIR = "node_modules/.cache/fullstack-cli/plugins";
 async function getPluginVersions(keys, latestOnly = true) {
   const client = getHttpClient();
@@ -3002,19 +2723,19 @@ async function downloadFromPublic(downloadURL) {
   return Buffer.from(arrayBuffer);
 }
 function getPluginCacheDir() {
-  return path9.join(process.cwd(), PLUGIN_CACHE_DIR);
+  return path6.join(process.cwd(), PLUGIN_CACHE_DIR);
 }
 function ensureCacheDir() {
   const cacheDir = getPluginCacheDir();
-  if (!fs11.existsSync(cacheDir)) {
-    fs11.mkdirSync(cacheDir, { recursive: true });
+  if (!fs8.existsSync(cacheDir)) {
+    fs8.mkdirSync(cacheDir, { recursive: true });
   }
 }
 function getTempFilePath(pluginKey, version) {
   ensureCacheDir();
   const safeKey = pluginKey.replace(/[/@]/g, "_");
   const filename = `${safeKey}@${version}.tgz`;
-  return path9.join(getPluginCacheDir(), filename);
+  return path6.join(getPluginCacheDir(), filename);
 }
 var MAX_RETRIES = 2;
 async function withRetry(operation, description, maxRetries = MAX_RETRIES) {
@@ -3051,7 +2772,7 @@ async function downloadPlugin(pluginKey, requestedVersion) {
     );
   }
   const tgzPath = getTempFilePath(pluginKey, pluginInfo.version);
-  fs11.writeFileSync(tgzPath, tgzBuffer);
+  fs8.writeFileSync(tgzPath, tgzBuffer);
   console.log(`[action-plugin] Downloaded to ${tgzPath} (${(tgzBuffer.length / 1024).toFixed(2)} KB)`);
   return {
     tgzPath,
@@ -3065,18 +2786,18 @@ function getCachePath(pluginKey, version) {
   ensureCacheDir();
   const safeKey = pluginKey.replace(/[/@]/g, "_");
   const filename = `${safeKey}@${version}.tgz`;
-  return path9.join(getPluginCacheDir(), filename);
+  return path6.join(getPluginCacheDir(), filename);
 }
 function hasCachedPlugin(pluginKey, version) {
   const cachePath = getCachePath(pluginKey, version);
-  return fs11.existsSync(cachePath);
+  return fs8.existsSync(cachePath);
 }
 function listCachedPlugins() {
   const cacheDir = getPluginCacheDir();
-  if (!fs11.existsSync(cacheDir)) {
+  if (!fs8.existsSync(cacheDir)) {
     return [];
   }
-  const files = fs11.readdirSync(cacheDir);
+  const files = fs8.readdirSync(cacheDir);
   const result = [];
   for (const file of files) {
     if (!file.endsWith(".tgz")) continue;
@@ -3084,8 +2805,8 @@ function listCachedPlugins() {
     if (!match) continue;
     const [, rawName, version] = match;
     const name = rawName.replace(/^_/, "@").replace(/_/, "/");
-    const filePath = path9.join(cacheDir, file);
-    const stat = fs11.statSync(filePath);
+    const filePath = path6.join(cacheDir, file);
+    const stat = fs8.statSync(filePath);
     result.push({
       name,
       version,
@@ -3098,14 +2819,14 @@ function listCachedPlugins() {
 }
 function cleanAllCache() {
   const cacheDir = getPluginCacheDir();
-  if (!fs11.existsSync(cacheDir)) {
+  if (!fs8.existsSync(cacheDir)) {
     return 0;
   }
-  const files = fs11.readdirSync(cacheDir);
+  const files = fs8.readdirSync(cacheDir);
   let count = 0;
   for (const file of files) {
     if (file.endsWith(".tgz")) {
-      fs11.unlinkSync(path9.join(cacheDir, file));
+      fs8.unlinkSync(path6.join(cacheDir, file));
       count++;
     }
   }
@@ -3113,21 +2834,21 @@ function cleanAllCache() {
 }
 function cleanPluginCache(pluginKey, version) {
   const cacheDir = getPluginCacheDir();
-  if (!fs11.existsSync(cacheDir)) {
+  if (!fs8.existsSync(cacheDir)) {
     return 0;
   }
   const safeKey = pluginKey.replace(/[/@]/g, "_");
-  const files = fs11.readdirSync(cacheDir);
+  const files = fs8.readdirSync(cacheDir);
   let count = 0;
   for (const file of files) {
     if (version) {
       if (file === `${safeKey}@${version}.tgz`) {
-        fs11.unlinkSync(path9.join(cacheDir, file));
+        fs8.unlinkSync(path6.join(cacheDir, file));
         count++;
       }
     } else {
       if (file.startsWith(`${safeKey}@`) && file.endsWith(".tgz")) {
-        fs11.unlinkSync(path9.join(cacheDir, file));
+        fs8.unlinkSync(path6.join(cacheDir, file));
         count++;
       }
     }
@@ -3221,6 +2942,8 @@ 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 };
       }
     }
@@ -3231,6 +2954,8 @@ async function installOne(nameWithVersion) {
       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: ${targetVersion} (installed: ${actualVersion || "none"})`);
@@ -3261,6 +2986,10 @@ async function installOne(nameWithVersion) {
     writeActionPlugins(plugins);
     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);
@@ -3546,40 +3275,40 @@ var actionPluginCommandGroup = {
 };
 
 // src/commands/capability/utils.ts
-import fs12 from "fs";
+import fs9 from "fs";
 import { createRequire as createRequire2 } from "module";
-import path10 from "path";
+import path7 from "path";
 var CAPABILITIES_DIR = "server/capabilities";
 function getProjectRoot2() {
   return process.cwd();
 }
 function getCapabilitiesDir() {
-  return path10.join(getProjectRoot2(), CAPABILITIES_DIR);
+  return path7.join(getProjectRoot2(), CAPABILITIES_DIR);
 }
 function getCapabilityPath(id) {
-  return path10.join(getCapabilitiesDir(), `${id}.json`);
+  return path7.join(getCapabilitiesDir(), `${id}.json`);
 }
 function getPluginManifestPath(pluginKey) {
-  return path10.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
+  return path7.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
 }
 function capabilitiesDirExists() {
-  return fs12.existsSync(getCapabilitiesDir());
+  return fs9.existsSync(getCapabilitiesDir());
 }
 function listCapabilityIds() {
   const dir = getCapabilitiesDir();
-  if (!fs12.existsSync(dir)) {
+  if (!fs9.existsSync(dir)) {
     return [];
   }
-  const files = fs12.readdirSync(dir);
+  const files = fs9.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 (!fs12.existsSync(filePath)) {
+  if (!fs9.existsSync(filePath)) {
     throw new Error(`Capability not found: ${id}`);
   }
   try {
-    const content = fs12.readFileSync(filePath, "utf-8");
+    const content = fs9.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -3606,11 +3335,11 @@ function readAllCapabilities() {
 }
 function readPluginManifest(pluginKey) {
   const manifestPath = getPluginManifestPath(pluginKey);
-  if (!fs12.existsSync(manifestPath)) {
+  if (!fs9.existsSync(manifestPath)) {
     throw new Error(`Plugin not installed: ${pluginKey} (manifest.json not found)`);
   }
   try {
-    const content = fs12.readFileSync(manifestPath, "utf-8");
+    const content = fs9.readFileSync(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -3627,7 +3356,7 @@ function hasValidParamsSchema(paramsSchema) {
 }
 async function loadPlugin(pluginKey) {
   try {
-    const userRequire = createRequire2(path10.join(getProjectRoot2(), "package.json"));
+    const userRequire = createRequire2(path7.join(getProjectRoot2(), "package.json"));
     const resolvedPath = userRequire.resolve(pluginKey);
     const pluginModule = await import(resolvedPath);
     const pluginPackage = pluginModule.default ?? pluginModule;
@@ -3786,9 +3515,12 @@ var capabilityCommandGroup = {
   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 fs10 from "fs";
+import path8 from "path";
 import os from "os";
 
 // src/commands/component/service.ts
@@ -3844,7 +3576,7 @@ async function sendInstallEvent(key) {
 }
 
 // src/commands/component/registry-preparer.ts
-var REGISTRY_TEMP_DIR = path11.join(os.tmpdir(), "miaoda-registry");
+var REGISTRY_TEMP_DIR = path8.join(os.tmpdir(), "miaoda-registry");
 function parseComponentKey(key) {
   const match = key.match(/^@([^/]+)\/(.+)$/);
   if (!match) {
@@ -3856,11 +3588,11 @@ function parseComponentKey(key) {
 }
 function getLocalRegistryPath(key) {
   const { scope, name } = parseComponentKey(key);
-  return path11.join(REGISTRY_TEMP_DIR, scope, `${name}.json`);
+  return path8.join(REGISTRY_TEMP_DIR, scope, `${name}.json`);
 }
 function ensureDir(dirPath) {
-  if (!fs13.existsSync(dirPath)) {
-    fs13.mkdirSync(dirPath, { recursive: true });
+  if (!fs10.existsSync(dirPath)) {
+    fs10.mkdirSync(dirPath, { recursive: true });
   }
 }
 async function prepareRecursive(key, visited) {
@@ -3893,8 +3625,8 @@ async function prepareRecursive(key, visited) {
     registryDependencies: deps.map((dep) => getLocalRegistryPath(dep))
   };
   const localPath = getLocalRegistryPath(key);
-  ensureDir(path11.dirname(localPath));
-  fs13.writeFileSync(localPath, JSON.stringify(rewrittenItem, null, 2), "utf-8");
+  ensureDir(path8.dirname(localPath));
+  fs10.writeFileSync(localPath, JSON.stringify(rewrittenItem, null, 2), "utf-8");
   debug("\u4FDD\u5B58\u5230: %s", localPath);
 }
 async function prepareComponentRegistryItems(id) {
@@ -3904,18 +3636,18 @@ async function prepareComponentRegistryItems(id) {
 }
 function cleanupTempDir() {
   try {
-    if (fs13.existsSync(REGISTRY_TEMP_DIR)) {
-      fs13.rmSync(REGISTRY_TEMP_DIR, { recursive: true, force: true });
+    if (fs10.existsSync(REGISTRY_TEMP_DIR)) {
+      fs10.rmSync(REGISTRY_TEMP_DIR, { recursive: true, force: true });
     }
   } catch {
   }
 }
 function getDownloadedRegistryItem(itemId) {
   const localPath = getLocalRegistryPath(itemId);
-  if (!fs13.existsSync(localPath)) {
+  if (!fs10.existsSync(localPath)) {
     return null;
   }
-  const content = fs13.readFileSync(localPath, "utf-8");
+  const content = fs10.readFileSync(localPath, "utf-8");
   return JSON.parse(content);
 }
 
@@ -4015,6 +3747,16 @@ async function executeShadcnAdd(registryItemPath) {
 }
 
 // src/commands/component/add.handler.ts
+function runActionPluginInit() {
+  return new Promise((resolve) => {
+    execFile("fullstack-cli", ["action-plugin", "init"], { cwd: process.cwd(), stdio: "ignore" }, (error) => {
+      if (error) {
+        debug("action-plugin init \u5931\u8D25: %s", error.message);
+      }
+      resolve();
+    });
+  });
+}
 function printResult(result) {
   console.log(JSON.stringify(result, null, 2));
 }
@@ -4051,6 +3793,7 @@ async function add(key) {
       errors: [{ message: errorMessage }]
     });
   } finally {
+    await runActionPluginInit();
     cleanupTempDir();
   }
 }
@@ -4072,58 +3815,58 @@ var componentCommandGroup = {
 };
 
 // src/commands/migration/version-manager.ts
-import fs14 from "fs";
-import path12 from "path";
+import fs11 from "fs";
+import path9 from "path";
 var PACKAGE_JSON = "package.json";
 var VERSION_FIELD = "migrationVersion";
 function getPackageJsonPath2() {
-  return path12.join(process.cwd(), PACKAGE_JSON);
+  return path9.join(process.cwd(), PACKAGE_JSON);
 }
 function getCurrentVersion() {
   const pkgPath = getPackageJsonPath2();
-  if (!fs14.existsSync(pkgPath)) {
+  if (!fs11.existsSync(pkgPath)) {
     throw new Error("package.json not found");
   }
-  const pkg2 = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
   return pkg2[VERSION_FIELD] ?? 0;
 }
 function setCurrentVersion(version) {
   const pkgPath = getPackageJsonPath2();
-  const pkg2 = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
+  const pkg2 = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
   pkg2[VERSION_FIELD] = version;
-  fs14.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+  fs11.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/detector.ts
-import fs16 from "fs";
-import path14 from "path";
+import fs13 from "fs";
+import path11 from "path";
 
 // src/commands/migration/versions/v001_capability/utils.ts
-import fs15 from "fs";
-import path13 from "path";
+import fs12 from "fs";
+import path10 from "path";
 var CAPABILITIES_DIR2 = "server/capabilities";
 function getProjectRoot3() {
   return process.cwd();
 }
 function getCapabilitiesDir2() {
-  return path13.join(getProjectRoot3(), CAPABILITIES_DIR2);
+  return path10.join(getProjectRoot3(), CAPABILITIES_DIR2);
 }
 function getPluginManifestPath2(pluginKey) {
-  return path13.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
+  return path10.join(getProjectRoot3(), "node_modules", pluginKey, "manifest.json");
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/detector.ts
 function detectJsonMigration() {
   const capabilitiesDir = getCapabilitiesDir2();
-  const oldFilePath = path14.join(capabilitiesDir, "capabilities.json");
-  if (!fs16.existsSync(oldFilePath)) {
+  const oldFilePath = path11.join(capabilitiesDir, "capabilities.json");
+  if (!fs13.existsSync(oldFilePath)) {
     return {
       needsMigration: false,
       reason: "capabilities.json not found"
     };
   }
   try {
-    const content = fs16.readFileSync(oldFilePath, "utf-8");
+    const content = fs13.readFileSync(oldFilePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!Array.isArray(parsed)) {
       return {
@@ -4174,8 +3917,8 @@ async function check(options) {
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
-import fs17 from "fs";
-import path15 from "path";
+import fs14 from "fs";
+import path12 from "path";
 
 // src/commands/migration/versions/v001_capability/mapping.ts
 var DEFAULT_PLUGIN_VERSION = "1.0.0";
@@ -4405,18 +4148,18 @@ function transformCapabilities(oldCapabilities) {
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
 function loadExistingCapabilities() {
   const capabilitiesDir = getCapabilitiesDir2();
-  if (!fs17.existsSync(capabilitiesDir)) {
+  if (!fs14.existsSync(capabilitiesDir)) {
     return [];
   }
-  const files = fs17.readdirSync(capabilitiesDir);
+  const files = fs14.readdirSync(capabilitiesDir);
   const capabilities = [];
   for (const file of files) {
     if (file === "capabilities.json" || !file.endsWith(".json")) {
       continue;
     }
     try {
-      const filePath = path15.join(capabilitiesDir, file);
-      const content = fs17.readFileSync(filePath, "utf-8");
+      const filePath = path12.join(capabilitiesDir, file);
+      const content = fs14.readFileSync(filePath, "utf-8");
       const capability = JSON.parse(content);
       if (capability.id && capability.pluginKey) {
         capabilities.push(capability);
@@ -4474,9 +4217,9 @@ async function migrateJsonFiles(options) {
   }
   const capabilitiesDir = getCapabilitiesDir2();
   for (const cap of newCapabilities) {
-    const filePath = path15.join(capabilitiesDir, `${cap.id}.json`);
+    const filePath = path12.join(capabilitiesDir, `${cap.id}.json`);
     const content = JSON.stringify(cap, null, 2);
-    fs17.writeFileSync(filePath, content, "utf-8");
+    fs14.writeFileSync(filePath, content, "utf-8");
     console.log(`   \u2713 Created: ${cap.id}.json`);
   }
   return {
@@ -4488,11 +4231,11 @@ async function migrateJsonFiles(options) {
 }
 
 // src/commands/migration/versions/v001_capability/plugin-installer/detector.ts
-import fs18 from "fs";
+import fs15 from "fs";
 function isPluginInstalled2(pluginKey) {
   const actionPlugins = readActionPlugins();
   const manifestPath = getPluginManifestPath2(pluginKey);
-  return fs18.existsSync(manifestPath) && !!actionPlugins[pluginKey];
+  return fs15.existsSync(manifestPath) && !!actionPlugins[pluginKey];
 }
 function detectPluginsToInstall(capabilities) {
   const pluginKeys = /* @__PURE__ */ new Set();
@@ -4568,12 +4311,12 @@ async function installPlugins(capabilities, options) {
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/index.ts
-import path17 from "path";
+import path14 from "path";
 import { Project as Project3 } from "ts-morph";
 
 // src/commands/migration/versions/v001_capability/code-migrator/scanner.ts
-import fs19 from "fs";
-import path16 from "path";
+import fs16 from "fs";
+import path13 from "path";
 var EXCLUDED_DIRS = [
   "node_modules",
   "dist",
@@ -4588,9 +4331,9 @@ var EXCLUDED_PATTERNS = [
   /\.d\.ts$/
 ];
 function scanDirectory(dir, files = []) {
-  const entries = fs19.readdirSync(dir, { withFileTypes: true });
+  const entries = fs16.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path16.join(dir, entry.name);
+    const fullPath = path13.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (EXCLUDED_DIRS.includes(entry.name)) {
         continue;
@@ -4606,14 +4349,14 @@ function scanDirectory(dir, files = []) {
   return files;
 }
 function scanServerFiles() {
-  const serverDir = path16.join(getProjectRoot3(), "server");
-  if (!fs19.existsSync(serverDir)) {
+  const serverDir = path13.join(getProjectRoot3(), "server");
+  if (!fs16.existsSync(serverDir)) {
     return [];
   }
   return scanDirectory(serverDir);
 }
 function hasCapabilityImport(filePath) {
-  const content = fs19.readFileSync(filePath, "utf-8");
+  const content = fs16.readFileSync(filePath, "utf-8");
   return /import\s+.*from\s+['"][^'"]*capabilities[^'"]*['"]/.test(content);
 }
 function scanFilesToMigrate() {
@@ -4990,7 +4733,7 @@ function analyzeFile(project, filePath, actionNameMap) {
   const callSites = analyzeCallSites(sourceFile, imports);
   const classInfo = analyzeClass(sourceFile);
   const { canMigrate, reason } = canAutoMigrate(classInfo);
-  const relativePath = path17.relative(getProjectRoot3(), filePath);
+  const relativePath = path14.relative(getProjectRoot3(), filePath);
   return {
     filePath: relativePath,
     imports,
@@ -5001,7 +4744,7 @@ function analyzeFile(project, filePath, actionNameMap) {
   };
 }
 function migrateFile(project, analysis, dryRun) {
-  const absolutePath = path17.join(getProjectRoot3(), analysis.filePath);
+  const absolutePath = path14.join(getProjectRoot3(), analysis.filePath);
   if (!analysis.canAutoMigrate) {
     return {
       filePath: analysis.filePath,
@@ -5104,17 +4847,17 @@ function getSuggestion(analysis) {
 }
 
 // src/commands/migration/versions/v001_capability/cleanup.ts
-import fs20 from "fs";
-import path18 from "path";
+import fs17 from "fs";
+import path15 from "path";
 function cleanupOldFiles(capabilities, dryRun) {
   const deletedFiles = [];
   const errors = [];
   const capabilitiesDir = getCapabilitiesDir2();
-  const oldJsonPath = path18.join(capabilitiesDir, "capabilities.json");
-  if (fs20.existsSync(oldJsonPath)) {
+  const oldJsonPath = path15.join(capabilitiesDir, "capabilities.json");
+  if (fs17.existsSync(oldJsonPath)) {
     try {
       if (!dryRun) {
-        fs20.unlinkSync(oldJsonPath);
+        fs17.unlinkSync(oldJsonPath);
       }
       deletedFiles.push("capabilities.json");
     } catch (error) {
@@ -5122,11 +4865,11 @@ function cleanupOldFiles(capabilities, dryRun) {
     }
   }
   for (const cap of capabilities) {
-    const tsFilePath = path18.join(capabilitiesDir, `${cap.id}.ts`);
-    if (fs20.existsSync(tsFilePath)) {
+    const tsFilePath = path15.join(capabilitiesDir, `${cap.id}.ts`);
+    if (fs17.existsSync(tsFilePath)) {
       try {
         if (!dryRun) {
-          fs20.unlinkSync(tsFilePath);
+          fs17.unlinkSync(tsFilePath);
         }
         deletedFiles.push(`${cap.id}.ts`);
       } catch (error) {
@@ -5142,8 +4885,8 @@ function cleanupOldFiles(capabilities, dryRun) {
 }
 
 // src/commands/migration/versions/v001_capability/report-generator.ts
-import fs21 from "fs";
-import path19 from "path";
+import fs18 from "fs";
+import path16 from "path";
 var REPORT_FILE = "capability-migration-report.md";
 function printSummary(result) {
   const { jsonMigration, pluginInstallation, codeMigration, cleanup } = result;
@@ -5306,15 +5049,15 @@ async function generateReport(result) {
   }
   lines.push("");
   const logDir = process.env.LOG_DIR || "logs";
-  if (!fs21.existsSync(logDir)) {
+  if (!fs18.existsSync(logDir)) {
     return;
   }
-  const reportDir = path19.join(logDir, "migration");
-  if (!fs21.existsSync(reportDir)) {
-    fs21.mkdirSync(reportDir, { recursive: true });
+  const reportDir = path16.join(logDir, "migration");
+  if (!fs18.existsSync(reportDir)) {
+    fs18.mkdirSync(reportDir, { recursive: true });
   }
-  const reportPath = path19.join(reportDir, REPORT_FILE);
-  fs21.writeFileSync(reportPath, lines.join("\n"), "utf-8");
+  const reportPath = path16.join(reportDir, REPORT_FILE);
+  fs18.writeFileSync(reportPath, lines.join("\n"), "utf-8");
   console.log(`\u{1F4C4} Report generated: ${reportPath}`);
 }
 
@@ -5491,7 +5234,7 @@ function buildResult(jsonMigration, pluginInstallation, codeMigration, cleanup)
 }
 
 // src/commands/migration/versions/v001_capability/run.ts
-async function run5(options) {
+async function run3(options) {
   try {
     const migrationOptions = {
       dryRun: options.dryRun ?? false
@@ -5556,7 +5299,7 @@ var v001CapabilityMigration = {
   name: "capability",
   description: "Migrate capability configurations from old format (capabilities.json array) to new format (individual JSON files)",
   check,
-  run: run5
+  run: run3
 };
 
 // src/commands/migration/versions/index.ts
@@ -5846,10 +5589,10 @@ var migrationCommand = {
 };
 
 // src/commands/read-logs/index.ts
-import path20 from "path";
+import path17 from "path";
 
 // src/commands/read-logs/std-utils.ts
-import fs22 from "fs";
+import fs19 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;
@@ -5879,11 +5622,11 @@ function stripPrefixFromStdLine(line) {
   return `[${time}] ${content}`;
 }
 function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarker) {
-  const stat = fs22.statSync(filePath);
+  const stat = fs19.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], markerFound: false, totalLinesCount: 0 };
   }
-  const fd = fs22.openSync(filePath, "r");
+  const fd = fs19.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -5897,7 +5640,7 @@ function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarke
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs22.readSync(fd, buffer, 0, length, position);
+      fs19.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -5939,7 +5682,7 @@ function readStdLinesTailFromLastMarkerPaged(filePath, maxLines, offset, isMarke
       }
     }
   } finally {
-    fs22.closeSync(fd);
+    fs19.closeSync(fd);
   }
   return { lines: collected.reverse(), markerFound, totalLinesCount };
 }
@@ -5960,21 +5703,21 @@ function readServerStdSegment(filePath, maxLines, offset) {
 }
 
 // src/commands/read-logs/tail.ts
-import fs23 from "fs";
+import fs20 from "fs";
 function fileExists(filePath) {
   try {
-    fs23.accessSync(filePath, fs23.constants.F_OK | fs23.constants.R_OK);
+    fs20.accessSync(filePath, fs20.constants.F_OK | fs20.constants.R_OK);
     return true;
   } catch {
     return false;
   }
 }
 function readFileTailLines(filePath, maxLines) {
-  const stat = fs23.statSync(filePath);
+  const stat = fs20.statSync(filePath);
   if (stat.size === 0) {
     return [];
   }
-  const fd = fs23.openSync(filePath, "r");
+  const fd = fs20.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   const chunks = [];
   let position = stat.size;
@@ -5984,13 +5727,13 @@ function readFileTailLines(filePath, maxLines) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs23.readSync(fd, buffer, 0, length, position);
+      fs20.readSync(fd, buffer, 0, length, position);
       chunks.unshift(buffer.toString("utf8"));
       const chunkLines = buffer.toString("utf8").split("\n").length - 1;
       collectedLines += chunkLines;
     }
   } finally {
-    fs23.closeSync(fd);
+    fs20.closeSync(fd);
   }
   const content = chunks.join("");
   const allLines = content.split("\n");
@@ -6006,11 +5749,11 @@ function readFileTailLines(filePath, maxLines) {
   return allLines.slice(allLines.length - maxLines);
 }
 function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
-  const stat = fs23.statSync(filePath);
+  const stat = fs20.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs23.openSync(filePath, "r");
+  const fd = fs20.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -6022,7 +5765,7 @@ function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs23.readSync(fd, buffer, 0, length, position);
+      fs20.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -6053,7 +5796,7 @@ function readFileTailNonEmptyLinesWithOffset(filePath, maxLines, offset) {
       }
     }
   } finally {
-    fs23.closeSync(fd);
+    fs20.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -6195,7 +5938,7 @@ function readDevStdSegment(filePath, maxLines, offset) {
 }
 
 // src/commands/read-logs/json-lines.ts
-import fs24 from "fs";
+import fs21 from "fs";
 function normalizePid(value) {
   if (typeof value === "number") {
     return String(value);
@@ -6246,11 +5989,11 @@ function buildWantedLevelSet(levels) {
   return set.size > 0 ? set : null;
 }
 function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
-  const stat = fs24.statSync(filePath);
+  const stat = fs21.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs24.openSync(filePath, "r");
+  const fd = fs21.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -6265,7 +6008,7 @@ function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs24.readSync(fd, buffer, 0, length, position);
+      fs21.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -6327,7 +6070,7 @@ function readJsonLinesLastPid(filePath, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs24.closeSync(fd);
+    fs21.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -6370,11 +6113,11 @@ function extractTraceId(obj) {
 function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
   const wanted = traceId.trim();
   if (!wanted) return { lines: [], totalLinesCount: 0 };
-  const stat = fs24.statSync(filePath);
+  const stat = fs21.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs24.openSync(filePath, "r");
+  const fd = fs21.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -6387,7 +6130,7 @@ function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs24.readSync(fd, buffer, 0, length, position);
+      fs21.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -6440,7 +6183,7 @@ function readJsonLinesByTraceId(filePath, traceId, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs24.closeSync(fd);
+    fs21.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -6449,11 +6192,11 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
   if (!wantedLevelSet) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const stat = fs24.statSync(filePath);
+  const stat = fs21.statSync(filePath);
   if (stat.size === 0) {
     return { lines: [], totalLinesCount: 0 };
   }
-  const fd = fs24.openSync(filePath, "r");
+  const fd = fs21.openSync(filePath, "r");
   const chunkSize = 64 * 1024;
   let position = stat.size;
   let remainder = "";
@@ -6465,7 +6208,7 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
       const length = Math.min(chunkSize, position);
       position -= length;
       const buffer = Buffer.alloc(length);
-      fs24.readSync(fd, buffer, 0, length, position);
+      fs21.readSync(fd, buffer, 0, length, position);
       let chunk = buffer.toString("utf8");
       if (remainder) {
         chunk += remainder;
@@ -6512,7 +6255,7 @@ function readJsonLinesTailByLevel(filePath, maxLines, offset, levels) {
       }
     }
   } finally {
-    fs24.closeSync(fd);
+    fs21.closeSync(fd);
   }
   return { lines: collected.reverse(), totalLinesCount };
 }
@@ -6746,34 +6489,34 @@ async function readLogsJsonResult(options) {
   };
 }
 function resolveLogFilePath(logDir, type) {
-  const base = path20.isAbsolute(logDir) ? logDir : path20.join(process.cwd(), logDir);
+  const base = path17.isAbsolute(logDir) ? logDir : path17.join(process.cwd(), logDir);
   if (type === "server") {
-    return path20.join(base, "server.log");
+    return path17.join(base, "server.log");
   }
   if (type === "trace") {
-    return path20.join(base, "trace.log");
+    return path17.join(base, "trace.log");
   }
   if (type === "server-std") {
-    return path20.join(base, "server.std.log");
+    return path17.join(base, "server.std.log");
   }
   if (type === "client-std") {
-    return path20.join(base, "client.std.log");
+    return path17.join(base, "client.std.log");
   }
   if (type === "dev") {
-    return path20.join(base, "dev.log");
+    return path17.join(base, "dev.log");
   }
   if (type === "dev-std") {
-    return path20.join(base, "dev.std.log");
+    return path17.join(base, "dev.std.log");
   }
   if (type === "install-dep-std") {
-    return path20.join(base, "install-dep.std.log");
+    return path17.join(base, "install-dep.std.log");
   }
   if (type === "browser") {
-    return path20.join(base, "browser.log");
+    return path17.join(base, "browser.log");
   }
   throw new Error(`Unsupported log type: ${type}`);
 }
-async function run6(options) {
+async function run4(options) {
   const result = await readLogsJsonResult(options);
   process.stdout.write(JSON.stringify(result) + "\n");
 }
@@ -6815,7 +6558,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 run6({ logDir, type, maxLines, offset, traceId, levels });
+        await run4({ logDir, type, maxLines, offset, traceId, levels });
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         process.stderr.write(message + "\n");
@@ -6825,25 +6568,100 @@ 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: "" })
+  }
+};
+
+// 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(
+      `API request failed: ${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/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 buildCommandGroup = {
+  name: "build",
+  description: "Build related commands",
+  commands: [getTokenCommand]
+};
+
 // src/commands/index.ts
 var commands = [
   genDbSchemaCommand,
   syncCommand,
-  upgradeCommand,
   actionPluginCommandGroup,
   capabilityCommandGroup,
   componentCommandGroup,
   migrationCommand,
-  readLogsCommand
+  readLogsCommand,
+  buildCommandGroup
 ];
 
 // src/index.ts
-var envPath = path21.join(process.cwd(), ".env");
-if (fs25.existsSync(envPath)) {
+var envPath = path18.join(process.cwd(), ".env");
+if (fs22.existsSync(envPath)) {
   dotenvConfig({ path: envPath });
 }
-var __dirname = path21.dirname(fileURLToPath5(import.meta.url));
-var pkg = JSON.parse(fs25.readFileSync(path21.join(__dirname, "../package.json"), "utf-8"));
+var __dirname = path18.dirname(fileURLToPath4(import.meta.url));
+var pkg = JSON.parse(fs22.readFileSync(path18.join(__dirname, "../package.json"), "utf-8"));
 var cli = new FullstackCLI(pkg.version);
 cli.useAll(commands);
 cli.run();