@runium/cli 0.0.1 → 0.0.2

package/src/services/plugin.ts

@@ -1,144 +0,0 @@
-import { existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { Service } from 'typedi';
-import {
-  isRuniumError,
-  Macro,
-  ProjectSchemaExtension,
-  RuniumError,
-  RuniumTaskConstructor,
-  RuniumTriggerConstructor,
-  RuniumTriggerOptions,
-} from '@runium/core';
-import { ErrorCode } from '@constants';
-
-type PluginOptions = Record<string, unknown>;
-
-type PluginModule = { default: (options?: PluginOptions) => Plugin };
-
-export interface PluginProjectDefinition {
-  macros?: Record<string, Macro>;
-  tasks?: Record<string, RuniumTaskConstructor>;
-  actions?: Record<string, (payload: unknown) => void>;
-  triggers?: Record<string, RuniumTriggerConstructor<RuniumTriggerOptions>>;
-  validationSchema?: ProjectSchemaExtension;
-}
-
-export interface PluginOptionsDefinition {
-  value?: PluginOptions;
-  validate?(options: PluginOptions): boolean;
-}
-
-export interface PluginAppDefinition {
-  commands?: Record<string, unknown>;
-}
-
-export interface Plugin {
-  name: string;
-  project?: PluginProjectDefinition;
-  options?: PluginOptionsDefinition;
-  app?: PluginAppDefinition;
-}
-
-@Service()
-export class PluginService {
-  private plugins: Map<string, Plugin> = new Map();
-
-  /**
-   * Get all plugins
-   */
-  getAllPlugins(): Plugin[] {
-    return Array.from(this.plugins.values());
-  }
-
-  /**
-   * Get plugin by name
-   * @param name
-   */
-  getPluginByName(name: string): Plugin | undefined {
-    return this.plugins.get(name);
-  }
-
-  /**
-   * Load plugin
-   * @param path
-   */
-  async loadPlugin(path: string): Promise<string> {
-    if (!path || !existsSync(path)) {
-      throw new RuniumError(
-        `Plugin file "${path}" does not exist`,
-        ErrorCode.PLUGIN_FILE_NOT_FOUND,
-        { path }
-      );
-    }
-
-    try {
-      const pluginModule = (await import(path)) as PluginModule;
-      const { default: getPlugin } = pluginModule;
-      if (!getPlugin || typeof getPlugin !== 'function') {
-        throw new RuniumError(
-          'Plugin module must have a default function',
-          ErrorCode.PLUGIN_INCORRECT_MODULE,
-          { path }
-        );
-      }
-      const plugin = getPlugin();
-
-      this.validate(plugin);
-
-      this.plugins.set(plugin.name, plugin);
-
-      return plugin.name;
-    } catch (error) {
-      if (isRuniumError(error)) {
-        throw error;
-      }
-      throw new RuniumError(
-        `Failed to load plugin "${path}"`,
-        ErrorCode.PLUGIN_INCORRECT_PLUGIN,
-        { path, original: error }
-      );
-    }
-  }
-
-  /**
-   * Unload plugin
-   * @param name
-   */
-  async unloadPlugin(name: string): Promise<boolean> {
-    return this.plugins.delete(name);
-  }
-
-  /**
-   * Resolve path
-   * @param path
-   * @param isFile
-   */
-  resolvePath(path: string, isFile: boolean = false): string {
-    try {
-      const resolvedPath = isFile ? resolve(path) : import.meta.resolve(path);
-      return resolvedPath.replace('file://', '');
-    } catch (error) {
-      throw new RuniumError(
-        `Failed to resolve plugin path "${path}"`,
-        ErrorCode.PLUGIN_PATH_RESOLVE_ERROR,
-        { path, original: error }
-      );
-    }
-  }
-
-  /**
-   * Validate plugin
-   * @param plugin
-   */
-  private validate(plugin: Plugin): void {
-    // TODO add plugin validation
-    if (!plugin || !plugin?.name) {
-      throw new RuniumError(
-        'Incorrect plugin format',
-        ErrorCode.PLUGIN_INCORRECT_PLUGIN,
-        { name: plugin.name }
-      );
-    }
-  }
-}

package/src/services/profile.ts

@@ -1,211 +0,0 @@
-import { existsSync } from 'node:fs';
-import { mkdir } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { Inject, Service } from 'typedi';
-import {
-  JSONObject,
-  readJsonFile,
-  RuniumError,
-  writeJsonFile,
-} from '@runium/core';
-import { ConfigService } from '@services';
-import { ErrorCode } from '@constants';
-
-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) {}
-
-  /**
-   * 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.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();
-  }
-
-  /**
-   * Read JSON file
-   * @param pathParts
-   */
-  async readJsonFile(...pathParts: string[]): Promise<JSONObject> {
-    return readJsonFile(this.getPath(...pathParts));
-  }
-
-  /**
-   * Write JSON file
-   * @param data
-   * @param parts
-   */
-  async writeJsonFile(data: unknown, ...parts: string[]): Promise<void> {
-    const path = this.getPath(...parts);
-    try {
-      const dirName = dirname(path);
-      if (!existsSync(dirName)) {
-        await mkdir(dirName, { recursive: true });
-      }
-      await writeJsonFile(path, data);
-    } catch (error) {
-      throw new RuniumError(
-        `Failed to write JSON file`,
-        ErrorCode.PROFILE_JSON_WRITE_ERROR,
-        { path, data, original: error }
-      );
-    }
-  }
-  /**
-   * Read JSON file
-   * @param parts
-   */
-  private getPath(...parts: string[]): string {
-    return join(this.path, ...parts);
-  }
-
-  /**
-   * Read plugins from file
-   */
-  private async readPlugins(): Promise<void> {
-    this.plugins =
-      ((await readJsonFile(this.getPath(PLUGINS_FILE_NAME)).catch(
-        () => []
-      )) as ProfilePlugin[]) || this.plugins;
-  }
-
-  /**
-   * Write plugins to file
-   */
-  private async writePlugins(): Promise<void> {
-    await writeJsonFile(this.getPath(PLUGINS_FILE_NAME), this.plugins);
-  }
-  /**
-   * Read projects from file
-   */
-  private async readProjects(): Promise<void> {
-    this.projects =
-      ((await readJsonFile(this.getPath(PROJECTS_FILE_NAME)).catch(
-        () => []
-      )) as ProfileProject[]) || this.projects;
-  }
-
-  /**
-   * Write projects to file
-   */
-  private async writeProjects(): Promise<void> {
-    await writeJsonFile(this.getPath(PROJECTS_FILE_NAME), this.projects);
-  }
-}

package/src/services/project.ts

@@ -1,114 +0,0 @@
-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> {
-    const content = await this.readFile(path);
-    const projectContent = this.applyMacros(content);
-    const projectData = this.parseProjectContent(projectContent, path);
-
-    const project = new Project(projectData);
-    return this.extendProjectWithPlugins(project);
-  }
-
-  /**
-   * Resolve path
-   * @param path
-   */
-  resolvePath(path: string): string {
-    return resolve(path);
-  }
-
-  /**
-   * 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

@@ -1,130 +0,0 @@
-import { Inject, Service } from 'typedi';
-import { OutputService } from '@services';
-
-type ShutdownBlocker = () => 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) {}
-  /**
-   * 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;
-    }
-
-    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();
-      exitProcess(0);
-    } catch (error) {
-      exitProcess(1);
-    }
-  }
-
-  /**
-   * Execute all blockers with timeout
-   */
-  private async executeBlockersWithTimeout(): Promise<void> {
-    const blockerPromises = Array.from(this.blockers).map(blocker =>
-      this.executeBlocker(blocker)
-    );
-
-    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
-   */
-  private async executeBlocker(blocker: ShutdownBlocker): Promise<void> {
-    await blocker();
-  }
-}

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

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

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

@@ -1,17 +0,0 @@
-/**
- * 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/index.ts

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