@runium/cli 0.0.3 → 0.0.4

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

@@ -1,59 +0,0 @@
-import { RuniumError } from '@runium/core';
-import { ErrorCode } from '@constants';
-import { ProjectStateCommand } from './project-state-command.js';
-
-/**
- * Project stop command
- */
-export class ProjectStopCommand extends ProjectStateCommand {
-  /**
-   * Config command
-   */
-  protected config(): void {
-    this.command
-      .name('stop')
-      .description('stop project')
-      .option('-f, --file', 'use file path instead of project name')
-      .argument('<name>', 'project name');
-  }
-
-  /**
-   * Handle command
-   * @param name
-   * @param file
-   */
-  protected async handle(
-    name: string,
-    { file }: { file: boolean }
-  ): Promise<void> {
-    const path = file
-      ? this.projectService.resolvePath(name)
-      : this.ensureProfileProject(name).path;
-
-    const projectDataFileName = this.getProjectDataFileName(file ? path : name);
-    const projectDataFilePath = this.profileService.getPath(
-      'projects',
-      projectDataFileName
-    );
-
-    // check if project is started
-    const projectData = await this.readProjectData(projectDataFilePath);
-    if (!projectData || !this.isProjectProcessStarted(projectData.pid)) {
-      throw new RuniumError(
-        `Project "${name}" is not started`,
-        ErrorCode.PROJECT_NOT_STARTED,
-        { name }
-      );
-    }
-
-    try {
-      process.kill(projectData.pid, 'SIGTERM');
-    } catch (ex) {
-      throw new RuniumError(
-        `Failed to stop project "${name}"`,
-        ErrorCode.PROJECT_STOP_ERROR,
-        { name, original: ex }
-      );
-    }
-  }
-}

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

@@ -1,56 +0,0 @@
-import * as ajv from 'ajv';
-import { ProjectCommand } from './project-command.js';
-import { getErrorMessages } from '@validation';
-
-interface ValidationError {
-  code: string;
-  payload: { errors: ajv.ErrorObject[] };
-}
-
-/**
- * Project validate command
- */
-export class ProjectValidateCommand extends ProjectCommand {
-  /**
-   * Config command
-   */
-  protected config(): void {
-    this.command
-      .name('validate')
-      .description('validate project')
-      .option('-f, --file', 'use file path instead of project name')
-      .argument('<name>', 'project name');
-  }
-
-  /**
-   * Handle command
-   * @param name
-   * @param file
-   */
-  protected async handle(
-    name: string,
-    { file }: { file: boolean }
-  ): Promise<void> {
-    const path = file
-      ? this.projectService.resolvePath(name)
-      : this.ensureProfileProject(name).path;
-    const projectInstance = await this.projectService.initProject(path);
-    try {
-      await projectInstance.validate();
-      this.outputService.success(`Project "%s" is valid`, name);
-    } catch (error) {
-      const errorMessages = getErrorMessages(
-        (error as ValidationError).payload.errors,
-        {
-          filter: error => error.original?.keyword !== 'oneOf',
-        }
-      );
-
-      this.outputService.error(
-        `Project "%s" validation failed:\n\n%s`,
-        name,
-        errorMessages.join('\n')
-      );
-    }
-  }
-}

package/src/commands/project/project.ts

@@ -1,40 +0,0 @@
-import { RuniumCommand } from '@commands/runium-command.js';
-import { ProjectAddCommand } from './project-add.js';
-import { ProjectListCommand } from './project-list.js';
-import { ProjectRemoveCommand } from './project-remove.js';
-import { ProjectStartCommand } from './project-start.js';
-import { ProjectStopCommand } from './project-stop.js';
-import { ProjectStatusCommand } from './project-status.js';
-import { ProjectValidateCommand } from './project-validate.js';
-
-/**
- * Project group command
- */
-export class ProjectCommand extends RuniumCommand {
-  /**
-   * Subcommands
-   */
-  subcommands = [
-    ProjectListCommand,
-    ProjectAddCommand,
-    ProjectRemoveCommand,
-    ProjectStartCommand,
-    ProjectStopCommand,
-    ProjectStatusCommand,
-    ProjectValidateCommand,
-  ];
-
-  /**
-   * Config command
-   */
-  protected config(): void {
-    this.command.name('project').description('manage projects');
-  }
-
-  /**
-   * Handle command
-   */
-  protected async handle(): Promise<void> {
-    this.command.help();
-  }
-}

package/src/commands/runium-command.ts

@@ -1,52 +0,0 @@
-import { Command } from 'commander';
-import { Container } from 'typedi';
-import { CommandService, OutputService } from '@services';
-
-export type RuniumCommandConstructor = new (program: Command) => RuniumCommand;
-
-/**
- * Base runium command
- */
-export abstract class RuniumCommand {
-  /**
-   * Output service
-   */
-  protected outputService: OutputService;
-
-  /**
-   * Current command
-   */
-  command: Command;
-
-  /**
-   * Subcommands
-   */
-  subcommands: RuniumCommandConstructor[] = [];
-
-  /**
-   * Run command
-   */
-  run: (...args: unknown[]) => Promise<void>;
-
-  constructor(parent: Command) {
-    const commandService = Container.get(CommandService);
-    this.run = commandService.createRunCommand(this.handle, this);
-
-    this.outputService = Container.get(OutputService);
-    this.command = new Command();
-    this.config();
-    this.command.action(this.run.bind(this));
-
-    parent.addCommand(this.command);
-  }
-
-  /**
-   * Config command
-   */
-  protected abstract config(): void;
-
-  /**
-   * Handle command
-   */
-  protected abstract handle(...args: unknown[]): Promise<void>;
-}

package/src/constants/error-code.ts

@@ -1,28 +0,0 @@
-export enum ErrorCode {
-  FILE_READ_JSON_ERROR = 'file-read-json-error',
-  FILE_WRITE_JSON_ERROR = 'file-write-json-error',
-  FILE_READ_ERROR = 'file-read-error',
-  FILE_WRITE_ERROR = 'file-write-error',
-  FILE_CREATE_DIR_ERROR = 'file-create-dir-error',
-  PLUGIN_NOT_FOUND = 'plugin-not-found',
-  PLUGIN_FILE_NOT_FOUND = 'plugin-file-not-found',
-  PLUGIN_INCORRECT_MODULE = 'plugin-incorrect-module',
-  PLUGIN_INVALID = 'plugin-invalid',
-  PLUGIN_PATH_RESOLVE_ERROR = 'plugin-path-resolve-error',
-  PLUGIN_LOAD_ERROR = 'plugin-load-error',
-  PLUGIN_HOOK_ERROR = 'plugin-hook-error',
-  PROJECT_ALREADY_STARTED = 'project-already-started',
-  PROJECT_NOT_STARTED = 'project-not-started',
-  PROJECT_STOP_ERROR = 'project-stop-error',
-  PROJECT_NOT_FOUND = 'project-not-found',
-  PROJECT_FILE_NOT_FOUND = 'project-file-not-found',
-  PROJECT_FILE_CAN_NOT_READ = 'project-file-can-not-read',
-  PROJECT_JSON_PARSE_ERROR = 'project-json-parse-error',
-  INVALID_ARGUMENT = 'invalid-argument',
-  INVALID_PATH = 'invalid-path',
-  CONFIG_INVALID_DATA = 'config-invalid-data',
-  COMMAND_REGISTRATION_ERROR = 'command-registration-error',
-  COMMAND_INCORRECT = 'command-incorrect',
-  COMMAND_NOT_FOUND = 'command-not-found',
-  COMMAND_RUN_ERROR = 'command-run-error',
-}

package/src/constants/index.ts

@@ -1 +0,0 @@
-export * from './error-code.js';

package/src/global.d.ts

@@ -1,6 +0,0 @@
-declare global {
-  // eslint-disable-next-line
-  var runium: unknown;
-}
-
-export {};

package/src/index.ts

@@ -1,24 +0,0 @@
-#!/usr/bin/env node
-
-import 'reflect-metadata';
-import { Container } from 'typedi';
-import { RuniumCliApp } from './app.js';
-import { OutputService, ShutdownService } from '@services';
-
-async function main() {
-  const app = new RuniumCliApp();
-  await app.start();
-}
-
-main().catch(error => {
-  const outputService = Container.get(OutputService);
-  outputService.error('Error: %s', error.message);
-  outputService.debug('Error details:', {
-    code: error.code,
-    payload: error.payload,
-  });
-  const shutdownService = Container.get(ShutdownService);
-  shutdownService.shutdown('error').catch(() => {
-    process.exit(1);
-  });
-});

package/src/macros/conditional.ts

@@ -1,31 +0,0 @@
-/**
- * Equal
- * @param value1
- * @param value2
- * @param trueValue
- * @param falseValue
- */
-export function eqMacro(
-  value1: string,
-  value2: string,
-  trueValue?: string,
-  falseValue?: string
-): string {
-  return value1 === value2 ? (trueValue ?? '') : (falseValue ?? '');
-}
-
-/**
- * Not equal
- * @param value1
- * @param value2
- * @param trueValue
- * @param falseValue
- */
-export function neMacro(
-  value1: string,
-  value2: string,
-  trueValue?: string,
-  falseValue?: string
-): string {
-  return value1 !== value2 ? (trueValue ?? '') : (falseValue ?? '');
-}

package/src/macros/date.ts

@@ -1,15 +0,0 @@
-import { formatTimestamp } from '@utils/format-timestamp.js';
-
-/**
- * Date
- */
-export function dateMacro(): string {
-  return formatTimestamp(Date.now());
-}
-
-/**
- * Timestamp
- */
-export function timestampMacro(): string {
-  return Date.now().toString();
-}

package/src/macros/empty.ts

@@ -1,6 +0,0 @@
-/**
- * Empty string
- */
-export function emptyMacro(): string {
-  return '';
-}

package/src/macros/env.ts

@@ -1,8 +0,0 @@
-/**
- * Get environment variable
- * @param name
- * @param defaultValue
- */
-export function envMacro(name: string, defaultValue?: string): string {
-  return process.env[name] ?? defaultValue ?? '';
-}

package/src/macros/index.ts

@@ -1,17 +0,0 @@
-import { eqMacro, neMacro } from './conditional.js';
-import { dateMacro, timestampMacro } from './date.js';
-import { emptyMacro } from './empty.js';
-import { envMacro } from './env.js';
-import { homeDirMacro, pathMacro, tmpDirMacro } from './path.js';
-
-export const macros = {
-  date: dateMacro,
-  homedir: homeDirMacro,
-  env: envMacro,
-  empty: emptyMacro,
-  eq: eqMacro,
-  ne: neMacro,
-  path: pathMacro,
-  tmpdir: tmpDirMacro,
-  timestamp: timestampMacro,
-};

package/src/macros/path.ts

@@ -1,24 +0,0 @@
-import { resolve } from 'node:path';
-import { homedir, tmpdir } from 'node:os';
-
-/**
- * Resolve path
- * @param path
- */
-export function pathMacro(...path: string[]): string {
-  return resolve(...path);
-}
-
-/**
- * Tmpdir path
- */
-export function tmpDirMacro(): string {
-  return tmpdir();
-}
-
-/**
- * Home directory path
- */
-export function homeDirMacro(): string {
-  return homedir();
-}

package/src/services/command.ts

@@ -1,171 +0,0 @@
-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

@@ -1,119 +0,0 @@
-import { existsSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { Service } from 'typedi';
-import { readJsonFile, RuniumError } from '@runium/core';
-import { ErrorCode } from '@constants';
-import {
-  createValidator,
-  getConfigSchema,
-  getErrorMessages,
-} from '@validation';
-
-interface ConfigEnv {
-  path: string[];
-}
-
-interface ConfigOutput {
-  debug: boolean;
-}
-
-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';
-const CONFIG_FILE_PATH = join(process.cwd(), CONFIG_FILE_NAME);
-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: [] },
-  };
-
-  /**
-   * Initialize the config service
-   */
-  async init(): Promise<void> {
-    if (existsSync(CWD_PROFILE_PATH)) {
-      this.data.profile.path = CWD_PROFILE_PATH;
-    }
-
-    if (existsSync(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 ?? {}),
-          profile: Object.assign(
-            {},
-            this.data.profile,
-            configData.profile ?? {}
-          ),
-          plugins: Object.assign(
-            {},
-            this.data.plugins,
-            configData.plugins ?? {}
-          ),
-        };
-
-        data.env.path = data.env.path.map(envPath => resolve(envPath));
-        data.profile.path = resolve(data.profile.path);
-        this.data = data;
-      }
-    }
-  }
-
-  /**
-   * Get a configuration value
-   * @param key
-   */
-  get<T extends keyof ConfigData>(key: T): ConfigData[T] {
-    return this.data[key];
-  }
-}