@lark-apaas/miaoda-cli 0.1.0-alpha.08508f4

package/dist/cli/handlers/plugin/plugin-local.js

@@ -0,0 +1,382 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectRoot = getProjectRoot;
+exports.getPluginPath = getPluginPath;
+exports.parsePluginName = parsePluginName;
+exports.readActionPlugins = readActionPlugins;
+exports.writeActionPlugins = writeActionPlugins;
+exports.isPluginInstalled = isPluginInstalled;
+exports.getInstalledPluginVersion = getInstalledPluginVersion;
+exports.getPackageVersion = getPackageVersion;
+exports.readPluginPackageJson = readPluginPackageJson;
+exports.extractTgzToNodeModules = extractTgzToNodeModules;
+exports.checkMissingPeerDeps = checkMissingPeerDeps;
+exports.installMissingDeps = installMissingDeps;
+exports.npmInstall = npmInstall;
+exports.removePluginDirectory = removePluginDirectory;
+exports.capabilitiesDirExists = capabilitiesDirExists;
+exports.readCapability = readCapability;
+exports.readAllCapabilities = readAllCapabilities;
+exports.hydrateCapability = hydrateCapability;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_module_1 = require("node:module");
+const error_1 = require("../../../utils/error");
+const logger_1 = require("../../../utils/logger");
+// ── Project paths ──
+function getProjectRoot() {
+    return process.cwd();
+}
+function getPackageJsonPath() {
+    return node_path_1.default.join(getProjectRoot(), "package.json");
+}
+function getPluginPath(pluginName) {
+    return node_path_1.default.join(getProjectRoot(), "node_modules", pluginName);
+}
+// ── Plugin name parsing ──
+function parsePluginName(input) {
+    const match = /^(@[^/]+\/[^@]+)(?:@(.+))?$/.exec(input);
+    if (!match) {
+        throw new error_1.AppError("INVALID_PLUGIN_NAME", `Invalid plugin name format: ${input}. Expected: @scope/name or @scope/name@version`, { next_actions: ["示例：@demo/example-plugin 或 @demo/example-plugin@1.2.3"] });
+    }
+    return { name: match[1], version: match[2] ?? "latest" };
+}
+// ── package.json actionPlugins CRUD ──
+function readPackageJson() {
+    const pkgPath = getPackageJsonPath();
+    if (!node_fs_1.default.existsSync(pkgPath)) {
+        throw new error_1.AppError("PKG_JSON_NOT_FOUND", "package.json not found in current directory", { next_actions: ["在应用项目根目录运行"] });
+    }
+    const content = node_fs_1.default.readFileSync(pkgPath, "utf-8");
+    return JSON.parse(content);
+}
+function writePackageJson(pkg) {
+    const pkgPath = getPackageJsonPath();
+    node_fs_1.default.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+}
+function readActionPlugins() {
+    const pkg = readPackageJson();
+    return pkg.actionPlugins ?? {};
+}
+function writeActionPlugins(plugins) {
+    const pkg = readPackageJson();
+    pkg.actionPlugins = plugins;
+    writePackageJson(pkg);
+}
+function isPluginInstalled(pluginName) {
+    const plugins = readActionPlugins();
+    return pluginName in plugins;
+}
+function getInstalledPluginVersion(pluginName) {
+    const plugins = readActionPlugins();
+    return plugins[pluginName] ?? null;
+}
+// ── node_modules operations ──
+function getPackageVersion(pluginName) {
+    const pkgJsonPath = node_path_1.default.join(getPluginPath(pluginName), "package.json");
+    if (!node_fs_1.default.existsSync(pkgJsonPath))
+        return null;
+    try {
+        const content = node_fs_1.default.readFileSync(pkgJsonPath, "utf-8");
+        const pkg = JSON.parse(content);
+        return pkg.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function readPluginPackageJson(pluginPath) {
+    const pkgJsonPath = node_path_1.default.join(pluginPath, "package.json");
+    if (!node_fs_1.default.existsSync(pkgJsonPath))
+        return null;
+    try {
+        const content = node_fs_1.default.readFileSync(pkgJsonPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+function extractTgzToNodeModules(tgzPath, pluginName) {
+    const nodeModulesPath = node_path_1.default.join(getProjectRoot(), "node_modules");
+    const targetDir = node_path_1.default.join(nodeModulesPath, pluginName);
+    const scopeDir = node_path_1.default.dirname(targetDir);
+    if (!node_fs_1.default.existsSync(scopeDir)) {
+        node_fs_1.default.mkdirSync(scopeDir, { recursive: true });
+    }
+    if (node_fs_1.default.existsSync(targetDir)) {
+        node_fs_1.default.rmSync(targetDir, { recursive: true });
+    }
+    const tempDir = node_path_1.default.join(nodeModulesPath, ".cache", "miaoda-cli", "extract-temp");
+    if (node_fs_1.default.existsSync(tempDir)) {
+        node_fs_1.default.rmSync(tempDir, { recursive: true });
+    }
+    node_fs_1.default.mkdirSync(tempDir, { recursive: true });
+    try {
+        (0, node_child_process_1.execSync)(`tar -xzf "${tgzPath}" -C "${tempDir}"`, { stdio: "pipe" });
+        const extractedDir = node_path_1.default.join(tempDir, "package");
+        if (node_fs_1.default.existsSync(extractedDir)) {
+            node_fs_1.default.renameSync(extractedDir, targetDir);
+        }
+        else {
+            const files = node_fs_1.default.readdirSync(tempDir);
+            if (files.length === 1) {
+                node_fs_1.default.renameSync(node_path_1.default.join(tempDir, files[0]), targetDir);
+            }
+            else {
+                throw new error_1.AppError("INTERNAL_EXTRACT_FAILED", "Unexpected tgz structure");
+            }
+        }
+        return targetDir;
+    }
+    finally {
+        if (node_fs_1.default.existsSync(tempDir)) {
+            node_fs_1.default.rmSync(tempDir, { recursive: true });
+        }
+    }
+}
+function checkMissingPeerDeps(peerDeps) {
+    if (!peerDeps || Object.keys(peerDeps).length === 0)
+        return [];
+    const missing = [];
+    const nodeModulesPath = node_path_1.default.join(getProjectRoot(), "node_modules");
+    for (const depName of Object.keys(peerDeps)) {
+        const depPath = node_path_1.default.join(nodeModulesPath, depName);
+        if (!node_fs_1.default.existsSync(depPath)) {
+            missing.push(depName);
+        }
+    }
+    return missing;
+}
+function installMissingDeps(deps) {
+    if (deps.length === 0)
+        return;
+    (0, logger_1.log)("plugin", `Installing missing dependencies: ${deps.join(", ")}`);
+    const result = (0, node_child_process_1.spawnSync)("npm", ["install", ...deps, "--no-save", "--no-package-lock"], { cwd: getProjectRoot(), stdio: "inherit" });
+    if (result.error) {
+        throw new error_1.AppError("INTERNAL_NPM_FAILED", `npm install failed: ${result.error.message}`, { next_actions: ["确认本机已安装 npm，可 --verbose 查看执行详情"] });
+    }
+    if (result.status !== 0) {
+        throw new error_1.AppError("INTERNAL_NPM_FAILED", `npm install failed with exit code ${String(result.status)}`, { next_actions: ["检查上方 npm 输出日志定位具体错误"] });
+    }
+}
+function npmInstall(tgzPath) {
+    const result = (0, node_child_process_1.spawnSync)("npm", ["install", tgzPath, "--no-save", "--no-package-lock", "--ignore-scripts"], { cwd: getProjectRoot(), stdio: "inherit" });
+    if (result.error) {
+        throw new error_1.AppError("INTERNAL_NPM_FAILED", `npm install failed: ${result.error.message}`, { next_actions: ["确认本机已安装 npm，可 --verbose 查看执行详情"] });
+    }
+    if (result.status !== 0) {
+        throw new error_1.AppError("INTERNAL_NPM_FAILED", `npm install failed with exit code ${String(result.status)}`, { next_actions: ["检查上方 npm 输出日志定位具体错误"] });
+    }
+}
+function removePluginDirectory(pluginName) {
+    const pluginPath = getPluginPath(pluginName);
+    if (node_fs_1.default.existsSync(pluginPath)) {
+        node_fs_1.default.rmSync(pluginPath, { recursive: true });
+    }
+}
+// ── Capability FS ──
+const CAPABILITIES_DIR = "server/capabilities";
+function getCapabilitiesDir() {
+    return node_path_1.default.join(getProjectRoot(), CAPABILITIES_DIR);
+}
+function capabilitiesDirExists() {
+    return node_fs_1.default.existsSync(getCapabilitiesDir());
+}
+function listCapabilityIds() {
+    const dir = getCapabilitiesDir();
+    if (!node_fs_1.default.existsSync(dir))
+        return [];
+    const files = node_fs_1.default.readdirSync(dir);
+    return files
+        .filter((f) => f.endsWith(".json") && f !== "capabilities.json")
+        .map((f) => f.replace(/\.json$/, ""));
+}
+function readCapability(id) {
+    const filePath = node_path_1.default.join(getCapabilitiesDir(), `${id}.json`);
+    if (!node_fs_1.default.existsSync(filePath)) {
+        throw new error_1.AppError("CAPABILITY_NOT_FOUND", `Capability not found: ${id}`, { next_actions: ["运行 miaoda plugin list 查看所有可用 capability id"] });
+    }
+    try {
+        const content = node_fs_1.default.readFileSync(filePath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new error_1.AppError("INVALID_JSON", `Invalid JSON in capability file: ${id}.json`, { next_actions: [`检查 server/capabilities/${id}.json 的 JSON 语法`] });
+        }
+        throw error;
+    }
+}
+function readAllCapabilities() {
+    const ids = listCapabilityIds();
+    const capabilities = [];
+    for (const id of ids) {
+        try {
+            const cap = readCapability(id);
+            if (!cap.pluginKey)
+                continue;
+            capabilities.push(cap);
+        }
+        catch {
+            continue;
+        }
+    }
+    return capabilities;
+}
+// ── Capability Hydration ──
+function getPluginManifestPath(pluginKey) {
+    return node_path_1.default.join(getProjectRoot(), "node_modules", pluginKey, "manifest.json");
+}
+function readPluginManifest(pluginKey) {
+    const manifestPath = getPluginManifestPath(pluginKey);
+    if (!node_fs_1.default.existsSync(manifestPath)) {
+        throw new error_1.AppError("MANIFEST_NOT_FOUND", `Plugin not installed: ${pluginKey} (manifest.json not found)`, { next_actions: [`运行 miaoda plugin install ${pluginKey}`] });
+    }
+    try {
+        const content = node_fs_1.default.readFileSync(manifestPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new error_1.AppError("INVALID_JSON", `Invalid JSON in plugin manifest: ${pluginKey}/manifest.json`, { next_actions: [`检查 node_modules/${pluginKey}/manifest.json 的 JSON 语法`] });
+        }
+        throw error;
+    }
+}
+function isDynamicSchema(schema) {
+    return (schema !== undefined &&
+        typeof schema === "object" &&
+        "dynamic" in schema &&
+        schema.dynamic === true);
+}
+function hasValidParamsSchema(paramsSchema) {
+    return paramsSchema !== undefined && Object.keys(paramsSchema).length > 0;
+}
+async function loadPlugin(pluginKey) {
+    try {
+        const userRequire = (0, node_module_1.createRequire)(node_path_1.default.join(getProjectRoot(), "package.json"));
+        const resolvedPath = userRequire.resolve(pluginKey);
+        const pluginModule = (await Promise.resolve(`${resolvedPath}`).then(s => __importStar(require(s))));
+        const pluginPackage = (pluginModule.default ?? pluginModule);
+        if (typeof pluginPackage.create !== "function") {
+            throw new error_1.AppError("INTERNAL_PLUGIN_LOAD_FAILED", `Plugin ${pluginKey} does not export a valid create function`, { next_actions: [`该插件包版本可能过旧，尝试 miaoda plugin update ${pluginKey}`] });
+        }
+        return pluginPackage;
+    }
+    catch (error) {
+        if (error.code === "MODULE_NOT_FOUND") {
+            throw new error_1.AppError("PLUGIN_NOT_FOUND", `Plugin not installed: ${pluginKey}`, { next_actions: [`运行 miaoda plugin install ${pluginKey}`] });
+        }
+        throw new error_1.AppError("INTERNAL_PLUGIN_LOAD_FAILED", `Failed to load plugin ${pluginKey}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function hydrateCapability(capability) {
+    try {
+        const manifest = readPluginManifest(capability.pluginKey);
+        if (manifest.actions.length === 0) {
+            throw new error_1.AppError("INTERNAL_PLUGIN_LOAD_FAILED", `Plugin ${capability.pluginKey} has no actions defined`);
+        }
+        const hasDynamic = manifest.actions.some((action) => isDynamicSchema(action.inputSchema) ||
+            isDynamicSchema(action.outputSchema));
+        let pluginInstance = null;
+        if (hasDynamic) {
+            const plugin = await loadPlugin(capability.pluginKey);
+            pluginInstance = plugin.create(capability.formValue);
+        }
+        const actions = [];
+        for (let index = 0; index < manifest.actions.length; index++) {
+            const manifestAction = manifest.actions[index];
+            // inputSchema
+            let inputSchema;
+            if (index === 0 && hasValidParamsSchema(capability.paramsSchema)) {
+                inputSchema = capability.paramsSchema;
+            }
+            else if (isDynamicSchema(manifestAction.inputSchema)) {
+                if (!pluginInstance) {
+                    throw new error_1.AppError("INTERNAL_SCHEMA_ERROR", "Plugin instance not available for dynamic schema");
+                }
+                const jsonSchema = pluginInstance.getInputJsonSchema(manifestAction.key);
+                if (!jsonSchema) {
+                    throw new error_1.AppError("INTERNAL_SCHEMA_ERROR", `Failed to get input schema for action: ${manifestAction.key}`, { next_actions: [`检查插件 ${capability.pluginKey} 的 getInputJsonSchema 实现`] });
+                }
+                inputSchema = jsonSchema;
+            }
+            else {
+                inputSchema = manifestAction.inputSchema;
+            }
+            // outputSchema
+            let outputSchema;
+            if (isDynamicSchema(manifestAction.outputSchema)) {
+                if (!pluginInstance) {
+                    throw new error_1.AppError("INTERNAL_SCHEMA_ERROR", "Plugin instance not available for dynamic schema");
+                }
+                const jsonSchema = pluginInstance.getOutputJsonSchema(manifestAction.key, capability.formValue);
+                if (!jsonSchema) {
+                    throw new error_1.AppError("INTERNAL_SCHEMA_ERROR", `Failed to get output schema for action: ${manifestAction.key}`, { next_actions: [`检查插件 ${capability.pluginKey} 的 getOutputJsonSchema 实现`] });
+                }
+                outputSchema = jsonSchema;
+            }
+            else {
+                outputSchema = manifestAction.outputSchema;
+            }
+            actions.push({
+                key: manifestAction.key,
+                inputSchema,
+                outputSchema,
+                outputMode: manifestAction.outputMode || "",
+            });
+        }
+        return {
+            id: capability.id,
+            pluginKey: capability.pluginKey,
+            pluginVersion: capability.pluginVersion,
+            name: capability.name,
+            description: capability.description,
+            actions,
+            createdAt: capability.createdAt,
+            updatedAt: capability.updatedAt,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ...capability, _hydrateError: message };
+    }
+}

package/dist/cli/handlers/plugin/plugin.js

@@ -0,0 +1,308 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePluginInstall = handlePluginInstall;
+exports.handlePluginUpdate = handlePluginUpdate;
+exports.handlePluginRemove = handlePluginRemove;
+exports.handlePluginInit = handlePluginInit;
+exports.handlePluginList = handlePluginList;
+exports.handlePluginListPlugins = handlePluginListPlugins;
+const api = __importStar(require("../../../api/index"));
+const output_1 = require("../../../utils/output");
+const error_1 = require("../../../utils/error");
+const logger_1 = require("../../../utils/logger");
+const plugin_local_1 = require("./plugin-local");
+const log = (msg) => { (0, logger_1.log)("plugin", msg); };
+// ── Install ──
+function syncActionPluginsRecord(name, version) {
+    const plugins = (0, plugin_local_1.readActionPlugins)();
+    if (plugins[name] !== version) {
+        plugins[name] = version;
+        (0, plugin_local_1.writeActionPlugins)(plugins);
+        log(`Synced record: ${name}@${version}`);
+    }
+}
+async function installOne(nameWithVersion) {
+    const { name, version: requestedVersion } = (0, plugin_local_1.parsePluginName)(nameWithVersion);
+    try {
+        log(`Installing ${name}@${requestedVersion}...`);
+        const actualVersion = (0, plugin_local_1.getPackageVersion)(name);
+        if (actualVersion && requestedVersion !== "latest") {
+            if (actualVersion === requestedVersion) {
+                log(`${name}@${requestedVersion} already installed`);
+                syncActionPluginsRecord(name, actualVersion);
+                api.plugin.reportCreateInstanceEvent(name, actualVersion).catch(() => { });
+                return { name, version: actualVersion, success: true, skipped: true };
+            }
+        }
+        let targetVersion = requestedVersion;
+        if (requestedVersion === "latest") {
+            const latestInfo = await api.plugin.getPluginVersion(name, "latest");
+            targetVersion = latestInfo.version;
+            if (actualVersion === targetVersion) {
+                log(`${name} already up to date (${actualVersion})`);
+                syncActionPluginsRecord(name, actualVersion);
+                api.plugin.reportCreateInstanceEvent(name, actualVersion).catch(() => { });
+                return { name, version: actualVersion, success: true, skipped: true };
+            }
+            log(`Found newer version: ${targetVersion} (installed: ${actualVersion ?? "none"})`);
+        }
+        let tgzPath;
+        let fromCache = false;
+        if (api.plugin.hasCachedPlugin(name, targetVersion)) {
+            log(`Using cached ${name}@${targetVersion}`);
+            tgzPath = api.plugin.getCachePath(name, targetVersion);
+            fromCache = true;
+        }
+        else {
+            log(`Downloading ${name}@${targetVersion}...`);
+            const downloadResult = await api.plugin.downloadPlugin(name, requestedVersion);
+            tgzPath = downloadResult.tgzPath;
+        }
+        log("Extracting to node_modules...");
+        const pluginDir = (0, plugin_local_1.extractTgzToNodeModules)(tgzPath, name);
+        const pluginPkg = (0, plugin_local_1.readPluginPackageJson)(pluginDir);
+        if (pluginPkg?.peerDependencies) {
+            const missingDeps = (0, plugin_local_1.checkMissingPeerDeps)(pluginPkg.peerDependencies);
+            if (missingDeps.length > 0) {
+                (0, plugin_local_1.installMissingDeps)(missingDeps);
+            }
+        }
+        const installedVersion = (0, plugin_local_1.getPackageVersion)(name) ?? targetVersion;
+        const plugins = (0, plugin_local_1.readActionPlugins)();
+        plugins[name] = installedVersion;
+        (0, plugin_local_1.writeActionPlugins)(plugins);
+        const source = fromCache ? "from cache" : "downloaded";
+        log(`Installed ${name}@${installedVersion} (${source})`);
+        api.plugin.reportInstallEvent(name, installedVersion).catch(() => { });
+        api.plugin.reportCreateInstanceEvent(name, installedVersion).catch(() => { });
+        return { name, version: installedVersion, success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log(`Failed to install ${name}: ${message}`);
+        return { name, version: requestedVersion, success: false, error: message };
+    }
+}
+async function handlePluginInstall(opts) {
+    const { names } = opts;
+    const results = [];
+    for (const n of names) {
+        const result = await installOne(n);
+        results.push(result);
+    }
+    (0, output_1.emit)({
+        installed: results.filter((r) => r.success && !r.skipped).map((r) => `${r.name}@${r.version}`),
+        skipped: results.filter((r) => r.skipped).map((r) => r.name),
+        failed: results.filter((r) => !r.success).map((r) => ({ name: r.name, error: r.error })),
+    });
+    if (results.some((r) => !r.success)) {
+        process.exitCode = 1;
+    }
+}
+// ── Update ──
+async function updateOne(nameWithVersion) {
+    const { name } = (0, plugin_local_1.parsePluginName)(nameWithVersion);
+    try {
+        log(`Updating ${name}...`);
+        if (!(0, plugin_local_1.isPluginInstalled)(name)) {
+            log(`${name} is not installed`);
+            return { name, success: false, notInstalled: true };
+        }
+        const oldVersion = (0, plugin_local_1.getInstalledPluginVersion)(name) ?? "unknown";
+        log(`Current version: ${oldVersion}`);
+        const downloadResult = await api.plugin.downloadPlugin(name, "latest");
+        if (oldVersion === downloadResult.version) {
+            log(`${name} already up to date (${downloadResult.version})`);
+            return {
+                name,
+                oldVersion,
+                newVersion: downloadResult.version,
+                success: true,
+                skipped: true,
+            };
+        }
+        (0, plugin_local_1.npmInstall)(downloadResult.tgzPath);
+        const installedVersion = (0, plugin_local_1.getPackageVersion)(name) ?? downloadResult.version;
+        const plugins = (0, plugin_local_1.readActionPlugins)();
+        plugins[name] = installedVersion;
+        (0, plugin_local_1.writeActionPlugins)(plugins);
+        log(`Updated ${name}: ${oldVersion} → ${installedVersion}`);
+        return { name, oldVersion, newVersion: installedVersion, success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log(`Failed to update ${name}: ${message}`);
+        return { name, success: false, error: message };
+    }
+}
+async function handlePluginUpdate(opts) {
+    const { names } = opts;
+    const results = [];
+    for (const n of names) {
+        const result = await updateOne(n);
+        results.push(result);
+    }
+    (0, output_1.emit)({
+        updated: results
+            .filter((r) => r.success && !r.skipped)
+            .map((r) => ({ name: r.name, from: r.oldVersion, to: r.newVersion })),
+        skipped: results.filter((r) => r.skipped).map((r) => r.name),
+        notInstalled: results.filter((r) => r.notInstalled).map((r) => r.name),
+        failed: results
+            .filter((r) => !r.success && !r.notInstalled)
+            .map((r) => ({ name: r.name, error: r.error })),
+    });
+    if (results.some((r) => !r.success && !r.notInstalled)) {
+        process.exitCode = 1;
+    }
+}
+// ── Remove ──
+function handlePluginRemove(opts) {
+    const { name } = (0, plugin_local_1.parsePluginName)(opts.name);
+    if (!(0, plugin_local_1.isPluginInstalled)(name)) {
+        throw new error_1.AppError("PLUGIN_NOT_FOUND", `Plugin ${name} is not installed`, { next_actions: ["运行 miaoda plugin list-packages 查看已安装插件"] });
+    }
+    (0, plugin_local_1.removePluginDirectory)(name);
+    const plugins = (0, plugin_local_1.readActionPlugins)();
+    const { [name]: _, ...remaining } = plugins;
+    (0, plugin_local_1.writeActionPlugins)(remaining);
+    (0, output_1.emit)({ removed: name });
+}
+// ── Init ──
+async function installOneForInit(name, version) {
+    try {
+        const installedVersion = (0, plugin_local_1.getPackageVersion)(name);
+        if (installedVersion === version) {
+            return { name, version, success: true, skipped: true };
+        }
+        let tgzPath;
+        let fromCache = false;
+        if (api.plugin.hasCachedPlugin(name, version)) {
+            log(`Restoring ${name}@${version} from cache...`);
+            tgzPath = api.plugin.getCachePath(name, version);
+            fromCache = true;
+        }
+        else {
+            log(`Downloading ${name}@${version}...`);
+            const downloadResult = await api.plugin.downloadPlugin(name, version);
+            tgzPath = downloadResult.tgzPath;
+        }
+        const pluginDir = (0, plugin_local_1.extractTgzToNodeModules)(tgzPath, name);
+        const pluginPkg = (0, plugin_local_1.readPluginPackageJson)(pluginDir);
+        if (pluginPkg?.peerDependencies) {
+            const missingDeps = (0, plugin_local_1.checkMissingPeerDeps)(pluginPkg.peerDependencies);
+            if (missingDeps.length > 0) {
+                (0, plugin_local_1.installMissingDeps)(missingDeps);
+            }
+        }
+        const source = fromCache ? "from cache" : "downloaded";
+        log(`Installed ${name}@${version} (${source})`);
+        return { name, version, success: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log(`Failed to install ${name}: ${message}`);
+        return { name, version, success: false, error: message };
+    }
+}
+async function handlePluginInit() {
+    const plugins = (0, plugin_local_1.readActionPlugins)();
+    const entries = Object.entries(plugins);
+    if (entries.length === 0) {
+        (0, output_1.emit)({ message: "No plugins found in package.json", installed: [], skipped: [] });
+        return;
+    }
+    log(`Found ${String(entries.length)} plugin(s) to install`);
+    const results = [];
+    for (const [name, version] of entries) {
+        const result = await installOneForInit(name, version);
+        results.push(result);
+    }
+    (0, output_1.emit)({
+        installed: results.filter((r) => r.success && !r.skipped).map((r) => `${r.name}@${r.version}`),
+        skipped: results.filter((r) => r.skipped).map((r) => r.name),
+        failed: results.filter((r) => !r.success).map((r) => ({ name: r.name, error: r.error })),
+    });
+    if (results.some((r) => !r.success)) {
+        process.exitCode = 1;
+    }
+}
+// ── List (capability configs) ──
+async function handlePluginList(opts) {
+    if (!(0, plugin_local_1.capabilitiesDirExists)()) {
+        throw new error_1.AppError("CAPABILITIES_DIR_NOT_FOUND", "server/capabilities directory not found", { next_actions: ["当前目录必须是含 server/capabilities/ 的应用项目"] });
+    }
+    if (opts.id) {
+        const capability = (0, plugin_local_1.readCapability)(opts.id);
+        if (opts.summary) {
+            (0, output_1.emit)(capability);
+        }
+        else {
+            const hydrated = await (0, plugin_local_1.hydrateCapability)(capability);
+            (0, output_1.emit)(hydrated);
+        }
+    }
+    else {
+        const capabilities = (0, plugin_local_1.readAllCapabilities)();
+        if (capabilities.length === 0) {
+            (0, output_1.emit)([]);
+            return;
+        }
+        if (opts.summary) {
+            (0, output_1.emit)(capabilities);
+        }
+        else {
+            const hydrated = [];
+            for (const cap of capabilities) {
+                const result = await (0, plugin_local_1.hydrateCapability)(cap);
+                hydrated.push(result);
+            }
+            (0, output_1.emit)(hydrated);
+        }
+    }
+}
+// ── List plugins (installed) ──
+function handlePluginListPlugins() {
+    const plugins = Object.entries((0, plugin_local_1.readActionPlugins)());
+    if (plugins.length === 0) {
+        (0, output_1.emit)({ plugins: [], total: 0 });
+        return;
+    }
+    (0, output_1.emit)({
+        plugins: plugins.map(([name, version]) => ({ name, version })),
+        total: plugins.length,
+    });
+}