@runium/cli 0.0.2 → 0.0.3

package/src/services/profile.ts

@@ -0,0 +1,199 @@
+import { existsSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { Inject, Service } from 'typedi';
+import { ConfigService, FileService } from '@services';
+
+export interface ProfilePlugin {
+  name: string;
+  path: string;
+  file?: boolean;
+  disabled?: boolean;
+  options?: Record<string, unknown>;
+}
+
+export interface ProfileProject {
+  name: string;
+  path: string;
+}
+
+const PLUGINS_FILE_NAME = 'plugins.json';
+const PROJECTS_FILE_NAME = 'projects.json';
+
+@Service()
+export class ProfileService {
+  private path: string = process.cwd();
+
+  private plugins: ProfilePlugin[] = [];
+
+  private projects: ProfileProject[] = [];
+
+  constructor(
+    @Inject() private configService: ConfigService,
+    @Inject() private fileService: FileService
+  ) {}
+
+  /**
+   * Initialize the profile service
+   */
+  async init(): Promise<void> {
+    this.path = this.configService.get('profile').path;
+    if (!existsSync(this.path)) {
+      await mkdir(this.path, { recursive: true });
+    }
+
+    await this.readPlugins();
+    await this.patchPlugins();
+    await this.readProjects();
+  }
+
+  /**
+   * Get plugins
+   */
+  getPlugins(): ProfilePlugin[] {
+    return this.plugins;
+  }
+
+  /**
+   * Get plugin by name
+   * @param name
+   */
+  getPluginByName(name: string): ProfilePlugin | undefined {
+    return this.plugins.find(p => p.name === name);
+  }
+
+  /**
+   * Add plugin
+   * @param plugin
+   */
+  async addPlugin(plugin: ProfilePlugin): Promise<void> {
+    this.plugins = this.plugins
+      .filter(p => p.name !== plugin.name)
+      .concat(plugin);
+    await this.writePlugins();
+  }
+
+  /**
+   * Update plugin
+   * @param name
+   */
+  async removePlugin(name: string): Promise<void> {
+    this.plugins = this.plugins.filter(plugin => plugin.name !== name);
+    await this.writePlugins();
+  }
+
+  /**
+   * Update plugin
+   * @param name
+   * @param data
+   */
+  async updatePlugin(
+    name: string,
+    data: Partial<Omit<ProfilePlugin, 'name'>>
+  ): Promise<void> {
+    const index = this.plugins.findIndex(plugin => plugin.name === name);
+    if (index !== -1) {
+      this.plugins[index] = {
+        ...this.plugins[index],
+        ...data,
+      };
+      await this.writePlugins();
+    }
+  }
+
+  /**
+   * Get projects
+   */
+  getProjects(): ProfileProject[] {
+    return this.projects;
+  }
+
+  /**
+   * Get project by name
+   * @param name
+   */
+  getProjectByName(name: string): ProfileProject | undefined {
+    return this.projects.find(p => p.name === name);
+  }
+
+  /**
+   * Add project
+   * @param project
+   */
+  async addProject(project: ProfileProject): Promise<void> {
+    this.projects = this.projects
+      .filter(p => p.name !== project.name)
+      .concat(project);
+    await this.writeProjects();
+  }
+
+  /**
+   * Remove project
+   * @param name
+   */
+  async removeProject(name: string): Promise<void> {
+    this.projects = this.projects.filter(p => p.name !== name);
+    await this.writeProjects();
+  }
+
+  /**
+   * Get path for a file
+   * @param parts
+   */
+  getPath(...parts: string[]): string {
+    return join(this.path, ...parts);
+  }
+
+  /**
+   * Read plugins from file
+   */
+  private async readPlugins(): Promise<void> {
+    this.plugins =
+      ((await this.fileService
+        .readJson(this.getPath(PLUGINS_FILE_NAME))
+        .catch(() => [])) as ProfilePlugin[]) || this.plugins;
+  }
+
+  /**
+   * Write plugins to file
+   */
+  private async writePlugins(): Promise<void> {
+    await this.fileService.writeJson(
+      this.getPath(PLUGINS_FILE_NAME),
+      this.plugins
+    );
+  }
+
+  /**
+   * Patch plugins
+   */
+  private async patchPlugins(): Promise<void> {
+    const pluginsConfig = this.configService.get('plugins');
+    for (const plugin of this.plugins) {
+      const config = pluginsConfig[plugin.name];
+      if (config) {
+        Object.assign(plugin, config);
+      }
+    }
+  }
+
+  /**
+   * Read projects from file
+   */
+  private async readProjects(): Promise<void> {
+    this.projects =
+      ((await this.fileService
+        .readJson(this.getPath(PROJECTS_FILE_NAME))
+        .catch(() => [])) as ProfileProject[]) || this.projects;
+  }
+
+  /**
+   * Write projects to file
+   */
+  private async writeProjects(): Promise<void> {
+    await this.fileService.writeJson(
+      this.getPath(PROJECTS_FILE_NAME),
+      this.projects
+    );
+  }
+}

package/src/services/project.ts

@@ -0,0 +1,142 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { Inject, Service } from 'typedi';
+import { applyMacros, Project, ProjectConfig, RuniumError } from '@runium/core';
+import { ErrorCode } from '@constants';
+import { macros } from '@macros';
+import { PluginProjectDefinition, PluginService } from '@services';
+
+@Service()
+export class ProjectService {
+  constructor(@Inject() private pluginService: PluginService) {}
+
+  /**
+   * Init project
+   * @param path
+   */
+  async initProject(path: string): Promise<Project> {
+    await this.pluginService.runHook('project.beforeConfigRead', path);
+
+    let content = await this.readFile(path);
+    content = await this.pluginService.runHook(
+      'project.afterConfigRead',
+      content,
+      { mutable: true }
+    );
+    content = this.applyMacros(content);
+    content = await this.pluginService.runHook(
+      'project.afterConfigMacrosApply',
+      content,
+      { mutable: true }
+    );
+
+    let projectData = this.parseProjectContent(content, path);
+    projectData = await this.pluginService.runHook(
+      'project.afterConfigParse',
+      projectData,
+      { mutable: true }
+    );
+
+    const project = new Project(projectData);
+    return this.extendProjectWithPlugins(project);
+  }
+
+  /**
+   * Resolve path
+   * @param path
+   */
+  resolvePath(path: string): string {
+    return resolve(path);
+  }
+
+  /**
+   * Run hook
+   * @param args
+   */
+  runHook(
+    ...args: Parameters<PluginService['runHook']>
+  ): ReturnType<PluginService['runHook']> {
+    return this.pluginService.runHook(...args);
+  }
+
+  /**
+   * Read project file
+   * @param path
+   */
+  private async readFile(path: string): Promise<string> {
+    if (!existsSync(path)) {
+      throw new RuniumError(
+        `Project file "${path}" does not exist`,
+        ErrorCode.PROJECT_FILE_NOT_FOUND,
+        { path }
+      );
+    }
+    try {
+      return readFile(path, { encoding: 'utf-8' });
+    } catch (error) {
+      throw new RuniumError(
+        `Failed to read project file "${path}"`,
+        ErrorCode.PROJECT_FILE_CAN_NOT_READ,
+        { path, original: error }
+      );
+    }
+  }
+
+  /**
+   * Apply macros to text
+   * @param text
+   */
+  private applyMacros(text: string): string {
+    const plugins = this.pluginService.getAllPlugins();
+    const pluginMacros = plugins.reduce(
+      (acc, plugin) => ({ ...acc, ...(plugin.project?.macros || {}) }),
+      {}
+    );
+    return applyMacros(text, { ...pluginMacros, ...macros });
+  }
+
+  /**
+   * Parse project content
+   * @param content
+   * @param path
+   */
+  private parseProjectContent(content: string, path: string): ProjectConfig {
+    try {
+      return JSON.parse(content);
+    } catch (error) {
+      throw new RuniumError(
+        `Failed to parse project "${path}"`,
+        ErrorCode.PROJECT_JSON_PARSE_ERROR,
+        { path, original: error }
+      );
+    }
+  }
+
+  /**
+   * Extends the project with plugins
+   * @param project
+   */
+  private extendProjectWithPlugins(project: Project): Project {
+    const plugins = this.pluginService.getAllPlugins();
+
+    plugins.forEach(plugin => {
+      const { tasks, actions, triggers, validationSchema } = (plugin.project ||
+        {}) as PluginProjectDefinition;
+      Object.entries(actions || {}).forEach(([type, processor]) => {
+        project.registerAction(type, processor);
+      });
+      Object.entries(tasks || {}).forEach(([type, processor]) => {
+        project.registerTask(type, processor);
+      });
+      Object.entries(triggers || {}).forEach(([type, processor]) => {
+        project.registerTrigger(type, processor);
+      });
+      if (validationSchema) {
+        project.extendValidationSchema(validationSchema);
+      }
+    });
+
+    return project;
+  }
+}

package/src/services/shutdown.ts

@@ -0,0 +1,147 @@
+import { Inject, Service } from 'typedi';
+import { OutputService, PluginService } from '@services';
+
+type ShutdownBlocker = (reason?: string) => Promise<void> | void;
+
+const TIMEOUT = 30000;
+const EXIT_DELAY = 250;
+const SIGNALS: NodeJS.Signals[] = ['SIGHUP', 'SIGINT', 'SIGTERM', 'SIGQUIT'];
+
+@Service()
+export class ShutdownService {
+  private blockers: Set<ShutdownBlocker> = new Set();
+  private isShuttingDown = false;
+
+  constructor(
+    @Inject() private outputService: OutputService,
+    @Inject() private pluginService: PluginService
+  ) {}
+  /**
+   * Initialize shutdown handlers
+   */
+  async init(): Promise<void> {
+    SIGNALS.forEach(signal => {
+      process.on(signal, () => {
+        this.shutdown(signal).catch(error => {
+          this.outputService.error('Error during shutdown: %s', error.message);
+          this.outputService.debug('Error details:', error);
+          process.exit(1);
+        });
+      });
+    });
+
+    process.on('uncaughtException', error => {
+      this.outputService.error('Uncaught exception: %s', error.message);
+      this.outputService.debug('Error details:', error);
+      this.shutdown('uncaughtException').catch(() => {
+        process.exit(1);
+      });
+    });
+
+    process.on('unhandledRejection', (reason, promise) => {
+      this.outputService.error(
+        'Unhandled rejection at:',
+        promise,
+        'reason:',
+        reason
+      );
+      this.outputService.debug('Error details:', { reason, promise });
+      this.shutdown('unhandledRejection').catch(() => {
+        process.exit(1);
+      });
+    });
+
+    process.on('beforeExit', () => {
+      if (!this.isShuttingDown) {
+        this.shutdown('exit').catch(() => {
+          process.exit(1);
+        });
+      }
+    });
+  }
+
+  /**
+   * Add a shutdown blocker function
+   * @param blocker
+   */
+  addBlocker(blocker: ShutdownBlocker): void {
+    this.blockers.add(blocker);
+  }
+
+  /**
+   * Remove a shutdown blocker
+   * @param blocker
+   */
+  removeBlocker(blocker: ShutdownBlocker): boolean {
+    return this.blockers.delete(blocker);
+  }
+
+  /**
+   * Execute graceful shutdown
+   * @param reason
+   */
+  async shutdown(reason?: string): Promise<void> {
+    if (this.isShuttingDown || !reason) {
+      return;
+    }
+
+    // add plugin beforeExit hooks as shutdown blockers
+    const plugins = this.pluginService.getAllPlugins();
+    for (const plugin of plugins) {
+      const hook = plugin.hooks?.app?.beforeExit;
+      if (hook) {
+        this.addBlocker(hook.bind(plugin, reason));
+      }
+    }
+
+    this.isShuttingDown = true;
+
+    const exitProcess = (code: number): void => {
+      setTimeout(() => {
+        process.exit(code);
+      }, EXIT_DELAY);
+    };
+
+    if (this.blockers.size === 0) {
+      exitProcess(0);
+      return;
+    }
+
+    try {
+      await this.executeBlockersWithTimeout(reason);
+      exitProcess(0);
+    } catch (error) {
+      exitProcess(1);
+    }
+  }
+
+  /**
+   * Execute all blockers with timeout
+   * @param reason
+   */
+  private async executeBlockersWithTimeout(reason: string): Promise<void> {
+    const blockerPromises = Array.from(this.blockers).map(blocker =>
+      this.executeBlocker(blocker, reason)
+    );
+
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Shutdown timeout after ${TIMEOUT}ms`));
+      }, TIMEOUT);
+    });
+
+    await Promise.race([Promise.allSettled(blockerPromises), timeoutPromise]);
+  }
+
+  /**
+   * Execute a single blocker with error handling
+   * @param blocker
+   * @param reason
+   */
+  private async executeBlocker(
+    blocker: ShutdownBlocker,
+    reason: string
+  ): Promise<void> {
+    await blocker(reason);
+  }
+}

package/src/utils/convert-path-to-valid-file-name.ts

@@ -0,0 +1,39 @@
+const MAX_FILENAME_LENGTH = 200;
+
+/**
+ * Converts a file path to a valid filename by replacing invalid characters
+ * @param filePath
+ * @param replacement
+ */
+export function convertPathToValidFileName(
+  filePath: string,
+  replacement: string = '_'
+): string {
+  let filename = filePath.trim();
+
+  // replace path separators (both forward and backward slashes)
+  filename = filename.replace(/^\/+/, '');
+  filename = filename.replace(/[/\\]/g, replacement);
+
+  // replace invalid filename characters
+  // Windows: < > : " | ? * and control characters (0-31)
+  // also replacing common problematic characters
+  // eslint-disable-next-line no-control-regex
+  filename = filename.replace(/[<>:"|?*\x00-\x1F]/g, replacement);
+
+  // remove leading/trailing dots and spaces (problematic on Windows)
+  filename = filename.replace(/^[.\s]+|[.\s]+$/g, '');
+
+  // replace multiple consecutive replacement characters with a single one
+  const replacementRegex = new RegExp(
+    `${replacement.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}+`,
+    'g'
+  );
+  filename = filename.replace(replacementRegex, replacement);
+
+  if (filename.length > MAX_FILENAME_LENGTH) {
+    filename = filename.substring(0, MAX_FILENAME_LENGTH);
+  }
+
+  return filename;
+}

package/src/utils/debounce.ts

@@ -0,0 +1,23 @@
+/**
+ * Create a debounced function
+ *
+ * @param func
+ * @param wait
+ */
+export function debounce<T extends (...args: unknown[]) => unknown>(
+  func: T,
+  wait: number
+): (...args: Parameters<T>) => void {
+  let timeoutId: NodeJS.Timeout | null = null;
+
+  return function debounced(...args: Parameters<T>): void {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+
+    timeoutId = setTimeout(() => {
+      func(...args);
+      timeoutId = null;
+    }, wait);
+  };
+}

package/src/utils/format-timestamp.ts

@@ -0,0 +1,17 @@
+/**
+ * Format a timestamp to 'yyyy-mm-dd hh:mm:ss' format
+ * @param timestamp
+ */
+export function formatTimestamp(timestamp: number | Date): string {
+  const date = typeof timestamp === 'number' ? new Date(timestamp) : timestamp;
+
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  const hours = String(date.getHours()).padStart(2, '0');
+  const minutes = String(date.getMinutes()).padStart(2, '0');
+  const seconds = String(date.getSeconds()).padStart(2, '0');
+  const milliseconds = String(date.getMilliseconds()).padStart(3, '0');
+
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${milliseconds}`;
+}

package/src/utils/get-version.ts

@@ -0,0 +1,13 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+let version: string | null = null;
+
+export function getVersion(): string {
+  if (!version) {
+    const packageJsonPath = resolve(import.meta.dirname, '..', 'package.json');
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    version = packageJson.version;
+  }
+  return version as string;
+}

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export { convertPathToValidFileName } from './convert-path-to-valid-file-name.js';
+export { debounce } from './debounce.js';
+export { formatTimestamp } from './format-timestamp.js';
+export { getVersion } from './get-version.js';

package/src/validation/create-validator.ts

@@ -0,0 +1,27 @@
+import Ajv, { ValidateFunction } from 'ajv/dist/2020.js';
+
+const classes = { Function: Function };
+
+export type Validator<T = unknown> = ValidateFunction<T>;
+
+/**
+ * Create validator
+ * @param schema
+ */
+export function createValidator<T = unknown>(schema: object): Validator<T> {
+  const ajv = new Ajv({
+    allowUnionTypes: true,
+    allErrors: true,
+    verbose: true,
+  });
+
+  ajv.addKeyword({
+    keyword: 'instanceof',
+    schemaType: 'string',
+    validate: (schema: string, data: unknown) => {
+      return data instanceof classes[schema as keyof typeof classes];
+    },
+  });
+
+  return ajv.compile<T>(schema);
+}

package/src/validation/get-config-schema.ts

@@ -0,0 +1,59 @@
+/**
+ * Get config schema
+ */
+export function getConfigSchema(): object {
+  return {
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    $id: 'https://runium.dev/schemas/config.json',
+    title: 'Runium Config',
+    type: 'object',
+    properties: {
+      env: {
+        type: 'object',
+        properties: {
+          path: {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+          },
+        },
+        additionalProperties: false,
+      },
+      output: {
+        type: 'object',
+        properties: {
+          debug: {
+            type: 'boolean',
+          },
+        },
+        additionalProperties: false,
+      },
+      profile: {
+        type: 'object',
+        properties: {
+          path: {
+            type: 'string',
+          },
+        },
+        additionalProperties: false,
+      },
+      plugins: {
+        type: 'object',
+        additionalProperties: {
+          type: 'object',
+          properties: {
+            disabled: {
+              type: 'boolean',
+            },
+            options: {
+              type: 'object',
+            },
+          },
+          additionalProperties: false,
+        },
+      },
+    },
+    additionalProperties: false,
+  };
+}