@runium/cli 0.0.1

package/src/services/output.ts

@@ -0,0 +1,201 @@
+import { Console } from 'node:console';
+import { Transform } from 'node:stream';
+
+import { Service } from 'typedi';
+
+export enum OutputLevel {
+  TRACE = 0,
+  DEBUG = 1,
+  INFO = 2,
+  WARN = 3,
+  ERROR = 4,
+  SILENT = 5,
+}
+
+/**
+ * Console dumper
+ * wrapper around node console with a transform stream
+ */
+class ConsoleDumper extends Console {
+  private readonly transform: Transform;
+
+  constructor() {
+    const transform = new Transform({
+      transform: (chunk, _, cb) => cb(null, chunk),
+    });
+    super({
+      stdout: transform,
+      stderr: transform,
+      colorMode: false,
+    });
+    this.transform = transform;
+  }
+
+  /**
+   * Get a table output with index column removed
+   * @param data
+   * @param columns
+   */
+  getPatchedTable(data: unknown[], columns?: string[]): string {
+    this.table(data, columns);
+
+    const original = (this.transform.read() || '').toString();
+
+    // Tables should all start with roughly:
+    // ┌─────────┬──────
+    // │ (index) │
+    // ├─────────┼
+    const columnWidth = original.indexOf('┬') + 1;
+
+    return original
+      .split('\n')
+      .map((line: string) => line.charAt(0) + line.slice(columnWidth))
+      .join('\n');
+  }
+}
+
+const dumper = new ConsoleDumper();
+
+@Service()
+export class OutputService {
+  private outputLevel: OutputLevel = OutputLevel.INFO;
+
+  /**
+   * Set output level
+   * @param level
+   */
+  setLevel(level: OutputLevel): void {
+    this.outputLevel = level;
+  }
+
+  /**
+   * Get output level
+   */
+  getLevel(): OutputLevel {
+    return this.outputLevel;
+  }
+
+  /**
+   * Log a trace message
+   * @param message
+   * @param args
+   */
+  trace(message: string, ...args: unknown[]): void {
+    if (this.outputLevel <= OutputLevel.TRACE) {
+      // eslint-disable-next-line no-console
+      console.log(message, ...args);
+    }
+  }
+
+  /**
+   * Log a debug message
+   * @param message
+   * @param args
+   */
+  debug(message: string, ...args: unknown[]): void {
+    if (this.outputLevel <= OutputLevel.DEBUG) {
+      // eslint-disable-next-line no-console
+      console.log(message, ...args);
+    }
+  }
+
+  /**
+   * Log an info message
+   * @param message
+   * @param args
+   */
+  info(message: string, ...args: unknown[]): void {
+    if (this.outputLevel <= OutputLevel.INFO) {
+      // eslint-disable-next-line no-console
+      console.log(message, ...args);
+    }
+  }
+
+  /**
+   * Log a success message
+   * @param message
+   * @param args
+   */
+  success(message: string, ...args: unknown[]): void {
+    if (this.outputLevel <= OutputLevel.INFO) {
+      // eslint-disable-next-line no-console
+      console.log(message, ...args);
+    }
+  }
+
+  /**
+   * Log a warning message
+   * @param message
+   * @param args
+   */
+  warn(message: string, ...args: unknown[]): void {
+    if (this.outputLevel <= OutputLevel.WARN) {
+      // eslint-disable-next-line no-console
+      console.warn(message, ...args);
+    }
+  }
+
+  /**
+   * Log an error message
+   * @param message
+   * @param args
+   */
+  error(message: string, ...args: unknown[]): void {
+    if (this.outputLevel <= OutputLevel.ERROR) {
+      // eslint-disable-next-line no-console
+      console.error(message, ...args);
+    }
+  }
+
+  /**
+   * Log a message without level
+   * @param message
+   * @param args
+   */
+  log(message: string, ...args: unknown[]): void {
+    if (this.outputLevel < OutputLevel.SILENT) {
+      // eslint-disable-next-line no-console
+      console.log(message, ...args);
+    }
+  }
+
+  /**
+   * Output a table
+   * @param data
+   * @param columns
+   */
+  table(data: unknown[], columns?: string[]): void {
+    if (this.outputLevel < OutputLevel.SILENT) {
+      const patchedData = data.map((item, index) => ({
+        ...(item as object),
+        '#': index + 1,
+      }));
+      const patchedOutput = dumper.getPatchedTable(
+        patchedData,
+        columns ? ['#', ...columns] : undefined
+      );
+      // eslint-disable-next-line no-console
+      console.log(patchedOutput);
+    }
+  }
+
+  /**
+   * Output a blank line
+   */
+  newLine(): void {
+    if (this.outputLevel < OutputLevel.SILENT) {
+      // eslint-disable-next-line no-console
+      console.log('');
+    }
+  }
+
+  /**
+   * Clear output
+   */
+  clear(): void {
+    if (this.outputLevel < OutputLevel.SILENT) {
+      // eslint-disable-next-line no-console
+      console.clear();
+    }
+  }
+}

package/src/services/plugin-context.ts

@@ -0,0 +1,81 @@
+import { Inject, Service } from 'typedi';
+
+import {
+  RuniumError,
+  isRuniumError,
+  RuniumTask,
+  RuniumTrigger,
+  readJsonFile,
+  writeJsonFile,
+  applyMacros,
+  TaskStatus,
+  ProjectEvent,
+  ProjectStatus,
+} from '@runium/core';
+import { RuniumCommand } from '@commands/runium-command.js';
+import { OutputLevel, OutputService, ShutdownService } from '@services';
+
+// @ts-expect-error global object access
+global.runium = null;
+
+@Service()
+export class PluginContextService {
+  constructor(
+    @Inject() private outputService: OutputService,
+    @Inject() private shutdownService: ShutdownService
+  ) {}
+
+  /**
+   * Initialize the plugin context service
+   */
+  async init(): Promise<void> {
+    const output = this.outputService;
+    const shutdown = this.shutdownService;
+
+    const runium = {
+      class: {
+        RuniumCommand,
+        RuniumError,
+        RuniumTask,
+        RuniumTrigger,
+      },
+      enum: {
+        OutputLevel: Object.keys(OutputLevel)
+          .filter(key => isNaN(Number(key)))
+          .reduce(
+            (acc, key) => {
+              acc[key] = OutputLevel[key as keyof typeof OutputLevel];
+              return acc;
+            },
+            {} as Record<string, number>
+          ),
+        ProjectEvent,
+        ProjectStatus,
+        TaskStatus,
+      },
+      utils: {
+        applyMacros,
+        isRuniumError,
+        readJsonFile,
+        writeJsonFile,
+      },
+      output: {
+        getLevel: output.getLevel.bind(output),
+        setLevel: output.setLevel.bind(output),
+        trace: output.trace.bind(output),
+        debug: output.debug.bind(output),
+        info: output.info.bind(output),
+        warn: output.warn.bind(output),
+        error: output.error.bind(output),
+        table: output.table.bind(output),
+        log: output.log.bind(output),
+      },
+      shutdown: {
+        addBlocker: shutdown.addBlocker.bind(shutdown),
+        removeBlocker: shutdown.removeBlocker.bind(shutdown),
+      },
+    };
+    // @ts-expect-error global object access
+    global.runium = Object.freeze(runium);
+  }
+}

package/src/services/plugin.ts

@@ -0,0 +1,144 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { Service } from 'typedi';
+import {
+  isRuniumError,
+  Macro,
+  ProjectSchemaExtension,
+  RuniumError,
+  RuniumTaskConstructor,
+  RuniumTriggerConstructor,
+  RuniumTriggerOptions,
+} from '@runium/core';
+import { ErrorCode } from '@constants';
+
+type PluginOptions = Record<string, unknown>;
+
+type PluginModule = { default: (options?: PluginOptions) => Plugin };
+
+export interface PluginProjectDefinition {
+  macros?: Record<string, Macro>;
+  tasks?: Record<string, RuniumTaskConstructor>;
+  actions?: Record<string, (payload: unknown) => void>;
+  triggers?: Record<string, RuniumTriggerConstructor<RuniumTriggerOptions>>;
+  validationSchema?: ProjectSchemaExtension;
+}
+
+export interface PluginOptionsDefinition {
+  value?: PluginOptions;
+  validate?(options: PluginOptions): boolean;
+}
+
+export interface PluginAppDefinition {
+  commands?: Record<string, unknown>;
+}
+
+export interface Plugin {
+  name: string;
+  project?: PluginProjectDefinition;
+  options?: PluginOptionsDefinition;
+  app?: PluginAppDefinition;
+}
+
+@Service()
+export class PluginService {
+  private plugins: Map<string, Plugin> = new Map();
+
+  /**
+   * Get all plugins
+   */
+  getAllPlugins(): Plugin[] {
+    return Array.from(this.plugins.values());
+  }
+
+  /**
+   * Get plugin by name
+   * @param name
+   */
+  getPluginByName(name: string): Plugin | undefined {
+    return this.plugins.get(name);
+  }
+
+  /**
+   * Load plugin
+   * @param path
+   */
+  async loadPlugin(path: string): Promise<string> {
+    if (!path || !existsSync(path)) {
+      throw new RuniumError(
+        `Plugin file "${path}" does not exist`,
+        ErrorCode.PLUGIN_FILE_NOT_FOUND,
+        { path }
+      );
+    }
+
+    try {
+      const pluginModule = (await import(path)) as PluginModule;
+      const { default: getPlugin } = pluginModule;
+      if (!getPlugin || typeof getPlugin !== 'function') {
+        throw new RuniumError(
+          'Plugin module must have a default function',
+          ErrorCode.PLUGIN_INCORRECT_MODULE,
+          { path }
+        );
+      }
+      const plugin = getPlugin();
+
+      this.validate(plugin);
+
+      this.plugins.set(plugin.name, plugin);
+
+      return plugin.name;
+    } catch (error) {
+      if (isRuniumError(error)) {
+        throw error;
+      }
+      throw new RuniumError(
+        `Failed to load plugin "${path}"`,
+        ErrorCode.PLUGIN_INCORRECT_PLUGIN,
+        { path, original: error }
+      );
+    }
+  }
+
+  /**
+   * Unload plugin
+   * @param name
+   */
+  async unloadPlugin(name: string): Promise<boolean> {
+    return this.plugins.delete(name);
+  }
+
+  /**
+   * Resolve path
+   * @param path
+   * @param isFile
+   */
+  resolvePath(path: string, isFile: boolean = false): string {
+    try {
+      const resolvedPath = isFile ? resolve(path) : import.meta.resolve(path);
+      return resolvedPath.replace('file://', '');
+    } catch (error) {
+      throw new RuniumError(
+        `Failed to resolve plugin path "${path}"`,
+        ErrorCode.PLUGIN_PATH_RESOLVE_ERROR,
+        { path, original: error }
+      );
+    }
+  }
+
+  /**
+   * Validate plugin
+   * @param plugin
+   */
+  private validate(plugin: Plugin): void {
+    // TODO add plugin validation
+    if (!plugin || !plugin?.name) {
+      throw new RuniumError(
+        'Incorrect plugin format',
+        ErrorCode.PLUGIN_INCORRECT_PLUGIN,
+        { name: plugin.name }
+      );
+    }
+  }
+}

package/src/services/profile.ts

@@ -0,0 +1,211 @@
+import { existsSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { Inject, Service } from 'typedi';
+import {
+  JSONObject,
+  readJsonFile,
+  RuniumError,
+  writeJsonFile,
+} from '@runium/core';
+import { ConfigService } from '@services';
+import { ErrorCode } from '@constants';
+
+export interface ProfilePlugin {
+  name: string;
+  path: string;
+  file?: boolean;
+  disabled?: boolean;
+  options?: Record<string, unknown>;
+}
+
+export interface ProfileProject {
+  name: string;
+  path: string;
+}
+
+const PLUGINS_FILE_NAME = 'plugins.json';
+const PROJECTS_FILE_NAME = 'projects.json';
+
+@Service()
+export class ProfileService {
+  private path: string = process.cwd();
+
+  private plugins: ProfilePlugin[] = [];
+
+  private projects: ProfileProject[] = [];
+
+  constructor(@Inject() private configService: ConfigService) {}
+
+  /**
+   * Initialize the profile service
+   */
+  async init(): Promise<void> {
+    this.path = this.configService.get('profile').path;
+    if (!existsSync(this.path)) {
+      await mkdir(this.path, { recursive: true });
+    }
+
+    await this.readPlugins();
+    await this.readProjects();
+  }
+
+  /**
+   * Get plugins
+   */
+  getPlugins(): ProfilePlugin[] {
+    return this.plugins;
+  }
+
+  /**
+   * Get plugin by name
+   * @param name
+   */
+  getPluginByName(name: string): ProfilePlugin | undefined {
+    return this.plugins.find(p => p.name === name);
+  }
+
+  /**
+   * Add plugin
+   * @param plugin
+   */
+  async addPlugin(plugin: ProfilePlugin): Promise<void> {
+    this.plugins = this.plugins
+      .filter(p => p.name !== plugin.name)
+      .concat(plugin);
+    await this.writePlugins();
+  }
+
+  /**
+   * Update plugin
+   * @param name
+   */
+  async removePlugin(name: string): Promise<void> {
+    this.plugins = this.plugins.filter(plugin => plugin.name !== name);
+    await this.writePlugins();
+  }
+
+  /**
+   * Update plugin
+   * @param name
+   * @param data
+   */
+  async updatePlugin(
+    name: string,
+    data: Partial<Omit<ProfilePlugin, 'name'>>
+  ): Promise<void> {
+    const index = this.plugins.findIndex(plugin => plugin.name === name);
+    if (index !== -1) {
+      this.plugins[index] = {
+        ...this.plugins[index],
+        ...data,
+      };
+      await this.writePlugins();
+    }
+  }
+
+  /**
+   * Get projects
+   */
+  getProjects(): ProfileProject[] {
+    return this.projects;
+  }
+
+  /**
+   * Get project by name
+   * @param name
+   */
+  getProjectByName(name: string): ProfileProject | undefined {
+    return this.projects.find(p => p.name === name);
+  }
+
+  /**
+   * Add project
+   * @param project
+   */
+  async addProject(project: ProfileProject): Promise<void> {
+    this.projects = this.projects
+      .filter(p => p.name !== project.name)
+      .concat(project);
+    await this.writeProjects();
+  }
+
+  /**
+   * Remove project
+   * @param name
+   */
+  async removeProject(name: string): Promise<void> {
+    this.projects = this.projects.filter(p => p.name !== name);
+    await this.writeProjects();
+  }
+
+  /**
+   * Read JSON file
+   * @param pathParts
+   */
+  async readJsonFile(...pathParts: string[]): Promise<JSONObject> {
+    return readJsonFile(this.getPath(...pathParts));
+  }
+
+  /**
+   * Write JSON file
+   * @param data
+   * @param parts
+   */
+  async writeJsonFile(data: unknown, ...parts: string[]): Promise<void> {
+    const path = this.getPath(...parts);
+    try {
+      const dirName = dirname(path);
+      if (!existsSync(dirName)) {
+        await mkdir(dirName, { recursive: true });
+      }
+      await writeJsonFile(path, data);
+    } catch (error) {
+      throw new RuniumError(
+        `Failed to write JSON file`,
+        ErrorCode.PROFILE_JSON_WRITE_ERROR,
+        { path, data, original: error }
+      );
+    }
+  }
+  /**
+   * Read JSON file
+   * @param parts
+   */
+  private getPath(...parts: string[]): string {
+    return join(this.path, ...parts);
+  }
+
+  /**
+   * Read plugins from file
+   */
+  private async readPlugins(): Promise<void> {
+    this.plugins =
+      ((await readJsonFile(this.getPath(PLUGINS_FILE_NAME)).catch(
+        () => []
+      )) as ProfilePlugin[]) || this.plugins;
+  }
+
+  /**
+   * Write plugins to file
+   */
+  private async writePlugins(): Promise<void> {
+    await writeJsonFile(this.getPath(PLUGINS_FILE_NAME), this.plugins);
+  }
+  /**
+   * Read projects from file
+   */
+  private async readProjects(): Promise<void> {
+    this.projects =
+      ((await readJsonFile(this.getPath(PROJECTS_FILE_NAME)).catch(
+        () => []
+      )) as ProfileProject[]) || this.projects;
+  }
+
+  /**
+   * Write projects to file
+   */
+  private async writeProjects(): Promise<void> {
+    await writeJsonFile(this.getPath(PROJECTS_FILE_NAME), this.projects);
+  }
+}