@runium/cli 0.0.2 → 0.0.3

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

@@ -0,0 +1,158 @@
+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 { AtomicWriter, ShutdownService } from '@services';
+import { ProjectData, ProjectStateCommand } from './project-state-command.js';
+
+/**
+ * Project start command
+ */
+export class ProjectStartCommand extends ProjectStateCommand {
+  protected shutdownService: ShutdownService;
+  protected fileWriter: AtomicWriter | null = null;
+
+  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);
+    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 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((reason?: string) => project.stop(reason));
+
+    await this.fileService.ensureDirExists(dirname(projectDataFilePath));
+    this.fileWriter = this.fileService.createAtomicWriter(projectDataFilePath);
+
+    this.addProjectListeners(project, {
+      projectPath: path,
+      output,
+    });
+
+    await this.projectService.runHook('project.beforeStart', project);
+
+    await project.start();
+  }
+
+  /**
+   * Add project listeners
+   * @param project
+   * @param options
+   */
+  protected addProjectListeners(
+    project: Project,
+    options: { projectPath: string; output?: boolean }
+  ): void {
+    const { projectPath, output } = options;
+
+    const projectData: ProjectData = {
+      id: project.getConfig().id,
+      pid: process.pid,
+      cwd: process.cwd(),
+      path: projectPath,
+      state: {
+        project: [],
+        tasks: {},
+      },
+    };
+
+    const writeProjectData = () => {
+      this.fileWriter!.writeJson(projectData).then();
+    };
+
+    // 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 || ''
+          );
+        }
+      }
+    );
+  }
+}

package/src/commands/project/project-state-command.ts

@@ -0,0 +1,53 @@
+import { convertPathToValidFileName } from '@utils';
+import { ProjectCommand } from './project-command.js';
+import { ProjectState, TaskState } from '@runium/core';
+
+export interface ProjectData {
+  id: string;
+  pid: number;
+  cwd: string;
+  path: string;
+  state: {
+    project: ProjectState[];
+    tasks: Record<string, TaskState[]>;
+  };
+}
+
+/**
+ * Base project state command
+ */
+export abstract class ProjectStateCommand extends ProjectCommand {
+  /**
+   * Get project data file name
+   * @param name
+   */
+  protected getProjectDataFileName(name: string): string {
+    let fileName = convertPathToValidFileName(name);
+    if (!fileName.endsWith('.json')) {
+      fileName = fileName + '.json';
+    }
+    return fileName;
+  }
+
+  /**
+   * Read project data
+   * @param path
+   */
+  protected async readProjectData(path: string): Promise<ProjectData | null> {
+    return this.fileService
+      .readJson(path)
+      .catch(() => null) as Promise<ProjectData | null>;
+  }
+
+  /**
+   * Checks if a project process is started
+   * @param pid
+   */
+  protected isProjectProcessStarted(pid: number): boolean {
+    try {
+      return process.kill(Number(pid), 0);
+    } catch (ex) {
+      return (ex as { code?: string }).code === 'EPERM';
+    }
+  }
+}

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

@@ -0,0 +1,116 @@
+import { formatTimestamp } from '@utils';
+import { ProjectStateCommand } from './project-state-command.js';
+
+interface StateRecord {
+  name: string;
+  status: string;
+  time: string;
+  timestamp: number;
+  reason?: string;
+  exitCode?: number;
+}
+
+/**
+ * Project status command
+ */
+export class ProjectStatusCommand extends ProjectStateCommand {
+  /**
+   * Config command
+   */
+  protected config(): void {
+    this.command
+      .name('status')
+      .description('get project status')
+      .option('-f, --file', 'use file path instead of project name')
+      .option('-t, --tasks', 'show tasks status')
+      .option('-a, --all', 'show status change history')
+      .argument('<name>', 'project name');
+  }
+
+  /**
+   * Handle command
+   * @param name
+   * @param file
+   * @param tasks
+   * @param all
+   */
+  protected async handle(
+    name: string,
+    { file, tasks, all }: { file: boolean; tasks: boolean; all: 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
+    );
+
+    const projectData = await this.readProjectData(projectDataFilePath);
+    if (projectData) {
+      let { project: projectState = [] } = projectData.state;
+      if (!all) {
+        projectState =
+          projectState.length > 0
+            ? [projectState[projectState.length - 1]]
+            : [];
+      }
+
+      if (tasks) {
+        const projectMappedState = projectState.map(state => {
+          return {
+            name: 'Project',
+            status: state.status,
+            time: formatTimestamp(state.timestamp),
+            timestamp: state.timestamp,
+            reason: state.reason || '',
+          };
+        });
+
+        const { tasks: tasksState = [] } = projectData.state;
+
+        const tasksMappedState: StateRecord[] = [];
+        Object.entries(tasksState).forEach(([key, value]) => {
+          if (!all) {
+            value = value.length > 0 ? [value[value.length - 1]] : [];
+          }
+          value.forEach(task => {
+            tasksMappedState.push({
+              name: key,
+              status: task.status,
+              time: formatTimestamp(task.timestamp),
+              timestamp: task.timestamp,
+              reason: [task.reason, task.exitCode].filter(Boolean).join(' '),
+            });
+          });
+        });
+
+        const mappedState: StateRecord[] = [
+          ...projectMappedState,
+          ...tasksMappedState,
+        ];
+        mappedState.sort((a, b) => a.timestamp - b.timestamp);
+
+        this.outputService.table(mappedState, [
+          'time',
+          'name',
+          'status',
+          'reason',
+        ]);
+      } else {
+        const mappedState = projectState.map(state => {
+          return {
+            status: state.status,
+            time: formatTimestamp(state.timestamp),
+          };
+        });
+
+        this.outputService.table(mappedState, ['time', 'status']);
+      }
+    } else {
+      this.outputService.info(`No project status for "${name}"`);
+    }
+  }
+}

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

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

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

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

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

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

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

package/src/global.d.ts

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

package/src/index.ts

@@ -0,0 +1,24 @@
+#!/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

@@ -0,0 +1,31 @@
+/**
+ * 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

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

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

package/src/macros/env.ts

@@ -0,0 +1,8 @@
+/**
+ * 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

@@ -0,0 +1,17 @@
+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,
+};