@runium/cli 0.0.1

package/src/services/project.ts

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

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

@@ -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/index.ts

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

package/tsconfig.json

@@ -0,0 +1,40 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "target": "esnext",
+    "outDir": "./lib",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "forceConsistentCasingInFileNames": true,
+    "declaration": false,
+    "sourceMap": false,
+    "strictNullChecks": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "paths": {
+      "@commands/*": ["src/commands/*"],
+      "@commands": ["src/commands/index.js"],
+      "@constants/*": ["src/constants/*"],
+      "@constants": ["src/constants/index.js"],
+      "@macros/*": ["src/macros/*"],
+      "@macros": ["src/macros/index.js"],
+      "@services/*": ["src/services/*"],
+      "@services": ["src/services/index.js"],
+      "@utils/*": ["src/utils/*"],
+      "@utils": ["src/utils/index.js"]
+    }
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "lib/**/*"
+  ]
+}