@runium/cli 0.0.1

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: {},
+      });
+      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('[plugin...]', '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('[plugin...]', '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);
+      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('[plugin...]', '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,41 @@
+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 {
+  /**
+   * Config command
+   */
+  protected config(): void {
+    this.command.name('plugin').description('manage plugins');
+  }
+
+  /**
+   * Handle command
+   */
+  protected async handle(): Promise<void> {
+    this.command.help();
+  }
+
+  /**
+   * Add subcommands
+   */
+  protected addSubcommands(): void {
+    const constructors = [
+      PluginListCommand,
+      PluginAddCommand,
+      PluginRemoveCommand,
+      PluginDisableCommand,
+      PluginEnableCommand,
+    ];
+    for (const CommandConstructor of constructors) {
+      this.subcommands.push(new CommandConstructor(this.command));
+    }
+  }
+}

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

@@ -0,0 +1,46 @@
+import { 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) {
+      await this.profileService.addProject({
+        // TODO validate name
+        // optionally save project file to profile
+        name: name ?? project.getConfig().id,
+        path: projectPath,
+      });
+      this.outputService.success(
+        `Project "%s" successfully added`,
+        name ?? project.getConfig().id
+      );
+    } else {
+      throw new RuniumError(
+        `Failed to add project "${projectPath}"`,
+        ErrorCode.PROJECT_NOT_FOUND,
+        { path: projectPath }
+      );
+    }
+  }
+}

package/src/commands/project/project-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 { ProfileService, ProjectService, ProfileProject } from '@services';
+
+/**
+ * Base project command
+ */
+export abstract class ProjectCommand extends RuniumCommand {
+  protected projectService: ProjectService;
+  protected profileService: ProfileService;
+
+  constructor(parent: Command) {
+    super(parent);
+    this.projectService = Container.get(ProjectService);
+    this.profileService = Container.get(ProfileService);
+  }
+
+  /**
+   * 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);
+    }
+  }
+}

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

@@ -0,0 +1,152 @@
+import { dirname } from 'node:path';
+import { Command, Option } from 'commander';
+import { Container } from 'typedi';
+import {
+  Project,
+  ProjectEvent,
+  ProjectState,
+  RuniumError,
+  TaskState,
+} from '@runium/core';
+import { ErrorCode } from '@constants';
+import { ShutdownService } from '@services';
+import { debounce } from '@utils';
+import { ProjectData, ProjectStateCommand } from './project-state-command.js';
+
+const WRITE_PROJECT_DATA_DEBOUNCE_WAIT = 100;
+
+/**
+ * Project start command
+ */
+export class ProjectStartCommand extends ProjectStateCommand {
+  protected shutdownService: ShutdownService;
+
+  constructor(parent: Command) {
+    super(parent);
+    this.shutdownService = Container.get(ShutdownService);
+  }
+
+  /**
+   * Config command
+   */
+  protected config(): void {
+    this.command
+      .name('start')
+      .description('start project')
+      .option('-f, --file', 'use file path instead of project name')
+      .option('-o, --output', 'output project state changes')
+      .addOption(
+        new Option('-w, --working-dir <choice>', 'set working directory')
+          .choices(['cwd', 'project'])
+          .default('cwd')
+      )
+      .argument('<name>', 'project name');
+  }
+
+  /**
+   * Handle command
+   * @param name
+   * @param file
+   * @param workingDir
+   * @param output
+   */
+  protected async handle(
+    name: string,
+    {
+      file,
+      workingDir,
+      output,
+    }: { file: boolean; workingDir?: string; output?: boolean }
+  ): Promise<void> {
+    const path = file
+      ? this.projectService.resolvePath(name)
+      : this.ensureProfileProject(name).path;
+
+    const projectDataFileName = this.getProjectDataFileName(file ? path : name);
+
+    // check if project is started
+    const projectData = await this.readProjectData(projectDataFileName);
+    if (projectData && this.isProjectProcessStarted(projectData.pid)) {
+      throw new RuniumError(
+        `Project "${name}" is already started`,
+        ErrorCode.PROJECT_ALREADY_STARTED,
+        { name }
+      );
+    }
+
+    if (workingDir === 'project') {
+      const projectDir = dirname(path);
+      if (projectDir !== process.cwd()) {
+        process.chdir(projectDir);
+      }
+    }
+
+    const project = await this.projectService.initProject(path);
+    this.shutdownService.addBlocker(() => project.stop());
+
+    this.addProjectListeners(project, {
+      dataFileName: projectDataFileName,
+      projectPath: path,
+      output,
+    });
+
+    await project.start();
+  }
+
+  /**
+   * Add project listeners
+   * @param project
+   * @param options
+   */
+  protected addProjectListeners(
+    project: Project,
+    options: { dataFileName: string; projectPath: string; output?: boolean }
+  ): void {
+    const { dataFileName, projectPath, output } = options;
+
+    const projectData: ProjectData = {
+      id: project.getConfig().id,
+      pid: process.pid,
+      cwd: process.cwd(),
+      path: projectPath,
+      state: {
+        project: [],
+        tasks: {},
+      },
+    };
+
+    const writeProjectData = debounce(() => {
+      this.writeProjectData(projectData, dataFileName);
+    }, WRITE_PROJECT_DATA_DEBOUNCE_WAIT);
+
+    // write initial data
+    writeProjectData();
+
+    project.on(ProjectEvent.STATE_CHANGE, async (state: ProjectState) => {
+      projectData.state.project.push(state);
+      writeProjectData();
+      if (output) {
+        this.outputService.info('Project %s', state.status);
+      }
+    });
+
+    project.on(
+      ProjectEvent.TASK_STATE_CHANGE,
+      (taskId: string, state: TaskState) => {
+        if (!projectData.state.tasks[taskId]) {
+          projectData.state.tasks[taskId] = [];
+        }
+        projectData.state.tasks[taskId].push(state);
+        writeProjectData();
+        if (output) {
+          this.outputService.info(
+            'Task %s %s %s',
+            taskId,
+            state.status,
+            state.exitCode || state.error || ''
+          );
+        }
+      }
+    );
+  }
+}