@yumerijs/loader 3.0.1 → 3.1.1

package/dist/index.d.ts

@@ -7,6 +7,14 @@ interface Plugin {
     render?: string;
     config?: Schema<any>;
 }
+export interface PluginConfigEntry {
+    id: string;
+    moduleName: string;
+    config: any;
+    configKey: string;
+    enabled: boolean;
+    legacy: boolean;
+}
 export declare class PluginLoader {
     private pluginsDir;
     core: Core;
@@ -25,6 +33,13 @@ export declare class PluginLoader {
     private pluginContexts;
     private isDev;
     constructor(core?: Core, pluginsDir?: string);
+    /**
+     * Normalize both the legacy `{ "package-name": { ...config } }` form and
+     * the named instance form `{ "instance-id": { module, config } }`.
+     */
+    getPluginEntry(pluginId: string): PluginConfigEntry | undefined;
+    setPluginConfig(pluginId: string, config: any): boolean;
+    private getEnabledPluginEntries;
     /**
      * Reloads the config file from disk into memory and emits a 'config-reloaded' event.
      * This does NOT reload any plugins.
@@ -42,6 +57,12 @@ export declare class PluginLoader {
     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;
@@ -25,6 +27,55 @@ export class PluginLoader {
         this.isDev = process.env.NODE_ENV === 'development';
         Logger.setCore(this.core);
     }
+    /**
+     * Normalize both the legacy `{ "package-name": { ...config } }` form and
+     * the named instance form `{ "instance-id": { module, config } }`.
+     */
+    getPluginEntry(pluginId) {
+        const plugins = this.config?.plugins;
+        if (!plugins || typeof plugins !== 'object')
+            return undefined;
+        const configKey = Object.prototype.hasOwnProperty.call(plugins, pluginId)
+            ? pluginId
+            : Object.prototype.hasOwnProperty.call(plugins, `~${pluginId}`)
+                ? `~${pluginId}`
+                : undefined;
+        if (!configKey)
+            return undefined;
+        const enabled = !configKey.startsWith('~');
+        const id = enabled ? configKey : configKey.substring(1);
+        const value = plugins[configKey];
+        const isInstance = value && typeof value === 'object' && !Array.isArray(value)
+            && typeof value.module === 'string';
+        return {
+            id,
+            moduleName: isInstance ? value.module : id,
+            config: isInstance ? (value.config ?? {}) : (value ?? {}),
+            configKey,
+            enabled,
+            legacy: !isInstance,
+        };
+    }
+    setPluginConfig(pluginId, config) {
+        const entry = this.getPluginEntry(pluginId);
+        if (!entry)
+            return false;
+        if (entry.legacy) {
+            this.config.plugins[entry.configKey] = config;
+        }
+        else {
+            this.config.plugins[entry.configKey].config = config;
+        }
+        return true;
+    }
+    getEnabledPluginEntries() {
+        if (!this.config || typeof this.config.plugins !== 'object' || this.config.plugins === null) {
+            return [];
+        }
+        return Object.keys(this.config.plugins)
+            .map(key => this.getPluginEntry(key.startsWith('~') ? key.substring(1) : key))
+            .filter(entry => entry && entry.enabled);
+    }
     /**
      * Reloads the config file from disk into memory and emits a 'config-reloaded' event.
      * This does NOT reload any plugins.
@@ -84,18 +135,14 @@ export class PluginLoader {
             this.logger.info('No plugins configuration found. No plugins to load.');
             return;
         }
-        const allPluginNames = Object.keys(this.config.plugins);
+        const allEntries = Object.keys(this.config.plugins)
+            .map(key => this.getPluginEntry(key.startsWith('~') ? key.substring(1) : key))
+            .filter(Boolean);
         this.pluginStatus = {}; // Reset status
-        for (const name of allPluginNames) {
-            if (name.startsWith('~')) {
-                const actualName = name.substring(1);
-                this.pluginStatus[actualName] = "disabled" /* PluginStatus.DISABLED */;
-            }
-            else {
-                this.pluginStatus[name] = "pending" /* PluginStatus.PENDING */;
-            }
+        for (const entry of allEntries) {
+            this.pluginStatus[entry.id] = entry.enabled ? "pending" /* PluginStatus.PENDING */ : "disabled" /* PluginStatus.DISABLED */;
         }
-        const enabledPlugins = allPluginNames.filter(name => !name.startsWith('~'));
+        const enabledPlugins = allEntries.filter(entry => entry.enabled).map(entry => entry.id);
         const currentlyLoaded = Object.keys(this.plugins);
         for (const loadedName of currentlyLoaded) {
             if (!enabledPlugins.includes(loadedName)) {
@@ -170,13 +217,13 @@ export class PluginLoader {
                 return false;
             }
             this.plugins[pluginName] = pluginInstance;
-            // ### NEW CONFIG LOGIC ###
-            const rawConfig = (this.config.plugins && this.config.plugins[pluginName]) || {};
-            const schema = pluginInstance.config || Schema.object({}); // The schema is exported as 'config'
-            const finalConfig = fallback(schema, rawConfig);
-            // Update the in-memory config with the fully resolved one
-            this.config.plugins[pluginName] = finalConfig;
-            // ### END NEW CONFIG LOGIC ###
+            const entry = this.getPluginEntry(pluginName);
+            if (!entry) {
+                throw new Error(`Plugin configuration not found for instance "${pluginName}".`);
+            }
+            const schema = pluginInstance.config || Schema.object({});
+            const finalConfig = fallback(schema, entry.config);
+            this.setPluginConfig(pluginName, finalConfig);
             const context = this.getContext(pluginName, {});
             if (pluginInstance.render) {
                 context.renderer = this.core.renderers.get(pluginInstance.render || '');
@@ -188,14 +235,15 @@ export class PluginLoader {
             }
             if (this.isDev) {
                 let pluginPathToWatch = null;
+                const moduleName = entry.moduleName;
                 try {
-                    const packageJsonUrl = import.meta.resolve(`${pluginName}/package.json`);
+                    const packageJsonUrl = import.meta.resolve(`${moduleName}/package.json`);
                     const pkgJsonPath = fileURLToPath(packageJsonUrl);
                     pluginPathToWatch = path.dirname(pkgJsonPath);
                 }
                 catch (e) {
-                    const localPluginPath = path.resolve(process.cwd(), pluginName);
-                    const localPluginPathInPlugins = path.resolve(process.cwd(), 'plugins', pluginName);
+                    const localPluginPath = path.resolve(process.cwd(), moduleName);
+                    const localPluginPathInPlugins = path.resolve(process.cwd(), 'plugins', moduleName);
                     if (fs.existsSync(localPluginPath)) {
                         pluginPathToWatch = localPluginPath;
                     }
@@ -314,29 +362,99 @@ export class PluginLoader {
         });
         this.pluginWatchers[pluginName] = watcher;
     }
-    async loadModule(pluginName) {
-        const pluginModule = await import(pluginName);
-        const context = this.getContext(pluginName, {});
-        const rawConfig = (this.config.plugins && this.config.plugins[pluginName]) || {};
-        return resolvePluginModule(pluginModule, context, rawConfig);
+    isMissingModuleError(error, moduleName) {
+        const candidate = error;
+        if (candidate?.code !== 'ERR_MODULE_NOT_FOUND')
+            return false;
+        return typeof candidate.message === 'string' && candidate.message.includes(moduleName);
     }
-    async checkPluginDependencies(pluginPath) {
-        return true;
+    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())));
     }
-    async installPluginDependencies(pluginName) {
+    detectPackageManager() {
+        const cwd = process.cwd();
         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}`);
+            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];
+                }
             }
-            this.logger.info(`Dependencies installed for plugin: ${pluginName}`);
+        }
+        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) {
-            this.logger.error(`Error installing dependencies for plugin ${pluginName}:`, error);
-            throw 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 this.importPluginModule(entry.moduleName);
+        const context = this.getContext(pluginName, {});
+        return resolvePluginModule(pluginModule, context, entry.config);
+    }
+    async checkPluginDependencies(pluginPath) {
+        return true;
+    }
+    async installPluginDependencies(pluginName) {
+        await this.installMissingPlugin(pluginName);
+    }
 }
 export default PluginLoader;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yumerijs/loader",
-  "version": "3.0.1",
+  "version": "3.1.1",
   "description": "Module loader for yumeri",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,7 +29,7 @@
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.13.10",
-    "@yumerijs/core": "^3.0.0",
+    "@yumerijs/core": "^3.0.5",
     "esbuild-register": "^3.6.0",
     "typescript": "^6.0.3"
   },
@@ -41,6 +41,6 @@
     "js-yaml": "^4.1.0"
   },
   "peerDependencies": {
-    "@yumerijs/core": "^3.0.0"
+    "@yumerijs/core": "^3.0.5"
   }
 }