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

package/dist/index.js

@@ -438,7 +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";
+import { spawnSync as spawnSync2, execSync } from "child_process";
 var CONFIG_FILE_NAME = ".capabilityrc.json";
 function parsePluginName(input) {
   const match = input.match(/^(@[^/]+\/[^@]+)(?:@(.+))?$/);
@@ -499,19 +499,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 +512,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,22 +736,35 @@ async function installOne(nameWithVersion) {
   const { name, version: requestedVersion } = parsePluginName(nameWithVersion);
   try {
     console.log(`[action-plugin] Installing ${name}@${requestedVersion}...`);
-    if (isPluginInstalled(name)) {
+    if (isPluginInstalled(name) && requestedVersion !== "latest") {
+      const info = getInstalledPluginInfo(name);
+      if (info && info.version === requestedVersion) {
+        console.log(`[action-plugin] Plugin ${name}@${requestedVersion} is already installed`);
+        return { name, version: info.version, success: true, skipped: true };
+      }
+    }
+    if (isPluginInstalled(name) && requestedVersion === "latest") {
       const info = getInstalledPluginInfo(name);
       if (info) {
         const latestInfo = await getPluginVersion(name, "latest");
-        const latestVersion = latestInfo.version;
-        if (info.version === latestVersion) {
+        if (info.version === latestInfo.version) {
           console.log(`[action-plugin] Plugin ${name} is already up to date (version: ${info.version})`);
           return { name, version: info.version, 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: ${info.version})`);
       }
     }
     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] = {
@@ -812,7 +896,7 @@ async function remove(nameWithVersion) {
       console.error(`[action-plugin] Plugin ${name} is not installed`);
       process.exit(1);
     }
-    npmUninstall(name);
+    removePluginDirectory(name);
     const config = readConfig();
     delete config.plugins[name];
     writeConfig(config);
@@ -917,8 +1001,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 +1034,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 +1055,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 +1081,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 +1133,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 +1225,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 +1297,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 +1351,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 +1380,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 +1414,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 +1437,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 +1447,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 +1995,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 +2013,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 +2117,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 +2210,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.2",
   "description": "CLI tool for fullstack template management",
   "type": "module",
   "main": "dist/index.js",