@yumerijs/loader 3.1.0 → 3.1.2

package/dist/index.d.ts

@@ -3,6 +3,7 @@ interface Plugin {
     apply: (ctx: Context, config: Config) => Promise<void>;
     disable: (ctx: Context) => Promise<void>;
     depend: Array<string>;
+    optional?: Array<string>;
     provide: Array<string>;
     render?: string;
     config?: Schema<any>;
@@ -23,6 +24,7 @@ export declare class PluginLoader {
     plugins: {
         [name: string]: Plugin & {
             depend?: string[];
+            optional?: string[];
             provide?: string[];
         };
     };
@@ -51,12 +53,18 @@ export declare class PluginLoader {
     unregall(pluginName: string): void;
     loadConfig(configPath: string): Promise<void>;
     loadPlugins(): Promise<void>;
-    loadSinglePlugin(pluginName: string, triggerPendingCheck?: boolean, onlypending?: boolean): Promise<boolean>;
+    loadSinglePlugin(pluginName: string, triggerPendingCheck?: boolean, onlypending?: boolean, requireOptionalDependencies?: boolean): Promise<boolean>;
     private _loadPendingPlugins;
     unloadPlugin(pluginNameToUnload: string, ispending?: boolean): Promise<void>;
     private _unloadSinglePlugin;
     reloadPlugin(pluginName: string): Promise<void>;
     private watchPlugin;
+    private isMissingModuleError;
+    private isNpxInvocation;
+    private detectPackageManager;
+    private confirmPluginInstall;
+    private installMissingPlugin;
+    private importPluginModule;
     loadModule(pluginName: string): Promise<Plugin>;
     checkPluginDependencies(pluginPath: string): Promise<boolean>;
     installPluginDependencies(pluginName: string): Promise<void>;

package/dist/index.js

@@ -2,11 +2,13 @@ import * as path from 'path';
 import { Core, Logger, Context, fallback, Schema, I18n, resolvePluginModule } from '@yumerijs/core';
 import * as fs from 'fs';
 import { promisify } from 'util';
-import { exec } from 'child_process';
+import { execFile } from 'child_process';
+import { createInterface } from 'readline/promises';
+import { stdin as input, stdout as output } from 'process';
 import { fileURLToPath } from 'url';
 import * as yaml from 'js-yaml';
 import * as chokidar from 'chokidar';
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 export class PluginLoader {
     pluginsDir;
     core;
@@ -151,26 +153,20 @@ export class PluginLoader {
             this.logger.info('No enabled plugins found in configuration.');
             return;
         }
-        let loadedInLastPass = true;
-        while (loadedInLastPass) {
-            loadedInLastPass = false;
-            for (const pluginName of enabledPlugins) {
-                if (this.pluginStatus[pluginName] === "enabled" /* PluginStatus.ENABLED */) {
-                    continue;
-                }
-                const success = await this.loadSinglePlugin(pluginName, false);
-                if (success) {
-                    loadedInLastPass = true;
-                }
-            }
+        // 第一阶段：将 optional 与 depend 一样处理，尽量让可选服务先完成加载并注入。
+        while (await this._loadPendingPlugins(true)) {
+            // Continue scanning until no plugin can satisfy all required and optional dependencies.
+        }
+        // 第二阶段：严格扫描无法推进后，忽略尚未提供的 optional；depend 仍必须满足。
+        while (await this._loadPendingPlugins(false)) {
+            // Continue scanning in relaxed mode until only genuinely missing dependencies remain.
         }
-        await this._loadPendingPlugins();
         const pendingPlugins = Object.keys(this.pluginStatus).filter(p => this.pluginStatus[p] === "pending" /* PluginStatus.PENDING */);
         if (pendingPlugins.length > 0) {
-            // this.logger.warn('Some plugins could not be loaded due to unresolved dependencies:', pendingPlugins);
+            this.logger.warn('Some plugins could not be loaded due to unresolved required dependencies:', pendingPlugins);
         }
     }
-    async loadSinglePlugin(pluginName, triggerPendingCheck = true, onlypending = false) {
+    async loadSinglePlugin(pluginName, triggerPendingCheck = true, onlypending = false, requireOptionalDependencies = true) {
         if (!this.pluginStatus[pluginName]) {
             this.pluginStatus[pluginName] = "pending" /* PluginStatus.PENDING */;
         }
@@ -209,7 +205,10 @@ export class PluginLoader {
                     }
                 }
             }
-            const deps = pluginInstance.depend || [];
+            const deps = [
+                ...(pluginInstance.depend || []),
+                ...(requireOptionalDependencies ? (pluginInstance.optional || []) : []),
+            ];
             const unmetDependencies = deps.filter(dep => !this.core.components[dep] && !this.core.services[dep]);
             if (unmetDependencies.length > 0) {
                 return false;
@@ -229,7 +228,7 @@ export class PluginLoader {
             await this.core.plugin(pluginInstance, context, finalConfig);
             this.pluginStatus[pluginName] = "enabled" /* PluginStatus.ENABLED */;
             if (triggerPendingCheck) {
-                await this._loadPendingPlugins();
+                await this._loadPendingPlugins(requireOptionalDependencies);
             }
             if (this.isDev) {
                 let pluginPathToWatch = null;
@@ -263,13 +262,14 @@ export class PluginLoader {
             return false;
         }
     }
-    async _loadPendingPlugins() {
+    async _loadPendingPlugins(requireOptionalDependencies = true) {
         const pendingPlugins = Object.keys(this.pluginStatus).filter(p => this.pluginStatus[p] === "pending" /* PluginStatus.PENDING */);
-        if (pendingPlugins.length === 0)
-            return;
+        let loadedAny = false;
         for (const pluginName of pendingPlugins) {
-            await this.loadSinglePlugin(pluginName, false);
+            const loaded = await this.loadSinglePlugin(pluginName, false, true, requireOptionalDependencies);
+            loadedAny ||= loaded;
         }
+        return loadedAny;
     }
     async unloadPlugin(pluginNameToUnload, ispending = false) {
         const dependents = [];
@@ -323,7 +323,10 @@ export class PluginLoader {
         this.logger.info(`Reloading plugin: "${pluginName}"...`);
         await this.reloadConfigFile();
         await this.unloadPlugin(pluginName, true);
-        const success = await this.loadSinglePlugin(pluginName, true, false);
+        let success = await this.loadSinglePlugin(pluginName, true, false, true);
+        if (!success) {
+            success = await this.loadSinglePlugin(pluginName, true, false, false);
+        }
         if (success) {
             this.logger.info(`Plugin "${pluginName}" reloaded successfully.`);
             this.core.emit('plugin-reloaded', pluginName);
@@ -360,11 +363,91 @@ export class PluginLoader {
         });
         this.pluginWatchers[pluginName] = watcher;
     }
+    isMissingModuleError(error, moduleName) {
+        const candidate = error;
+        if (candidate?.code !== 'ERR_MODULE_NOT_FOUND')
+            return false;
+        return typeof candidate.message === 'string' && candidate.message.includes(moduleName);
+    }
+    isNpxInvocation() {
+        const argv = process.argv.map(value => value.toLowerCase());
+        const env = process.env;
+        return Boolean(env.npm_config_npx_command ||
+            env.npm_command === 'exec' ||
+            argv.some(value => /(?:^|[\\/])npx(?:\.cmd)?$/.test(value)) ||
+            (env._ && /(?:^|[\\/])npx(?:\.cmd)?$/.test(env._.toLowerCase())));
+    }
+    detectPackageManager() {
+        const cwd = process.cwd();
+        try {
+            const packageJsonPath = path.join(cwd, 'package.json');
+            if (fs.existsSync(packageJsonPath)) {
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                if (typeof packageJson.packageManager === 'string') {
+                    return packageJson.packageManager.split('@')[0];
+                }
+            }
+        }
+        catch {
+            // Fall back to lockfile detection when package.json is unavailable or invalid.
+        }
+        if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml')))
+            return 'pnpm';
+        if (fs.existsSync(path.join(cwd, 'yarn.lock')))
+            return 'yarn';
+        if (fs.existsSync(path.join(cwd, 'bun.lockb')) || fs.existsSync(path.join(cwd, 'bun.lock')))
+            return 'bun';
+        return 'npm';
+    }
+    async confirmPluginInstall(moduleName) {
+        if (!input.isTTY || !output.isTTY) {
+            this.logger.warn(`Plugin package "${moduleName}" is not installed and no interactive terminal is available.`);
+            return false;
+        }
+        const scope = this.isNpxInvocation() ? 'globally' : 'in the current project';
+        const readline = createInterface({ input, output });
+        try {
+            const answer = await readline.question(`Plugin package "${moduleName}" is not installed. Install it ${scope}? [y/N] `);
+            return /^(y|yes)$/i.test(answer.trim());
+        }
+        finally {
+            readline.close();
+        }
+    }
+    async installMissingPlugin(moduleName) {
+        const packageManager = this.detectPackageManager();
+        const global = this.isNpxInvocation();
+        const argsByManager = {
+            npm: global ? ['install', '--global', moduleName] : ['install', moduleName, '--save'],
+            yarn: global ? ['global', 'add', moduleName] : ['add', moduleName],
+            pnpm: global ? ['add', '--global', moduleName] : ['add', moduleName],
+            bun: global ? ['add', '--global', moduleName] : ['add', moduleName],
+        };
+        const args = argsByManager[packageManager] || argsByManager.npm;
+        const command = process.platform === 'win32' ? `${packageManager}.cmd` : packageManager;
+        this.logger.info(`Installing missing plugin "${moduleName}" with ${command} ${args.join(' ')}` +
+            (global ? ' (global)' : ''));
+        await execFileAsync(command, args, { cwd: process.cwd() });
+    }
+    async importPluginModule(moduleName) {
+        try {
+            return await import(moduleName);
+        }
+        catch (error) {
+            if (!this.isMissingModuleError(error, moduleName))
+                throw error;
+            const shouldInstall = await this.confirmPluginInstall(moduleName);
+            if (!shouldInstall)
+                throw error;
+            await this.installMissingPlugin(moduleName);
+            return await import(moduleName);
+        }
+    }
     async loadModule(pluginName) {
         const entry = this.getPluginEntry(pluginName);
         if (!entry)
             throw new Error(`Plugin configuration not found for instance "${pluginName}".`);
-        const pluginModule = await import(entry.moduleName);
+        const pluginModule = await this.importPluginModule(entry.moduleName);
         const context = this.getContext(pluginName, {});
         return resolvePluginModule(pluginModule, context, entry.config);
     }
@@ -372,19 +455,7 @@ export class PluginLoader {
         return true;
     }
     async installPluginDependencies(pluginName) {
-        try {
-            this.logger.info(`Installing dependencies for plugin: ${pluginName}`);
-            const { stdout, stderr } = await execAsync(`npm install ${pluginName} --save`);
-            this.logger.info(`stdout: ${stdout}`);
-            if (stderr) {
-                this.logger.error(`stderr: ${stderr}`);
-            }
-            this.logger.info(`Dependencies installed for plugin: ${pluginName}`);
-        }
-        catch (error) {
-            this.logger.error(`Error installing dependencies for plugin ${pluginName}:`, error);
-            throw error;
-        }
+        await this.installMissingPlugin(pluginName);
     }
 }
 export default PluginLoader;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yumerijs/loader",
-  "version": "3.1.0",
+  "version": "3.1.2",
   "description": "Module loader for yumeri",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",