@runium/cli 0.0.1

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

@@ -0,0 +1,68 @@
+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 fileName
+   */
+  protected async readProjectData(
+    fileName: string
+  ): Promise<ProjectData | null> {
+    return this.profileService
+      .readJsonFile('projects', fileName)
+      .catch(() => null) as Promise<ProjectData | null>;
+  }
+
+  /**
+   * Write project data
+   * @param data
+   * @param fileName
+   */
+  protected async writeProjectData(
+    data: ProjectData,
+    fileName: string
+  ): Promise<void> {
+    return this.profileService.writeJsonFile(data, 'projects', fileName);
+  }
+
+  /**
+   * Checks if a project process is started
+   * @param pid
+   */
+  protected isProjectProcessStarted(pid: number): boolean {
+    // and process started
+    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,103 @@
+import { formatTimestamp } from '@utils';
+import { ProjectStateCommand } from './project-state-command.js';
+
+interface StateRecord {
+  name: string;
+  status: string;
+  time: string;
+  timestamp: 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 task 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 projectData = await this.readProjectData(projectDataFileName);
+    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,
+          };
+        });
+
+        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,
+            });
+          });
+        });
+
+        const mappedState: StateRecord[] = [
+          ...projectMappedState,
+          ...tasksMappedState,
+        ];
+        mappedState.sort((a, b) => a.timestamp - b.timestamp);
+
+        this.outputService.table(mappedState, ['time', 'name', 'status']);
+      } 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,55 @@
+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);
+
+    // check if project is started
+    const projectData = await this.readProjectData(projectDataFileName);
+    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,43 @@
+import { ProjectCommand } from './project-command.js';
+
+/**
+ * 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('<project>', 'project name or file path');
+  }
+
+  /**
+   * Handle command
+   * @param project
+   * @param file
+   */
+  protected async handle(
+    project: string,
+    { file }: { file: boolean }
+  ): Promise<void> {
+    const path = file
+      ? this.projectService.resolvePath(project)
+      : this.ensureProfileProject(project).path;
+    const projectInstance = await this.projectService.initProject(path);
+    try {
+      await projectInstance.validate();
+      this.outputService.success(`Project "%s" is valid`, project);
+    } catch (error) {
+      // TODO stringify validation errors
+      this.outputService.error(
+        `Project "%s" validation failed`,
+        project,
+        error
+      );
+    }
+  }
+}

package/src/commands/project/project.ts

@@ -0,0 +1,45 @@
+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 {
+  /**
+   * Config command
+   */
+  protected config(): void {
+    this.command.name('project').description('manage projects');
+  }
+
+  /**
+   * Handle command
+   */
+  protected async handle(): Promise<void> {
+    this.command.help();
+  }
+
+  /**
+   * Add subcommands
+   */
+  protected addSubcommands(): void {
+    const constructors = [
+      ProjectListCommand,
+      ProjectAddCommand,
+      ProjectRemoveCommand,
+      ProjectStartCommand,
+      ProjectStopCommand,
+      ProjectStatusCommand,
+      ProjectValidateCommand,
+    ];
+    for (const CommandConstructor of constructors) {
+      this.subcommands.push(new CommandConstructor(this.command));
+    }
+  }
+}

package/src/commands/runium-command.ts

@@ -0,0 +1,50 @@
+import { Command } from 'commander';
+import { Container } from 'typedi';
+import { OutputService } from '@services';
+
+/**
+ * Base runium command
+ */
+export abstract class RuniumCommand {
+  protected outputService: OutputService;
+
+  /**
+   * Parent command
+   */
+  protected parent: Command;
+
+  /**
+   * Current command
+   */
+  protected command: Command;
+
+  /**
+   * Subcommands
+   */
+  protected subcommands: RuniumCommand[] = [];
+
+  constructor(parent: Command) {
+    this.outputService = Container.get(OutputService);
+    this.parent = parent;
+    this.command = new Command();
+    this.config();
+    this.command.action(this.handle.bind(this));
+    this.addSubcommands();
+    this.parent.addCommand(this.command);
+  }
+
+  /**
+   * Add subcommands
+   */
+  protected addSubcommands(): void {}
+
+  /**
+   * Config command
+   */
+  protected abstract config(): void;
+
+  /**
+   * Handle command
+   */
+  protected abstract handle(...args: unknown[]): Promise<void>;
+}

package/src/constants/error-code.ts

@@ -0,0 +1,15 @@
+export enum ErrorCode {
+  PLUGIN_NOT_FOUND = 'plugin-not-found',
+  PLUGIN_FILE_NOT_FOUND = 'plugin-file-not-found',
+  PLUGIN_INCORRECT_MODULE = 'plugin-incorrect-module',
+  PLUGIN_INCORRECT_PLUGIN = 'plugin-incorrect-plugin',
+  PLUGIN_PATH_RESOLVE_ERROR = 'plugin-path-resolve-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',
+  PROFILE_JSON_WRITE_ERROR = 'profile-json-write-error',
+}

package/src/constants/index.ts

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

package/src/index.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+import 'reflect-metadata';
+import { Container } from 'typedi';
+import { RuniumCliApp } from './app.js';
+import { OutputService } 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,
+  });
+  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/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,12 @@
+import { eqMacro, neMacro } from './conditional.js';
+import { emptyMacro } from './empty.js';
+import { envMacro } from './env.js';
+import { pathMacro } from './path.js';
+
+export const macros = {
+  env: envMacro,
+  empty: emptyMacro,
+  eq: eqMacro,
+  ne: neMacro,
+  path: pathMacro,
+};

package/src/macros/path.ts

@@ -0,0 +1,9 @@
+import { resolve } from 'node:path';
+
+/**
+ * Resolve path
+ * @param path
+ */
+export function pathMacro(path: string): string {
+  return resolve(path);
+}

package/src/services/config.ts

@@ -0,0 +1,76 @@
+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';
+
+interface ConfigEnv {
+  path: string[];
+}
+
+interface ConfigOutput {
+  debug: boolean;
+}
+
+interface ConfigProfile {
+  path: string;
+}
+
+interface ConfigData {
+  env: ConfigEnv;
+  output: ConfigOutput;
+  profile: ConfigProfile;
+}
+
+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);
+
+@Service()
+export class ConfigService {
+  private data: ConfigData = {
+    profile: { path: HOME_PROFILE_PATH },
+    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)) {
+      // TODO validate config file
+      const configData: ConfigData =
+        await readJsonFile<ConfigData>(CONFIG_FILE_PATH);
+      if (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 ?? {}
+          ),
+        };
+
+        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];
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,7 @@
+export * from './config.js';
+export * from './output.js';
+export * from './profile.js';
+export * from './plugin.js';
+export * from './project.js';
+export * from './shutdown.js';
+export * from './plugin-context.js';