@re-shell/cli/dist/utils/plugin-system.d.ts

Full-stack development platform uniting microservices and microfrontends. Build complete applications with .NET (ASP.NET Core Web API, Minimal API), Java (Spring Boot, Quarkus, Micronaut, Vert.x), Rust (Actix-Web, Warp, Rocket, Axum), Python (FastAPI, Dja

import * as fs from 'fs-extra';
import * as path from 'path';
import { EventEmitter } from 'events';
import chalk from 'chalk';
import { PluginLifecycleManager, PluginState, ManagedPluginRegistration } from './plugin-lifecycle';
import { PluginHookSystem, PluginHookAPI, HookType } from './plugin-hooks';
import { PluginDependencyResolver, ResolutionResult } from './plugin-dependency';
export interface PluginManifest {
    name: string;
    version: string;
    description: string;
    author?: string;
    license?: string;
    homepage?: string;
    keywords?: string[];
    main: string;
    bin?: Record<string, string>;
    engines?: {
        'reshell-cli'?: string;
        node?: string;
    };
    dependencies?: Record<string, string>;
    peerDependencies?: Record<string, string>;
    reshell?: {
        compatibility?: string;
        hooks?: string[];
        commands?: string[];
        permissions?: PluginPermission[];
        config?: PluginConfigSchema;
        plugins?: Record<string, string>;
    };
}
export interface PluginPermission {
    type: 'filesystem' | 'network' | 'process' | 'environment' | 'workspace';
    resource?: string;
    access: 'read' | 'write' | 'execute' | 'full';
    description: string;
}
export interface PluginConfigSchema {
    type: 'object';
    properties: Record<string, any>;
    required?: string[];
    additionalProperties?: boolean;
}
export interface PluginContext {
    cli: {
        version: string;
        rootPath: string;
        configPath: string;
        workspaces: Record<string, any>;
    };
    plugin: {
        name: string;
        version: string;
        config: any;
        dataPath: string;
        cachePath: string;
    };
    logger: PluginLogger;
    hooks: PluginHookSystemInterface;
    utils: PluginUtils;
}
export interface PluginLogger {
    debug(message: string, ...args: any[]): void;
    info(message: string, ...args: any[]): void;
    warn(message: string, ...args: any[]): void;
    error(message: string, ...args: any[]): void;
}
export interface PluginHookSystemInterface {
    register(hookName: string, handler: Function, options?: any): string;
    unregister(hookName: string, handlerId: string): boolean;
    execute(hookName: string, data?: any): Promise<any>;
    executeSync(hookName: string, data?: any): any[];
    onCommand(command: string, handler: Function, options?: any): string;
    onFileChange(pattern: RegExp | string, handler: Function, options?: any): string;
    onWorkspaceBuild(workspace: string, handler: Function, options?: any): string;
    getHooks(): any[];
    registerCustomHook(name: string): string;
}
export interface PluginUtils {
    path: typeof path;
    fs: typeof fs;
    chalk: typeof chalk;
    exec(command: string, options?: any): Promise<{
        stdout: string;
        stderr: string;
    }>;
    spawn(command: string, args: string[], options?: any): Promise<number>;
}
export interface Plugin {
    manifest: PluginManifest;
    activate(context: PluginContext): Promise<void> | void;
    deactivate?(context: PluginContext): Promise<void> | void;
    onCommand?(command: string, args: any[], context: PluginContext): Promise<any> | any;
    onHook?(hookName: string, data: any, context: PluginContext): Promise<any> | any;
}
export interface PluginRegistration {
    manifest: PluginManifest;
    pluginPath: string;
    isLoaded: boolean;
    isActive: boolean;
    instance?: Plugin;
    loadError?: Error;
    activationError?: Error;
    lastUsed?: number;
    usageCount: number;
}
export interface PluginDiscoveryResult {
    found: PluginRegistration[];
    errors: Array<{
        path: string;
        error: Error;
    }>;
    skipped: Array<{
        path: string;
        reason: string;
    }>;
}
export type PluginSource = 'local' | 'npm' | 'git' | 'builtin';
export interface PluginDiscoveryOptions {
    sources?: PluginSource[];
    includeDisabled?: boolean;
    includeDev?: boolean;
    maxDepth?: number;
    timeout?: number;
    useCache?: boolean;
    cacheMaxAge?: number;
}
export declare class PluginRegistry extends EventEmitter {
    private plugins;
    private discoveryCache;
    private lifecycleManager;
    private hookSystem;
    private dependencyResolver;
    private rootPath;
    private pluginPaths;
    private isInitialized;
    constructor(rootPath?: string);
    private getDefaultPluginPaths;
    private getGlobalPluginPaths;
    initialize(): Promise<void>;
    private ensurePluginDirectories;
    discoverPlugins(options?: PluginDiscoveryOptions): Promise<PluginDiscoveryResult>;
    private discoverFromSource;
    private discoverLocalPlugins;
    private discoverNpmPlugins;
    private scanNodeModules;
    private checkPackageForPlugin;
    private discoverBuiltinPlugins;
    private deduplicatePlugins;
    private validateManifest;
    registerPlugin(pluginPath: string, manifest?: PluginManifest): Promise<void>;
    unregisterPlugin(name: string): Promise<boolean>;
    getPlugins(): PluginRegistration[];
    getPlugin(name: string): PluginRegistration | undefined;
    hasPlugin(name: string): boolean;
    getPluginCount(): number;
    getActivePlugins(): PluginRegistration[];
    clearCache(): void;
    loadPlugin(pluginName: string): Promise<void>;
    initializePlugin(pluginName: string): Promise<void>;
    activatePlugin(pluginName: string): Promise<void>;
    deactivatePlugin(pluginName: string): Promise<void>;
    unloadPlugin(pluginName: string): Promise<void>;
    reloadPlugin(pluginName: string): Promise<void>;
    getManagedPlugin(name: string): ManagedPluginRegistration | undefined;
    getManagedPlugins(): ManagedPluginRegistration[];
    getPluginsByState(state: PluginState): ManagedPluginRegistration[];
    getLifecycleStats(): any;
    getLifecycleManager(): PluginLifecycleManager;
    getHookSystem(): PluginHookSystem;
    createPluginHookAPI(pluginName: string): PluginHookAPI;
    executeHooks(hookType: HookType | string, data?: any): Promise<any>;
    getHookStats(): any;
    getDependencyResolver(): PluginDependencyResolver;
    resolveDependencies(pluginName: string): Promise<ResolutionResult>;
    getDependencyStats(): any;
    private createPluginContext;
    private createPluginLogger;
    private createPluginUtils;
}
export declare function createPluginRegistry(rootPath?: string): PluginRegistry;
export declare function discoverPlugins(rootPath?: string, options?: PluginDiscoveryOptions): Promise<PluginDiscoveryResult>;
export declare function validatePluginManifest(data: any): PluginManifest;