@runium/cli 0.0.1 → 0.0.3

package/src/services/command.ts

@@ -0,0 +1,171 @@
+import { Command } from 'commander';
+import { Container, Service } from 'typedi';
+import { isRuniumError, RuniumError } from '@runium/core';
+import { ErrorCode } from '@constants';
+import { PluginService } from '@services';
+import {
+  RuniumCommand,
+  RuniumCommandConstructor,
+} from '@commands/runium-command.js';
+
+const PROGRAM_NAME = 'runium';
+
+@Service()
+export class CommandService {
+  /**
+   * Full path commands
+   */
+  private fullPathCommands: Map<string, RuniumCommand> = new Map();
+
+  /**
+   * Get command full path recursively
+   * @param command
+   */
+  private getCommandFullPath(command: RuniumCommand): string {
+    const commandName = command.command?.name();
+
+    if (commandName === PROGRAM_NAME || !command.command.parent) {
+      return '';
+    }
+
+    // find the parent command instance
+    const parentCommand = Array.from(this.fullPathCommands.values()).find(
+      cmd => cmd.command === command.command.parent
+    );
+
+    if (parentCommand) {
+      // recursively get parent's full path
+      const parentPath = this.getCommandFullPath(parentCommand);
+      return [parentPath, commandName].filter(Boolean).join(' ').trim();
+    }
+
+    // fallback: if parent not found in map, check if parent is the program
+    const parentName = command.command.parent.name();
+    if (parentName === PROGRAM_NAME) {
+      return commandName;
+    }
+
+    return [parentName, commandName].join(' ').trim();
+  }
+
+  /**
+   * Register command
+   * @param command
+   * @param program
+   * @param context
+   */
+  registerCommand(
+    command: RuniumCommandConstructor,
+    program: Command,
+    context: string = 'app'
+  ): void {
+    const addCommand = (
+      CommandConstructor: RuniumCommandConstructor,
+      parent: Command
+    ) => {
+      try {
+        if (!(CommandConstructor.prototype instanceof RuniumCommand)) {
+          throw new RuniumError(
+            `Command "${CommandConstructor.name}" for "${context}" must be a subclass of "RuniumCommand"`,
+            ErrorCode.COMMAND_INCORRECT,
+            {
+              context,
+              CommandConstructor,
+            }
+          );
+        }
+
+        const commandInstance: RuniumCommand = new CommandConstructor(parent);
+
+        const commandPath = this.getCommandFullPath(commandInstance);
+        this.fullPathCommands.set(commandPath, commandInstance);
+
+        if (commandInstance.subcommands.length > 0) {
+          commandInstance.subcommands.forEach(subcommand => {
+            addCommand(subcommand, commandInstance.command);
+          });
+        }
+      } catch (error) {
+        if (isRuniumError(error)) {
+          throw error;
+        }
+        throw new RuniumError(
+          `Failed to register command "${CommandConstructor.name}" for "${context}"`,
+          ErrorCode.COMMAND_REGISTRATION_ERROR,
+          { original: error }
+        );
+      }
+    };
+
+    addCommand(command, program);
+  }
+
+  /**
+   * Create run command
+   * @param handle
+   * @param command
+   */
+  createRunCommand(
+    handle: (...args: unknown[]) => Promise<void>,
+    command: RuniumCommand
+  ): (...args: unknown[]) => Promise<void> {
+    const pluginService = Container.get(PluginService);
+    return async (...args: unknown[]): Promise<void> => {
+      // run from command action contains command
+      // run from plugin context does not contain command
+      if (args?.length > 0 && args[args.length - 1] instanceof Command) {
+        args.pop();
+      }
+
+      const commandPath = this.getCommandFullPath(command);
+
+      await pluginService.runHook('app.beforeCommandRun', {
+        command: commandPath,
+        args,
+      });
+
+      await handle.call(command, ...args);
+
+      await pluginService.runHook('app.afterCommandRun', {
+        command: commandPath,
+        args,
+      });
+    };
+  }
+
+  /**
+   * Check if command exists
+   * @param path
+   */
+  hasCommand(path: string): boolean {
+    return this.fullPathCommands.has(path);
+  }
+
+  /**
+   * Run command
+   * @param path
+   * @param args
+   */
+  async runCommand(path: string, ...args: unknown[]): Promise<void> {
+    const command = this.fullPathCommands.get(path);
+    if (!command) {
+      throw new RuniumError(
+        `Command "${path}" not found`,
+        ErrorCode.COMMAND_NOT_FOUND,
+        { path }
+      );
+    }
+    try {
+      await command.run(...args);
+    } catch (error) {
+      if (isRuniumError(error)) {
+        throw error;
+      }
+      throw new RuniumError(
+        `Failed to run command "${path}"`,
+        ErrorCode.COMMAND_RUN_ERROR,
+        { original: error }
+      );
+    }
+  }
+}

package/src/services/config.ts

@@ -2,7 +2,13 @@ import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { Service } from 'typedi';
-import { readJsonFile } from '@runium/core';
+import { readJsonFile, RuniumError } from '@runium/core';
+import { ErrorCode } from '@constants';
+import {
+  createValidator,
+  getConfigSchema,
+  getErrorMessages,
+} from '@validation';
 
 interface ConfigEnv {
   path: string[];
@@ -16,10 +22,20 @@ interface ConfigProfile {
   path: string;
 }
 
+interface ConfigPlugin {
+  disabled: boolean;
+  options: Record<string, unknown>;
+}
+
+interface ConfigPlugins {
+  [name: string]: ConfigPlugin;
+}
+
 interface ConfigData {
   env: ConfigEnv;
   output: ConfigOutput;
   profile: ConfigProfile;
+  plugins: ConfigPlugins;
 }
 
 const CONFIG_FILE_NAME = '.runiumrc.json';
@@ -28,10 +44,31 @@ const PROFILE_DIR_NAME = '.runium';
 const HOME_PROFILE_PATH = join(homedir(), PROFILE_DIR_NAME);
 const CWD_PROFILE_PATH = join(process.cwd(), PROFILE_DIR_NAME);
 
+/**
+ * Validate config data
+ * @param data
+ */
+function validateConfigData(data: unknown): void {
+  const schema = getConfigSchema();
+  const validate = createValidator(schema);
+  const result = validate(data);
+
+  if (!result && validate.errors) {
+    const errorMessages = getErrorMessages(validate.errors);
+
+    throw new RuniumError(
+      `Invalid "${CONFIG_FILE_PATH}" configuration data`,
+      ErrorCode.CONFIG_INVALID_DATA,
+      errorMessages
+    );
+  }
+}
+
 @Service()
 export class ConfigService {
   private data: ConfigData = {
     profile: { path: HOME_PROFILE_PATH },
+    plugins: {},
     output: { debug: false },
     env: { path: [] },
   };
@@ -45,10 +82,11 @@ export class ConfigService {
     }
 
     if (existsSync(CONFIG_FILE_PATH)) {
-      // TODO validate config file
-      const configData: ConfigData =
-        await readJsonFile<ConfigData>(CONFIG_FILE_PATH);
+      const configData: Partial<ConfigData> =
+        await readJsonFile<Partial<ConfigData>>(CONFIG_FILE_PATH);
       if (configData) {
+        validateConfigData(configData);
+
         const data = {
           env: Object.assign({}, this.data.env, configData.env ?? {}),
           output: Object.assign({}, this.data.output, configData.output ?? {}),
@@ -57,6 +95,11 @@ export class ConfigService {
             this.data.profile,
             configData.profile ?? {}
           ),
+          plugins: Object.assign(
+            {},
+            this.data.plugins,
+            configData.plugins ?? {}
+          ),
         };
 
         data.env.path = data.env.path.map(envPath => resolve(envPath));

package/src/services/file.ts

@@ -0,0 +1,272 @@
+import { PathLike } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import {
+  access,
+  constants,
+  mkdir,
+  readFile,
+  rename,
+  writeFile,
+} from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+
+import { Service } from 'typedi';
+import { JSONObject, RuniumError } from '@runium/core';
+import { ErrorCode } from '@constants';
+
+type Resolve = () => void;
+type Reject = (error: Error) => void;
+type Data = Parameters<typeof writeFile>[1];
+
+@Service()
+export class FileService {
+  /**
+   * Reads a file as text
+   * @param path
+   * @param options
+   */
+  async read(
+    path: string,
+    options: { encoding?: BufferEncoding } = {}
+  ): Promise<string> {
+    try {
+      return await readFile(path, { encoding: options.encoding || 'utf-8' });
+    } catch (ex) {
+      throw new RuniumError(
+        `Can not read file ${path}`,
+        ErrorCode.FILE_READ_ERROR,
+        { path, options, original: ex }
+      );
+    }
+  }
+
+  /**
+   * Writes data to a file
+   * @param path
+   * @param data
+   * @param options
+   */
+  async write(
+    path: string,
+    data: string,
+    options: { encoding?: BufferEncoding } = {}
+  ): Promise<void> {
+    try {
+      await writeFile(path, data, { encoding: options.encoding || 'utf-8' });
+    } catch (ex) {
+      throw new RuniumError(
+        `Can not write file ${path}`,
+        ErrorCode.FILE_WRITE_ERROR,
+        { path, data, options, original: ex }
+      );
+    }
+  }
+
+  /**
+   * Reads a JSON file
+   * @param path
+   */
+  async readJson<T = JSONObject>(path: string): Promise<T> {
+    try {
+      const data = await readFile(path, { encoding: 'utf-8' });
+      return JSON.parse(data);
+    } catch (ex) {
+      throw new RuniumError(
+        `Can not read JSON file ${path}`,
+        ErrorCode.FILE_READ_JSON_ERROR,
+        { path, original: ex }
+      );
+    }
+  }
+
+  /**
+   * Writes a JSON file
+   * @param path
+   * @param data
+   */
+  async writeJson<T = JSONObject>(path: string, data: T): Promise<void> {
+    try {
+      await writeFile(path, JSON.stringify(data, null, 2), {
+        encoding: 'utf-8',
+      });
+    } catch (ex) {
+      throw new RuniumError(
+        `Can not write JSON file ${path}`,
+        ErrorCode.FILE_WRITE_JSON_ERROR,
+        { path, data, original: ex }
+      );
+    }
+  }
+
+  /**
+   * Checks if a file or directory exists
+   * @param path
+   */
+  async isExists(path: string): Promise<boolean> {
+    try {
+      await access(path, constants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Create directory recursively if it does not exist
+   * @param path
+   */
+  async ensureDirExists(path: string): Promise<void> {
+    try {
+      await mkdir(path, { recursive: true });
+    } catch (ex) {
+      throw new RuniumError(
+        `Can not create directory ${path}`,
+        ErrorCode.FILE_CREATE_DIR_ERROR,
+        { path, original: ex }
+      );
+    }
+  }
+
+  /**
+   * Create an atomic file writer
+   * @param path
+   */
+  createAtomicWriter(path: PathLike): AtomicWriter {
+    return new AtomicWriter(path);
+  }
+}
+
+/**
+ * Creates a temporary file name for a given file
+ * @param file
+ */
+function getTempFilename(file: PathLike): string {
+  const f = file instanceof URL ? fileURLToPath(file) : file.toString();
+  return join(dirname(f), `.${basename(f)}.tmp`);
+}
+
+/**
+ * Retries an asynchronous operation with a delay between retries and a maximum retry count
+ * @param fn
+ * @param maxRetries
+ * @param delayMs
+ */
+async function retryAsyncOperation(
+  fn: () => Promise<void>,
+  maxRetries: number,
+  delayMs: number
+): Promise<void> {
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (i < maxRetries - 1) {
+        await new Promise(resolve => setTimeout(resolve, delayMs));
+      } else {
+        throw error;
+      }
+    }
+  }
+}
+
+/**
+ * Atomic file writer
+ *
+ * Allows writing to a file atomically
+ * based on https://github.com/typicode/steno
+ */
+export class AtomicWriter {
+  private readonly filename: PathLike;
+  private readonly tempFilename: PathLike;
+  private locked = false;
+  private prev: [Resolve, Reject] | null = null;
+  private next: [Resolve, Reject] | null = null;
+  private nextPromise: Promise<void> | null = null;
+  private nextData: Data | null = null;
+
+  constructor(filename: PathLike) {
+    this.filename = filename;
+    this.tempFilename = getTempFilename(filename);
+  }
+
+  /**
+   * Add data for later write
+   * @param data
+   */
+  private addData(data: Data): Promise<void> {
+    // keep only most recent data
+    this.nextData = data;
+
+    // create a singleton promise to resolve all next promises once next data is written
+    this.nextPromise ||= new Promise((resolve, reject) => {
+      this.next = [resolve, reject];
+    });
+
+    // return a promise that will resolve at the same time as next promise
+    return new Promise((resolve, reject) => {
+      this.nextPromise?.then(resolve).catch(reject);
+    });
+  }
+
+  /**
+   * Write data to a file atomically
+   * @param data
+   */
+  private async writeData(data: Data): Promise<void> {
+    this.locked = true;
+    try {
+      await writeFile(this.tempFilename, data, 'utf-8');
+      await retryAsyncOperation(
+        async () => {
+          await rename(this.tempFilename, this.filename);
+        },
+        10,
+        100
+      );
+
+      // resolve
+      this.prev?.[0]();
+    } catch (err) {
+      // reject
+      if (err instanceof Error) {
+        this.prev?.[1](err);
+      }
+      throw err;
+    } finally {
+      this.locked = false;
+
+      this.prev = this.next;
+      this.next = this.nextPromise = null;
+
+      if (this.nextData !== null) {
+        const nextData = this.nextData;
+        this.nextData = null;
+        await this.write(nextData);
+      }
+    }
+  }
+
+  /**
+   * Write data to a file atomically
+   * @param data
+   */
+  async write(data: Data): Promise<void> {
+    try {
+      await (this.locked ? this.addData(data) : this.writeData(data));
+    } catch (ex) {
+      throw new RuniumError(
+        `Can not write file ${this.filename}`,
+        ErrorCode.FILE_WRITE_ERROR,
+        { path: this.filename, data, original: ex }
+      );
+    }
+  }
+
+  /**
+   * Writes a JSON file
+   * @param data
+   */
+  async writeJson<T = JSONObject>(data: T): Promise<void> {
+    return this.write(JSON.stringify(data, null, 2));
+  }
+}

package/src/services/index.ts

@@ -1,4 +1,6 @@
+export * from './command.js';
 export * from './config.js';
+export * from './file.js';
 export * from './output.js';
 export * from './profile.js';
 export * from './plugin.js';

package/src/services/output.ts

@@ -1,5 +1,6 @@
 import { Console } from 'node:console';
 import { Transform } from 'node:stream';
+import { inspect } from 'node:util';
 
 import { Service } from 'typedi';
 
@@ -20,6 +21,8 @@ class ConsoleDumper extends Console {
   private readonly transform: Transform;
 
   constructor() {
+    inspect.defaultOptions.depth = 5;
+
     const transform = new Transform({
       transform: (chunk, _, cb) => cb(null, chunk),
     });
@@ -50,7 +53,8 @@ class ConsoleDumper extends Console {
     return original
       .split('\n')
       .map((line: string) => line.charAt(0) + line.slice(columnWidth))
-      .join('\n');
+      .join('\n')
+      .replace(/'([^']*)'/g, '$1  ');
   }
 }
 

package/src/services/plugin-context.ts

@@ -1,34 +1,80 @@
+import { delimiter } from 'node:path';
 import { Inject, Service } from 'typedi';
-
 import {
   RuniumError,
   isRuniumError,
   RuniumTask,
   RuniumTrigger,
-  readJsonFile,
-  writeJsonFile,
   applyMacros,
+  TaskEvent,
   TaskStatus,
   ProjectEvent,
   ProjectStatus,
 } from '@runium/core';
 import { RuniumCommand } from '@commands/runium-command.js';
-import { OutputLevel, OutputService, ShutdownService } from '@services';
+import {
+  CommandService,
+  FileService,
+  OutputLevel,
+  OutputService,
+  ProfileService,
+  ShutdownService,
+} from '@services';
+import { getVersion } from '@utils';
+import { ErrorCode } from '@constants';
 
-// @ts-expect-error global object access
 global.runium = null;
 
 @Service()
 export class PluginContextService {
   constructor(
+    @Inject() private commandService: CommandService,
     @Inject() private outputService: OutputService,
-    @Inject() private shutdownService: ShutdownService
+    @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;
 
@@ -51,13 +97,12 @@ export class PluginContextService {
           ),
         ProjectEvent,
         ProjectStatus,
+        TaskEvent,
         TaskStatus,
       },
       utils: {
         applyMacros,
         isRuniumError,
-        readJsonFile,
-        writeJsonFile,
       },
       output: {
         getLevel: output.getLevel.bind(output),
@@ -74,8 +119,22 @@ export class PluginContextService {
         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(),
     };
-    // @ts-expect-error global object access
     global.runium = Object.freeze(runium);
   }
 }