@runium/cli 0.0.2 → 0.0.3

package/src/app.ts

@@ -0,0 +1,190 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { Command } from 'commander';
+import { Container } from 'typedi';
+import { RuniumError } from '@runium/core';
+import * as commands from '@commands';
+import {
+  CommandService,
+  ConfigService,
+  ProfileService,
+  PluginService,
+  ShutdownService,
+  OutputService,
+  OutputLevel,
+  PluginContextService,
+} from '@services';
+import { getVersion } from '@utils';
+
+const RUNIUM_DESCRIPTION = `╔═══════════════════════╗
+║ ╔═╗ ╦ ╦ ╔╗╔ ╦ ╦ ╦ ╔╦╗ ║
+║ ╠╦╝ ║ ║ ║║║ ║ ║ ║ ║║║ ║
+║ ╩╚═ ╚═╝ ╝╚╝ ╩ ╚═╝ ╩ ╩ ║
+╚═══════════════════════╝
+One Tool to Run Them All!`;
+
+export class RuniumCliApp {
+  private readonly program: Command;
+
+  private commandService: CommandService;
+  private configService: ConfigService;
+  private profileService: ProfileService;
+  private pluginService: PluginService;
+  private shutdownService: ShutdownService;
+  private outputService: OutputService;
+  private pluginContextService: PluginContextService;
+
+  constructor() {
+    this.program = new Command('runium');
+    this.configService = Container.get(ConfigService);
+    this.profileService = Container.get(ProfileService);
+    this.pluginService = Container.get(PluginService);
+    this.shutdownService = Container.get(ShutdownService);
+    this.outputService = Container.get(OutputService);
+    this.pluginContextService = Container.get(PluginContextService);
+    this.commandService = Container.get(CommandService);
+  }
+
+  /**
+   * Start the application
+   */
+  async start(): Promise<Command> {
+    await this.configService.init().catch(error => {
+      this.initOutput();
+      throw error;
+    });
+    await this.shutdownService.init();
+    await this.profileService.init();
+    await this.pluginContextService.init();
+
+    this.initOutput();
+    this.initEnv();
+
+    await this.loadPlugins();
+    await this.initProgram();
+    await this.initPlugins();
+
+    return this.program.parseAsync();
+  }
+
+  /**
+   * Load plugins
+   */
+  private async loadPlugins(): Promise<void> {
+    const plugins = this.profileService.getPlugins();
+    for (const plugin of plugins) {
+      if (plugin.disabled !== true) {
+        try {
+          const pluginPath = this.pluginService.resolvePath(
+            plugin.path,
+            plugin.file
+          );
+          await this.pluginService.loadPlugin(pluginPath, plugin.options);
+        } catch (error) {
+          this.outputService.error(`Failed to load plugin "${plugin.name}"`);
+          const { code, message, payload } = error as RuniumError;
+          this.outputService.debug('Error details:', {
+            message,
+            code,
+            payload,
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Initialize the program
+   */
+  private async initProgram(): Promise<void> {
+    const program = this.program;
+
+    program.option('-D, --debug', 'enable debug mode');
+    program.option('-E, --env [paths...]', 'load env files');
+    program.version(getVersion());
+    program.description(RUNIUM_DESCRIPTION);
+
+    program.on('option:debug', () => {
+      this.setDebugMode();
+    });
+
+    program.on('option:env', path => {
+      this.loadEnvFiles([path]);
+    });
+
+    Object.values(commands).forEach(CommandConstructor => {
+      this.commandService.registerCommand(CommandConstructor, program);
+    });
+  }
+
+  /**
+   * Initialize the output
+   */
+  private initOutput(): void {
+    const output = this.configService.get('output');
+    if (
+      output.debug ||
+      process.argv.includes('-D') ||
+      process.argv.includes('--debug')
+    ) {
+      this.setDebugMode();
+    }
+  }
+
+  /**
+   * Set debug mode
+   */
+  private setDebugMode(): void {
+    if (this.outputService.getLevel() !== OutputLevel.DEBUG) {
+      this.outputService.setLevel(OutputLevel.DEBUG);
+      this.outputService.debug('Debug mode enabled');
+    }
+  }
+
+  /**
+   * Initialize the environment
+   */
+  private initEnv(): void {
+    const env = this.configService.get('env');
+    if (env.path.length > 0) {
+      this.loadEnvFiles(env.path);
+    }
+  }
+
+  /**
+   * Set environment variables
+   * @param path
+   */
+  private loadEnvFiles(path: string[]): void {
+    for (const p of path) {
+      const envPath = resolve((p && p.trim()) || '.env');
+      if (existsSync(envPath)) {
+        process.loadEnvFile(envPath);
+      } else {
+        this.outputService.error(`Env file "${envPath}" not found`);
+      }
+    }
+  }
+
+  /**
+   * Initialize plugins
+   */
+  private async initPlugins(): Promise<void> {
+    const plugins = this.pluginService.getAllPlugins();
+    for (const plugin of plugins) {
+      const commands = plugin.app?.commands;
+      if (commands) {
+        for (const command of commands) {
+          this.commandService.registerCommand(
+            command,
+            this.program,
+            plugin.name
+          );
+        }
+      }
+    }
+    await this.pluginService.runHook('app.afterInit', {
+      profilePath: this.configService.get('profile').path,
+    });
+  }
+}

package/src/commands/index.ts

@@ -0,0 +1,2 @@
+export { PluginCommand } from '@commands/plugin/plugin.js';
+export { ProjectCommand } from '@commands/project/project.js';

package/src/commands/plugin/plugin-add.ts

@@ -0,0 +1,48 @@
+import { RuniumError } from '@runium/core';
+import { ErrorCode } from '@constants';
+import { PluginCommand } from './plugin-command.js';
+/**
+ * Plugin add command
+ */
+export class PluginAddCommand extends PluginCommand {
+  /**
+   * Config command
+   */
+  protected config(): void {
+    this.command
+      .name('add')
+      .description('add plugin')
+      .option('-f, --file', 'use file path instead of plugin package name')
+      .argument('<plugin>', 'plugin package name or absolute file path');
+  }
+
+  /**
+   * Handle command
+   * @param path
+   * @param file
+   */
+  protected async handle(
+    path: string,
+    { file: isFile }: { file: boolean }
+  ): Promise<void> {
+    const pluginPath = this.pluginService.resolvePath(path, isFile);
+    const name = await this.pluginService.loadPlugin(pluginPath, {});
+    const plugin = this.pluginService.getPluginByName(name);
+    if (plugin) {
+      await this.profileService.addPlugin({
+        name,
+        path: isFile ? pluginPath : path,
+        file: isFile,
+        disabled: false,
+        options: plugin.options ?? {},
+      });
+      this.outputService.success(`Plugin "%s" successfully added`, name);
+    } else {
+      throw new RuniumError(
+        `Failed to add plugin "${path}"`,
+        ErrorCode.PLUGIN_NOT_FOUND,
+        { name, path }
+      );
+    }
+  }
+}

package/src/commands/plugin/plugin-command.ts

@@ -0,0 +1,36 @@
+import { Command } from 'commander';
+import { Container } from 'typedi';
+import { RuniumError } from '@runium/core';
+import { RuniumCommand } from '@commands/runium-command.js';
+import { ErrorCode } from '@constants';
+import { PluginService, ProfileService, ProfilePlugin } from '@services';
+
+/**
+ * Base plugin command
+ */
+export abstract class PluginCommand extends RuniumCommand {
+  protected pluginService: PluginService;
+  protected profileService: ProfileService;
+
+  constructor(parent: Command) {
+    super(parent);
+    this.pluginService = Container.get(PluginService);
+    this.profileService = Container.get(ProfileService);
+  }
+
+  /**
+   * Ensure plugin exists
+   * @param name
+   */
+  protected ensureProfilePlugin(name: string): ProfilePlugin {
+    const plugin = this.profileService.getPluginByName(name);
+    if (!plugin) {
+      throw new RuniumError(
+        `Plugin "${name}" not found`,
+        ErrorCode.PLUGIN_NOT_FOUND,
+        { name }
+      );
+    }
+    return plugin;
+  }
+}

package/src/commands/plugin/plugin-disable.ts

@@ -0,0 +1,46 @@
+import { PluginCommand } from './plugin-command.js';
+
+/**
+ * Plugin disable command
+ */
+export class PluginDisableCommand extends PluginCommand {
+  /**
+   * Config command
+   */
+  protected config(): void {
+    this.command
+      .name('disable')
+      .description('disable plugin')
+      .option('-a, --all', 'disable all plugins')
+      .argument('[name...]', 'plugin names');
+  }
+
+  /**
+   * Handle command
+   * @param names
+   * @param all
+   */
+  protected async handle(
+    names: string[],
+    { all }: { all: boolean }
+  ): Promise<void> {
+    if (names.length === 0 && !all) {
+      this.outputService.warn('No plugins specified to disable');
+      return;
+    }
+    if (all) {
+      names = this.profileService.getPlugins().map(p => p.name);
+    }
+
+    for (const name of names) {
+      const plugin = this.ensureProfilePlugin(name);
+      if (plugin.disabled) {
+        this.outputService.info(`Plugin "%s" is already disabled`, name);
+        continue;
+      }
+      await this.profileService.updatePlugin(name, { disabled: true });
+      await this.pluginService.unloadPlugin(name);
+      this.outputService.success(`Plugin "%s" successfully disabled`, name);
+    }
+  }
+}

package/src/commands/plugin/plugin-enable.ts

@@ -0,0 +1,50 @@
+import { PluginCommand } from './plugin-command.js';
+
+/**
+ * Plugin enable command
+ */
+export class PluginEnableCommand extends PluginCommand {
+  /**
+   * Config command
+   */
+  protected config(): void {
+    this.command
+      .name('enable')
+      .description('enable plugin')
+      .option('-a, --all', 'enable all plugins')
+      .argument('[name...]', 'plugin names');
+  }
+
+  /**
+   * Handle command
+   * @param names
+   * @param all
+   */
+  protected async handle(
+    names: string[],
+    { all }: { all: boolean }
+  ): Promise<void> {
+    if (names.length === 0 && !all) {
+      this.outputService.warn('No plugins specified to enable');
+      return;
+    }
+    if (all) {
+      names = this.profileService.getPlugins().map(p => p.name);
+    }
+
+    for (const name of names) {
+      const plugin = this.ensureProfilePlugin(name);
+      if (!plugin.disabled) {
+        this.outputService.info(`Plugin "%s" is already enabled`, name);
+        continue;
+      }
+      await this.profileService.updatePlugin(name, { disabled: false });
+      const pluginPath = this.pluginService.resolvePath(
+        plugin.path,
+        plugin.file
+      );
+      await this.pluginService.loadPlugin(pluginPath, plugin.options);
+      this.outputService.success(`Plugin "%s" successfully enabled`, name);
+    }
+  }
+}

package/src/commands/plugin/plugin-list.ts

@@ -0,0 +1,61 @@
+import { Option } from 'commander';
+import { PluginCommand } from './plugin-command.js';
+
+/**
+ * Plugin list command
+ */
+export class PluginListCommand extends PluginCommand {
+  /**
+   * Config command
+   */
+  protected config(): void {
+    this.command
+      .name('list')
+      .addOption(
+        new Option('-d, --disabled', 'show only disabled plugins').conflicts(
+          'enabled'
+        )
+      )
+      .addOption(
+        new Option('-e, --enabled', 'show only enabled plugins').conflicts(
+          'disabled'
+        )
+      )
+      .option('-s, --sort', 'sort by name')
+      .description('list plugins');
+  }
+
+  /**
+   * Handle command
+   */
+  protected async handle({
+    disabled,
+    enabled,
+    sort,
+  }: {
+    disabled: boolean;
+    enabled: boolean;
+    sort: boolean;
+  }): Promise<void> {
+    let plugins = this.profileService.getPlugins();
+    if (disabled) {
+      plugins = plugins.filter(p => p.disabled === true);
+    }
+    if (enabled) {
+      plugins = plugins.filter(p => p.disabled === false);
+    }
+    if (sort) {
+      plugins.sort((a, b) => a.name.localeCompare(b.name));
+    }
+
+    if (plugins.length !== 0) {
+      this.outputService.table(plugins, [
+        'name',
+        'path',
+        ...(disabled || enabled ? [] : ['disabled']),
+      ]);
+    } else {
+      this.outputService.warn('No plugins found');
+    }
+  }
+}

package/src/commands/plugin/plugin-remove.ts

@@ -0,0 +1,42 @@
+import { PluginCommand } from './plugin-command.js';
+
+/**
+ * Plugin remove command
+ */
+export class PluginRemoveCommand extends PluginCommand {
+  /**
+   * Config command
+   */
+  protected config(): void {
+    this.command
+      .name('remove')
+      .description('remove plugin')
+      .option('-a, --all', 'remove all plugins')
+      .argument('[name...]', 'plugin names');
+  }
+
+  /**
+   * Handle command
+   * @param names
+   * @param all
+   */
+  protected async handle(
+    names: string[],
+    { all }: { all: boolean }
+  ): Promise<void> {
+    if (names.length === 0 && !all) {
+      this.outputService.warn('No plugins specified to remove');
+      return;
+    }
+    if (all) {
+      names = this.profileService.getPlugins().map(p => p.name);
+    }
+
+    for (const name of names) {
+      this.ensureProfilePlugin(name);
+      await this.profileService.removePlugin(name);
+      await this.pluginService.unloadPlugin(name);
+      this.outputService.success(`Plugin "%s" successfully removed`, name);
+    }
+  }
+}

package/src/commands/plugin/plugin.ts

@@ -0,0 +1,36 @@
+import { RuniumCommand } from '@commands/runium-command.js';
+import { PluginAddCommand } from './plugin-add.js';
+import { PluginDisableCommand } from './plugin-disable.js';
+import { PluginEnableCommand } from './plugin-enable.js';
+import { PluginListCommand } from './plugin-list.js';
+import { PluginRemoveCommand } from './plugin-remove.js';
+
+/**
+ * Plugin group command
+ */
+export class PluginCommand extends RuniumCommand {
+  /**
+   * Subcommands
+   */
+  subcommands = [
+    PluginListCommand,
+    PluginAddCommand,
+    PluginRemoveCommand,
+    PluginDisableCommand,
+    PluginEnableCommand,
+  ];
+
+  /**
+   * Config command
+   */
+  protected config(): void {
+    this.command.name('plugin').description('manage plugins');
+  }
+
+  /**
+   * Handle command
+   */
+  protected async handle(): Promise<void> {
+    this.command.help();
+  }
+}

package/src/commands/project/project-add.ts

@@ -0,0 +1,64 @@
+import { ID_REGEX, RuniumError } from '@runium/core';
+import { ErrorCode } from '@constants';
+import { ProjectCommand } from './project-command.js';
+
+/**
+ * Project add command
+ */
+export class ProjectAddCommand extends ProjectCommand {
+  /**
+   * Config command
+   */
+  protected config(): void {
+    this.command
+      .name('add')
+      .description('add project')
+      .argument('<path>', 'project file path')
+      .argument('[name]', 'project name (default: project config id)');
+  }
+
+  /**
+   * Handle command
+   * @param path
+   * @param name
+   */
+  protected async handle(path: string, name?: string): Promise<void> {
+    const projectPath = this.projectService.resolvePath(path);
+    const project = await this.projectService.initProject(projectPath);
+    if (project) {
+      const projectName = name ?? project.getConfig().id;
+
+      this.validateProjectName(projectName);
+
+      await this.profileService.addProject({
+        name: projectName,
+        path: projectPath,
+      });
+      this.outputService.success(
+        `Project "%s" successfully added`,
+        projectName
+      );
+    } else {
+      throw new RuniumError(
+        `Failed to add project "${projectPath}"`,
+        ErrorCode.PROJECT_NOT_FOUND,
+        { path: projectPath }
+      );
+    }
+  }
+
+  /**
+   * Validate project name
+   * @param name - project name to validate
+   * @throws RuniumError if name contains invalid characters
+   */
+  private validateProjectName(name: string): void {
+    if (!ID_REGEX.test(name)) {
+      throw new RuniumError(
+        `Invalid project name "${name}". Only letters, digits, underscores (_), and hyphens (-) are allowed.`,
+        ErrorCode.INVALID_ARGUMENT,
+        { name }
+      );
+    }
+  }
+}

package/src/commands/project/project-command.ts

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { Container } from 'typedi';
+import { RuniumError } from '@runium/core';
+import { RuniumCommand } from '@commands/runium-command.js';
+import { ErrorCode } from '@constants';
+import {
+  ProfileService,
+  ProjectService,
+  ProfileProject,
+  FileService,
+} from '@services';
+
+/**
+ * Base project command
+ */
+export abstract class ProjectCommand extends RuniumCommand {
+  protected projectService: ProjectService;
+  protected profileService: ProfileService;
+  protected fileService: FileService;
+
+  constructor(parent: Command) {
+    super(parent);
+    this.projectService = Container.get(ProjectService);
+    this.profileService = Container.get(ProfileService);
+    this.fileService = Container.get(FileService);
+  }
+
+  /**
+   * Ensure project exists
+   * @param name
+   */
+  protected ensureProfileProject(name: string): ProfileProject {
+    const project = this.profileService.getProjectByName(name);
+    if (!project) {
+      throw new RuniumError(
+        `Project "${name}" not found`,
+        ErrorCode.PROJECT_NOT_FOUND,
+        { name }
+      );
+    }
+    return project;
+  }
+}

package/src/commands/project/project-list.ts

@@ -0,0 +1,32 @@
+import { ProjectCommand } from './project-command.js';
+
+/**
+ * Project list command
+ */
+export class ProjectListCommand extends ProjectCommand {
+  /**
+   * Config command
+   */
+  protected config(): void {
+    this.command
+      .name('list')
+      .description('list projects')
+      .option('-s, --sort', 'sort by name');
+  }
+
+  /**
+   * Handle command
+   */
+  protected async handle({ sort }: { sort: boolean }): Promise<void> {
+    const projects = this.profileService.getProjects();
+    if (sort) {
+      projects.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    // handle empty list
+    if (projects.length !== 0) {
+      this.outputService.table(projects, ['name', 'path']);
+    } else {
+      this.outputService.warn('No projects found');
+    }
+  }
+}

package/src/commands/project/project-remove.ts

@@ -0,0 +1,41 @@
+import { ProjectCommand } from './project-command.js';
+
+/**
+ * Project remove command
+ */
+export class ProjectRemoveCommand extends ProjectCommand {
+  /**
+   * Config command
+   */
+  protected config(): void {
+    this.command
+      .name('remove')
+      .description('remove project')
+      .option('-a, --all', 'remove all projects')
+      .argument('[name...]', 'project names');
+  }
+
+  /**
+   * Handle command
+   * @param names
+   * @param all
+   */
+  protected async handle(
+    names: string[],
+    { all }: { all: boolean }
+  ): Promise<void> {
+    if (names.length === 0 && !all) {
+      this.outputService.warn('No projects specified to remove');
+      return;
+    }
+    if (all) {
+      names = this.profileService.getProjects().map(p => p.name);
+    }
+
+    for (const name of names) {
+      this.ensureProfileProject(name);
+      await this.profileService.removeProject(name);
+      this.outputService.success(`Project "%s" successfully removed`, name);
+    }
+  }
+}