@runium/cli 0.0.2 → 0.0.3

package/src/services/output.ts

@@ -0,0 +1,205 @@
+import { Console } from 'node:console';
+import { Transform } from 'node:stream';
+import { inspect } from 'node:util';
+
+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() {
+    inspect.defaultOptions.depth = 5;
+
+    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')
+      .replace(/'([^']*)'/g, '$1  ');
+  }
+}
+
+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,140 @@
+import { delimiter } from 'node:path';
+import { Inject, Service } from 'typedi';
+import {
+  RuniumError,
+  isRuniumError,
+  RuniumTask,
+  RuniumTrigger,
+  applyMacros,
+  TaskEvent,
+  TaskStatus,
+  ProjectEvent,
+  ProjectStatus,
+} from '@runium/core';
+import { RuniumCommand } from '@commands/runium-command.js';
+import {
+  CommandService,
+  FileService,
+  OutputLevel,
+  OutputService,
+  ProfileService,
+  ShutdownService,
+} from '@services';
+import { getVersion } from '@utils';
+import { ErrorCode } from '@constants';
+
+global.runium = null;
+
+@Service()
+export class PluginContextService {
+  constructor(
+    @Inject() private commandService: CommandService,
+    @Inject() private outputService: OutputService,
+    @Inject() private shutdownService: ShutdownService,
+    @Inject() private fileService: FileService,
+    @Inject() private profileService: ProfileService
+  ) {}
+
+  /**
+   * Create a wrapper for a file service method that processes path parts
+   * @param methodName
+   */
+  private createStorageWrapper<T extends keyof FileService>(
+    methodName: T
+  ): FileService[T] {
+    return ((...args: unknown[]) => {
+      const [pathParts, ...rest] = args;
+      const resolvedPath = this.resolveProfilePath(
+        pathParts as string | string[]
+      );
+      const method = this.fileService[methodName] as (
+        ...args: unknown[]
+      ) => unknown;
+      return method(resolvedPath, ...rest);
+    }) as FileService[T];
+  }
+
+  /**
+   * Resolve path parts using profileService
+   * @param pathParts
+   */
+  private resolveProfilePath(pathParts: string | string[]): string {
+    const parts = Array.isArray(pathParts)
+      ? pathParts
+      : pathParts.split(delimiter);
+    if (parts.length === 0 || parts.every(part => part.trim() === '')) {
+      throw new RuniumError('Invalid path', ErrorCode.INVALID_PATH, {
+        path: pathParts,
+      });
+    }
+    return this.profileService.getPath(...parts);
+  }
+
+  /**
+   * Initialize the plugin context service
+   */
+  async init(): Promise<void> {
+    const command = this.commandService;
+    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,
+        TaskEvent,
+        TaskStatus,
+      },
+      utils: {
+        applyMacros,
+        isRuniumError,
+      },
+      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),
+      },
+      command: {
+        has: command.hasCommand.bind(command),
+        run: command.runCommand.bind(command),
+      },
+      storage: {
+        read: this.createStorageWrapper('read'),
+        write: this.createStorageWrapper('write'),
+        readJson: this.createStorageWrapper('readJson'),
+        writeJson: this.createStorageWrapper('writeJson'),
+        isExists: this.createStorageWrapper('isExists'),
+        ensureDirExists: this.createStorageWrapper('ensureDirExists'),
+        createAtomicWriter: this.createStorageWrapper('createAtomicWriter'),
+        getPath: this.resolveProfilePath.bind(this),
+      },
+      version: getVersion(),
+    };
+    global.runium = Object.freeze(runium);
+  }
+}

package/src/services/plugin.ts

@@ -0,0 +1,248 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { Inject, Service } from 'typedi';
+import {
+  isRuniumError,
+  MacrosCollection,
+  Project,
+  ProjectConfig,
+  ProjectSchemaExtension,
+  RuniumError,
+  RuniumTaskConstructor,
+  RuniumTriggerConstructor,
+  RuniumTriggerOptions,
+} from '@runium/core';
+import { RuniumCommandConstructor } from '@commands/runium-command.js';
+import { ErrorCode } from '@constants';
+import { OutputService } from '@services';
+import {
+  createValidator,
+  getErrorMessages,
+  getPluginSchema,
+} from '@validation';
+
+type PluginModule = { default: (options?: PluginOptions) => Plugin };
+
+type PluginHookErrorHandler = (error: RuniumError) => void;
+
+type PluginHookName =
+  | `app.${keyof PluginAppHooksDefinition}`
+  | `project.${keyof PluginProjectHooksDefinition}`;
+
+interface PluginHookOptions<M extends boolean> {
+  mutable?: M;
+  onError?: PluginHookErrorHandler;
+}
+
+export interface PluginProjectDefinition {
+  macros?: MacrosCollection;
+  tasks?: Record<string, RuniumTaskConstructor>;
+  actions?: Record<string, (payload: unknown) => void>;
+  triggers?: Record<string, RuniumTriggerConstructor<RuniumTriggerOptions>>;
+  validationSchema?: ProjectSchemaExtension;
+}
+
+export type PluginOptions = Record<string, unknown>;
+
+export interface PluginAppDefinition {
+  commands?: RuniumCommandConstructor[];
+}
+
+export interface PluginProjectHooksDefinition {
+  beforeConfigRead?(path: string): Promise<void>;
+  afterConfigRead?(content: string): Promise<string>;
+  afterConfigMacrosApply?(content: string): Promise<string>;
+  afterConfigParse?<T extends ProjectConfig>(config: T): Promise<T>;
+  beforeStart?(project: Project): Promise<void>;
+}
+
+export interface PluginAppHooksDefinition {
+  afterInit?(params: { profilePath: string }): Promise<void>;
+  beforeExit?(reason?: string): Promise<void>;
+  beforeCommandRun?(params: {
+    command: string;
+    args: unknown[];
+  }): Promise<void>;
+  afterCommandRun?(params: { command: string; args: unknown[] }): Promise<void>;
+}
+
+export interface PluginHooksDefinition {
+  app?: PluginAppHooksDefinition;
+  project?: PluginProjectHooksDefinition;
+}
+
+export interface Plugin {
+  name: string;
+  project?: PluginProjectDefinition;
+  options?: PluginOptions;
+  app?: PluginAppDefinition;
+  hooks?: PluginHooksDefinition;
+}
+
+@Service()
+export class PluginService {
+  /**
+   * Loaded plugins
+   */
+  private plugins: Map<string, Plugin> = new Map();
+
+  /**
+   * Validate plugin schema
+   * @private
+   */
+  private validator: ReturnType<typeof createValidator> =
+    createValidator(getPluginSchema());
+
+  constructor(@Inject() private outputService: OutputService) {}
+
+  /**
+   * 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
+   * @param options
+   */
+  async loadPlugin(path: string, options?: PluginOptions): 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(options);
+
+      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_LOAD_ERROR,
+        { 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 }
+      );
+    }
+  }
+
+  /**
+   * Run plugin hook
+   * @param name
+   * @param params
+   * @param options
+   */
+  async runHook<T, M extends boolean>(
+    name: PluginHookName,
+    params: T,
+    { mutable, onError }: PluginHookOptions<M> = {}
+  ): Promise<M extends true ? T : void> {
+    const plugins = this.getAllPlugins();
+
+    const [group, hookName] = name.split('.') as [
+      keyof PluginHooksDefinition,
+      keyof PluginHooksDefinition[keyof PluginHooksDefinition],
+    ];
+
+    for (const plugin of plugins) {
+      const hook = plugin.hooks?.[group]?.[hookName] as
+        | ((params: T) => Promise<T>)
+        | undefined;
+      if (hook) {
+        try {
+          if (!mutable) {
+            await hook(params);
+          } else {
+            params = (await hook(params)) ?? params;
+          }
+        } catch (ex) {
+          const error = new RuniumError(
+            `Failed to run "${plugin.name}.${name}" hook`,
+            ErrorCode.PLUGIN_HOOK_ERROR,
+            { plugin: plugin.name, hook: name, original: ex }
+          );
+          if (onError) {
+            onError(error);
+          } else {
+            this.outputService.error('Error: %s', error.message);
+            this.outputService.debug('Error details:', {
+              code: error.code,
+              payload: error.payload,
+            });
+          }
+        }
+      }
+    }
+
+    return (mutable ? params : undefined) as M extends true ? T : void;
+  }
+
+  /**
+   * Validate plugin
+   * @param plugin
+   */
+  private validate(plugin: Plugin): void {
+    const result = this.validator(plugin || {});
+    if (!result && this.validator.errors) {
+      const errorMessages = getErrorMessages(this.validator.errors);
+      throw new RuniumError(
+        'Incorrect plugin format',
+        ErrorCode.PLUGIN_INVALID,
+        { errors: errorMessages }
+      );
+    }
+  }
+}