@lark-apaas/fullstack-cli 1.1.6-alpha.1 → 1.1.6-alpha.3

package/dist/index.js

@@ -438,8 +438,7 @@ var syncCommand = {
 // src/commands/action-plugin/utils.ts
 import fs3 from "fs";
 import path3 from "path";
-import { spawnSync as spawnSync2 } from "child_process";
-var CONFIG_FILE_NAME = ".capabilityrc.json";
+import { spawnSync as spawnSync2, execSync } from "child_process";
 function parsePluginName(input) {
   const match = input.match(/^(@[^/]+\/[^@]+)(?:@(.+))?$/);
   if (!match) {
@@ -455,36 +454,44 @@ function parsePluginName(input) {
 function getProjectRoot() {
   return process.cwd();
 }
-function getConfigPath() {
-  return path3.join(getProjectRoot(), CONFIG_FILE_NAME);
+function getPackageJsonPath() {
+  return path3.join(getProjectRoot(), "package.json");
 }
 function getPluginPath(pluginName) {
   return path3.join(getProjectRoot(), "node_modules", pluginName);
 }
-function readConfig() {
-  const configPath = getConfigPath();
-  if (!fs3.existsSync(configPath)) {
-    return { plugins: {} };
+function readPackageJson() {
+  const pkgPath = getPackageJsonPath();
+  if (!fs3.existsSync(pkgPath)) {
+    throw new Error("package.json not found in current directory");
   }
   try {
-    const content = fs3.readFileSync(configPath, "utf-8");
+    const content = fs3.readFileSync(pkgPath, "utf-8");
     return JSON.parse(content);
   } catch {
-    console.warn(`[action-plugin] Warning: Failed to parse ${CONFIG_FILE_NAME}, using empty config`);
-    return { plugins: {} };
+    throw new Error("Failed to parse package.json");
   }
 }
-function writeConfig(config) {
-  const configPath = getConfigPath();
-  fs3.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+function writePackageJson(pkg2) {
+  const pkgPath = getPackageJsonPath();
+  fs3.writeFileSync(pkgPath, JSON.stringify(pkg2, null, 2) + "\n", "utf-8");
+}
+function readActionPlugins() {
+  const pkg2 = readPackageJson();
+  return pkg2.actionPlugins || {};
+}
+function writeActionPlugins(plugins) {
+  const pkg2 = readPackageJson();
+  pkg2.actionPlugins = plugins;
+  writePackageJson(pkg2);
 }
 function isPluginInstalled(pluginName) {
-  const config = readConfig();
-  return pluginName in config.plugins;
+  const plugins = readActionPlugins();
+  return pluginName in plugins;
 }
-function getInstalledPluginInfo(pluginName) {
-  const config = readConfig();
-  return config.plugins[pluginName] || null;
+function getInstalledPluginVersion(pluginName) {
+  const plugins = readActionPlugins();
+  return plugins[pluginName] || null;
 }
 function npmInstall(tgzPath) {
   console.log(`[action-plugin] Running npm install ${tgzPath}...`);
@@ -499,19 +506,6 @@ function npmInstall(tgzPath) {
     throw new Error(`npm install failed with exit code ${result.status}`);
   }
 }
-function npmUninstall(pluginName) {
-  console.log(`[action-plugin] Running npm uninstall ${pluginName}...`);
-  const result = spawnSync2("npm", ["uninstall", pluginName], {
-    cwd: getProjectRoot(),
-    stdio: "inherit"
-  });
-  if (result.error) {
-    throw new Error(`npm uninstall failed: ${result.error.message}`);
-  }
-  if (result.status !== 0) {
-    throw new Error(`npm uninstall failed with exit code ${result.status}`);
-  }
-}
 function getPackageVersion(pluginName) {
   const pkgJsonPath = path3.join(getPluginPath(pluginName), "package.json");
   if (!fs3.existsSync(pkgJsonPath)) {
@@ -525,6 +519,90 @@ function getPackageVersion(pluginName) {
     return null;
   }
 }
+function readPluginPackageJson(pluginPath) {
+  const pkgJsonPath = path3.join(pluginPath, "package.json");
+  if (!fs3.existsSync(pkgJsonPath)) {
+    return null;
+  }
+  try {
+    const content = fs3.readFileSync(pkgJsonPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function extractTgzToNodeModules(tgzPath, pluginName) {
+  const nodeModulesPath = path3.join(getProjectRoot(), "node_modules");
+  const targetDir = path3.join(nodeModulesPath, pluginName);
+  const scopeDir = path3.dirname(targetDir);
+  if (!fs3.existsSync(scopeDir)) {
+    fs3.mkdirSync(scopeDir, { recursive: true });
+  }
+  if (fs3.existsSync(targetDir)) {
+    fs3.rmSync(targetDir, { recursive: true });
+  }
+  const tempDir = path3.join(nodeModulesPath, ".cache", "fullstack-cli", "extract-temp");
+  if (fs3.existsSync(tempDir)) {
+    fs3.rmSync(tempDir, { recursive: true });
+  }
+  fs3.mkdirSync(tempDir, { recursive: true });
+  try {
+    execSync(`tar -xzf "${tgzPath}" -C "${tempDir}"`, { stdio: "pipe" });
+    const extractedDir = path3.join(tempDir, "package");
+    if (fs3.existsSync(extractedDir)) {
+      fs3.renameSync(extractedDir, targetDir);
+    } else {
+      const files = fs3.readdirSync(tempDir);
+      if (files.length === 1) {
+        fs3.renameSync(path3.join(tempDir, files[0]), targetDir);
+      } else {
+        throw new Error("Unexpected tgz structure");
+      }
+    }
+    return targetDir;
+  } finally {
+    if (fs3.existsSync(tempDir)) {
+      fs3.rmSync(tempDir, { recursive: true });
+    }
+  }
+}
+function checkMissingPeerDeps(peerDeps) {
+  if (!peerDeps || Object.keys(peerDeps).length === 0) {
+    return [];
+  }
+  const missing = [];
+  const nodeModulesPath = path3.join(getProjectRoot(), "node_modules");
+  for (const [depName, _version] of Object.entries(peerDeps)) {
+    const depPath = path3.join(nodeModulesPath, depName);
+    if (!fs3.existsSync(depPath)) {
+      missing.push(depName);
+    }
+  }
+  return missing;
+}
+function installMissingDeps(deps) {
+  if (deps.length === 0) {
+    return;
+  }
+  console.log(`[action-plugin] Installing missing dependencies: ${deps.join(", ")}`);
+  const result = spawnSync2("npm", ["install", ...deps, "--no-save", "--no-package-lock"], {
+    cwd: getProjectRoot(),
+    stdio: "inherit"
+  });
+  if (result.error) {
+    throw new Error(`npm install failed: ${result.error.message}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(`npm install failed with exit code ${result.status}`);
+  }
+}
+function removePluginDirectory(pluginName) {
+  const pluginPath = getPluginPath(pluginName);
+  if (fs3.existsSync(pluginPath)) {
+    fs3.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";
@@ -665,29 +743,39 @@ async function installOne(nameWithVersion) {
   const { name, version: requestedVersion } = parsePluginName(nameWithVersion);
   try {
     console.log(`[action-plugin] Installing ${name}@${requestedVersion}...`);
-    if (isPluginInstalled(name)) {
-      const info = getInstalledPluginInfo(name);
-      if (info) {
+    if (isPluginInstalled(name) && requestedVersion !== "latest") {
+      const installedVer = getInstalledPluginVersion(name);
+      if (installedVer === requestedVersion) {
+        console.log(`[action-plugin] Plugin ${name}@${requestedVersion} is already installed`);
+        return { name, version: installedVer, success: true, skipped: true };
+      }
+    }
+    if (isPluginInstalled(name) && requestedVersion === "latest") {
+      const installedVer = getInstalledPluginVersion(name);
+      if (installedVer) {
         const latestInfo = await getPluginVersion(name, "latest");
-        const latestVersion = latestInfo.version;
-        if (info.version === latestVersion) {
-          console.log(`[action-plugin] Plugin ${name} is already up to date (version: ${info.version})`);
-          return { name, version: info.version, success: true, skipped: true };
+        if (installedVer === latestInfo.version) {
+          console.log(`[action-plugin] Plugin ${name} is already up to date (version: ${installedVer})`);
+          return { name, version: installedVer, success: true, skipped: true };
         }
-        console.log(`[action-plugin] Found newer version: ${latestVersion} (installed: ${info.version})`);
-        console.log(`[action-plugin] Updating to ${latestVersion}...`);
+        console.log(`[action-plugin] Found newer version: ${latestInfo.version} (installed: ${installedVer})`);
       }
     }
     const downloadResult = await downloadPlugin(name, requestedVersion);
     tgzPath = downloadResult.tgzPath;
-    npmInstall(tgzPath);
+    console.log(`[action-plugin] Extracting to node_modules...`);
+    const pluginDir = extractTgzToNodeModules(tgzPath, name);
+    const pluginPkg = readPluginPackageJson(pluginDir);
+    if (pluginPkg?.peerDependencies) {
+      const missingDeps = checkMissingPeerDeps(pluginPkg.peerDependencies);
+      if (missingDeps.length > 0) {
+        installMissingDeps(missingDeps);
+      }
+    }
     const installedVersion = getPackageVersion(name) || downloadResult.version;
-    const config = readConfig();
-    config.plugins[name] = {
-      version: installedVersion,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    writeConfig(config);
+    const plugins = readActionPlugins();
+    plugins[name] = installedVersion;
+    writeActionPlugins(plugins);
     console.log(`[action-plugin] Successfully installed ${name}@${installedVersion}`);
     return { name, version: installedVersion, success: true };
   } catch (error) {
@@ -740,23 +828,19 @@ async function updateOne(nameWithVersion) {
       console.error(`[action-plugin] Plugin ${name} is not installed`);
       return { name, success: false, notInstalled: true };
     }
-    const currentInfo = getInstalledPluginInfo(name);
-    const oldVersion = currentInfo?.version || "unknown";
+    const oldVersion = getInstalledPluginVersion(name) || "unknown";
     console.log(`[action-plugin] Current version: ${oldVersion}`);
     const downloadResult = await downloadPlugin(name, "latest");
     tgzPath = downloadResult.tgzPath;
-    if (currentInfo && currentInfo.version === downloadResult.version) {
+    if (oldVersion === downloadResult.version) {
       console.log(`[action-plugin] Plugin ${name} is already up to date (version: ${downloadResult.version})`);
       return { name, oldVersion, newVersion: downloadResult.version, success: true, skipped: true };
     }
     npmInstall(tgzPath);
     const installedVersion = getPackageVersion(name) || downloadResult.version;
-    const config = readConfig();
-    config.plugins[name] = {
-      version: installedVersion,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    writeConfig(config);
+    const plugins = readActionPlugins();
+    plugins[name] = installedVersion;
+    writeActionPlugins(plugins);
     console.log(`[action-plugin] Successfully updated ${name} to ${installedVersion}`);
     return { name, oldVersion, newVersion: installedVersion, success: true };
   } catch (error) {
@@ -812,10 +896,10 @@ async function remove(nameWithVersion) {
       console.error(`[action-plugin] Plugin ${name} is not installed`);
       process.exit(1);
     }
-    npmUninstall(name);
-    const config = readConfig();
-    delete config.plugins[name];
-    writeConfig(config);
+    removePluginDirectory(name);
+    const plugins = readActionPlugins();
+    delete plugins[name];
+    writeActionPlugins(plugins);
     console.log(`[action-plugin] Successfully removed ${name}`);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -827,25 +911,22 @@ async function remove(nameWithVersion) {
 // src/commands/action-plugin/list.handler.ts
 async function list() {
   try {
-    const config = readConfig();
-    const plugins = Object.entries(config.plugins);
+    const plugins = Object.entries(readActionPlugins());
     if (plugins.length === 0) {
       console.log("[action-plugin] No plugins installed");
       console.log('[action-plugin] Use "action-plugin install <name>" to install a plugin');
       return;
     }
     console.log("[action-plugin] Installed plugins:\n");
-    const nameWidth = Math.max(30, ...plugins.map(([name]) => name.length + 2));
+    const nameWidth = Math.max(40, ...plugins.map(([name]) => name.length + 2));
     const versionWidth = 15;
-    const dateWidth = 25;
     console.log(
-      "  " + "Plugin".padEnd(nameWidth) + "Version".padEnd(versionWidth) + "Installed At"
+      "  " + "Plugin".padEnd(nameWidth) + "Version"
     );
-    console.log("  " + "-".repeat(nameWidth + versionWidth + dateWidth));
-    for (const [name, info] of plugins) {
-      const installedAt = new Date(info.installedAt).toLocaleString();
+    console.log("  " + "-".repeat(nameWidth + versionWidth));
+    for (const [name, version] of plugins) {
       console.log(
-        "  " + name.padEnd(nameWidth) + info.version.padEnd(versionWidth) + installedAt
+        "  " + name.padEnd(nameWidth) + version
       );
     }
     console.log(`
@@ -917,8 +998,8 @@ function getCapabilitiesDir() {
 function getCapabilityPath(id) {
   return path5.join(getCapabilitiesDir(), `${id}.json`);
 }
-function getPluginManifestPath(pluginID) {
-  return path5.join(getProjectRoot2(), "node_modules", pluginID, "manifest.json");
+function getPluginManifestPath(pluginKey) {
+  return path5.join(getProjectRoot2(), "node_modules", pluginKey, "manifest.json");
 }
 function capabilitiesDirExists() {
   return fs5.existsSync(getCapabilitiesDir());
@@ -950,17 +1031,17 @@ function readAllCapabilities() {
   const ids = listCapabilityIds();
   return ids.map((id) => readCapability(id));
 }
-function readPluginManifest(pluginID) {
-  const manifestPath = getPluginManifestPath(pluginID);
+function readPluginManifest(pluginKey) {
+  const manifestPath = getPluginManifestPath(pluginKey);
   if (!fs5.existsSync(manifestPath)) {
-    throw new Error(`Plugin not installed: ${pluginID} (manifest.json not found)`);
+    throw new Error(`Plugin not installed: ${pluginKey} (manifest.json not found)`);
   }
   try {
     const content = fs5.readFileSync(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error instanceof SyntaxError) {
-      throw new Error(`Invalid JSON in plugin manifest: ${pluginID}/manifest.json`);
+      throw new Error(`Invalid JSON in plugin manifest: ${pluginKey}/manifest.json`);
     }
     throw error;
   }
@@ -971,19 +1052,19 @@ function isDynamicSchema(schema) {
 function hasValidParamsSchema(paramsSchema) {
   return paramsSchema !== void 0 && Object.keys(paramsSchema).length > 0;
 }
-async function loadPlugin(pluginID) {
+async function loadPlugin(pluginKey) {
   try {
-    const pluginPackage = (await import(pluginID)).default;
+    const pluginPackage = (await import(pluginKey)).default;
     if (!pluginPackage || typeof pluginPackage.create !== "function") {
-      throw new Error(`Plugin ${pluginID} does not export a valid create function`);
+      throw new Error(`Plugin ${pluginKey} does not export a valid create function`);
     }
     return pluginPackage;
   } catch (error) {
     if (error.code === "MODULE_NOT_FOUND") {
-      throw new Error(`Plugin not installed: ${pluginID}`);
+      throw new Error(`Plugin not installed: ${pluginKey}`);
     }
     throw new Error(
-      `Failed to load plugin ${pluginID}: ${error instanceof Error ? error.message : String(error)}`
+      `Failed to load plugin ${pluginKey}: ${error instanceof Error ? error.message : String(error)}`
     );
   }
 }
@@ -997,16 +1078,16 @@ async function zodToJsonSchema(zodSchema) {
 }
 async function hydrateCapability(capability) {
   try {
-    const manifest = readPluginManifest(capability.pluginID);
+    const manifest = readPluginManifest(capability.pluginKey);
     if (!manifest.actions || manifest.actions.length === 0) {
-      throw new Error(`Plugin ${capability.pluginID} has no actions defined`);
+      throw new Error(`Plugin ${capability.pluginKey} has no actions defined`);
     }
     const hasDynamicSchema = manifest.actions.some(
       (action) => isDynamicSchema(action.inputSchema) || isDynamicSchema(action.outputSchema)
     );
     let pluginInstance = null;
     if (hasDynamicSchema) {
-      const plugin = await loadPlugin(capability.pluginID);
+      const plugin = await loadPlugin(capability.pluginKey);
       pluginInstance = plugin.create(capability.formValue || {});
     }
     const actions = [];
@@ -1049,7 +1130,7 @@ async function hydrateCapability(capability) {
     }
     return {
       id: capability.id,
-      pluginID: capability.pluginID,
+      pluginKey: capability.pluginKey,
       pluginVersion: capability.pluginVersion,
       name: capability.name,
       description: capability.description,
@@ -1141,14 +1222,14 @@ function mergeMapping(customMapping) {
   }
   return { ...DEFAULT_MAPPING, ...customMapping };
 }
-function getPluginID(sourceActionID, mapping) {
-  const pluginID = mapping[sourceActionID];
-  if (!pluginID) {
+function getPluginKey(sourceActionID, mapping) {
+  const pluginKey = mapping[sourceActionID];
+  if (!pluginKey) {
     throw new Error(
       `Unknown sourceActionID: "${sourceActionID}". Please provide mapping via --mapping option or add to default mapping.`
     );
   }
-  return pluginID;
+  return pluginKey;
 }
 
 // src/commands/capability/migration/json-migrator/index.ts
@@ -1213,10 +1294,10 @@ function detectJsonMigration() {
 
 // src/commands/capability/migration/json-migrator/transformer.ts
 function transformCapability(old, mapping) {
-  const pluginID = getPluginID(old.sourceActionID, mapping);
+  const pluginKey = getPluginKey(old.sourceActionID, mapping);
   return {
     id: old.id,
-    pluginID,
+    pluginKey,
     pluginVersion: "latest",
     name: old.name,
     description: old.desc,
@@ -1267,7 +1348,7 @@ async function migrateJsonFiles(options) {
   if (options.dryRun) {
     console.log(`   Would create ${newCapabilities.length} capability files:`);
     for (const cap of newCapabilities) {
-      console.log(`   - ${cap.id}.json (pluginID: ${cap.pluginID})`);
+      console.log(`   - ${cap.id}.json (pluginKey: ${cap.pluginKey})`);
     }
     return {
       success: true,
@@ -1296,22 +1377,22 @@ async function migrateJsonFiles(options) {
 
 // src/commands/capability/migration/plugin-installer/detector.ts
 import fs8 from "fs";
-function isPluginInstalled2(pluginID) {
-  const manifestPath = getPluginManifestPath(pluginID);
+function isPluginInstalled2(pluginKey) {
+  const manifestPath = getPluginManifestPath(pluginKey);
   return fs8.existsSync(manifestPath);
 }
 function detectPluginsToInstall(capabilities) {
-  const pluginIDs = /* @__PURE__ */ new Set();
+  const pluginKeys = /* @__PURE__ */ new Set();
   for (const cap of capabilities) {
-    pluginIDs.add(cap.pluginID);
+    pluginKeys.add(cap.pluginKey);
   }
   const toInstall = [];
   const alreadyInstalled = [];
-  for (const pluginID of pluginIDs) {
-    if (isPluginInstalled2(pluginID)) {
-      alreadyInstalled.push(pluginID);
+  for (const pluginKey of pluginKeys) {
+    if (isPluginInstalled2(pluginKey)) {
+      alreadyInstalled.push(pluginKey);
     } else {
-      toInstall.push(pluginID);
+      toInstall.push(pluginKey);
     }
   }
   return { toInstall, alreadyInstalled };
@@ -1330,15 +1411,15 @@ async function installPlugins(capabilities, options) {
   }
   if (options.dryRun) {
     console.log(`   Would install ${detection.toInstall.length} plugins:`);
-    for (const pluginID of detection.toInstall) {
-      console.log(`   - ${pluginID}`);
+    for (const pluginKey of detection.toInstall) {
+      console.log(`   - ${pluginKey}`);
     }
     result.installed = detection.toInstall;
     return result;
   }
   console.log(`   \u2B07 Installing ${detection.toInstall.length} plugins...`);
-  for (const pluginID of detection.toInstall) {
-    console.log(`     - ${pluginID}`);
+  for (const pluginKey of detection.toInstall) {
+    console.log(`     - ${pluginKey}`);
   }
   try {
     const originalExit = process.exit;
@@ -1353,9 +1434,9 @@ async function installPlugins(capabilities, options) {
       await install(detection.toInstall);
       result.installed = detection.toInstall;
     } catch (error) {
-      for (const pluginID of detection.toInstall) {
+      for (const pluginKey of detection.toInstall) {
         result.failed.push({
-          pluginID,
+          pluginKey,
           error: error instanceof Error ? error.message : String(error)
         });
       }
@@ -1363,9 +1444,9 @@ async function installPlugins(capabilities, options) {
       process.exit = originalExit;
     }
   } catch (error) {
-    for (const pluginID of detection.toInstall) {
+    for (const pluginKey of detection.toInstall) {
       result.failed.push({
-        pluginID,
+        pluginKey,
         error: error instanceof Error ? error.message : String(error)
       });
     }
@@ -1911,10 +1992,10 @@ async function generateReport(result) {
   } else {
     lines.push("### 1.1 \u5DF2\u8FC1\u79FB\u7684 Capabilities");
     lines.push("");
-    lines.push("| ID | pluginID |");
-    lines.push("|----|----------|");
+    lines.push("| ID | pluginKey |");
+    lines.push("|----|-----------|");
     for (const cap of jsonMigration.capabilities) {
-      lines.push(`| ${cap.id} | ${cap.pluginID} |`);
+      lines.push(`| ${cap.id} | ${cap.pluginKey} |`);
     }
     lines.push("");
     if (jsonMigration.backupPath) {
@@ -1929,16 +2010,16 @@ async function generateReport(result) {
   if (pluginInstallation.installed.length === 0 && pluginInstallation.alreadyInstalled.length === 0) {
     lines.push("\u65E0\u63D2\u4EF6\u9700\u8981\u5B89\u88C5\u3002");
   } else {
-    lines.push("| pluginID | \u72B6\u6001 |");
-    lines.push("|----------|------|");
-    for (const pluginID of pluginInstallation.alreadyInstalled) {
-      lines.push(`| ${pluginID} | \u5DF2\u5B89\u88C5 |`);
+    lines.push("| pluginKey | \u72B6\u6001 |");
+    lines.push("|-----------|------|");
+    for (const pluginKey of pluginInstallation.alreadyInstalled) {
+      lines.push(`| ${pluginKey} | \u5DF2\u5B89\u88C5 |`);
     }
-    for (const pluginID of pluginInstallation.installed) {
-      lines.push(`| ${pluginID} | \u65B0\u5B89\u88C5 |`);
+    for (const pluginKey of pluginInstallation.installed) {
+      lines.push(`| ${pluginKey} | \u65B0\u5B89\u88C5 |`);
     }
     for (const failed of pluginInstallation.failed) {
-      lines.push(`| ${failed.pluginID} | \u274C \u5931\u8D25: ${failed.error} |`);
+      lines.push(`| ${failed.pluginKey} | \u274C \u5931\u8D25: ${failed.error} |`);
     }
   }
   lines.push("");
@@ -2033,7 +2114,7 @@ async function runMigration(options = {}) {
       console.log(`   \u2713 Installed: ${pluginResult.installed.join(", ")}`);
     }
     if (pluginResult.failed.length > 0) {
-      console.log(`   \u2717 Failed: ${pluginResult.failed.map((f) => f.pluginID).join(", ")}`);
+      console.log(`   \u2717 Failed: ${pluginResult.failed.map((f) => f.pluginKey).join(", ")}`);
     }
     console.log("");
   } else {
@@ -2126,7 +2207,7 @@ var migrationCommand = {
   name: "migration",
   description: "Execute capability migration",
   register(program) {
-    program.command(this.name).description(this.description).option("--dry-run", "Preview mode, do not modify files").option("--skip-install", "Skip plugin installation step").option("--skip-code", "Skip code migration step").option("--mapping <file>", "Custom sourceActionID to pluginID mapping file").action(async (options) => {
+    program.command(this.name).description(this.description).option("--dry-run", "Preview mode, do not modify files").option("--skip-install", "Skip plugin installation step").option("--skip-code", "Skip code migration step").option("--mapping <file>", "Custom sourceActionID to pluginKey mapping file").action(async (options) => {
       await migration(options);
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-cli",
-  "version": "1.1.6-alpha.1",
+  "version": "1.1.6-alpha.3",
   "description": "CLI tool for fullstack template management",
   "type": "module",
   "main": "dist/index.js",