@comake/skl-js-engine 1.3.8 → 1.3.10

package/src/JsExecutor/transport/utils/PollingUtils.ts

@@ -0,0 +1,114 @@
+/**
+ * Utility for polling operations with timeout
+ */
+
+import { Logger } from '../../../logger';
+
+/**
+ * Options for polling with timeout
+ */
+export interface PollingOptions {
+  /** Total timeout in milliseconds */
+  timeout: number;
+  /** Polling interval in milliseconds (default: 100ms) */
+  interval?: number;
+  /** Initial delay before starting polling in milliseconds (default: 0ms) */
+  initialDelay?: number;
+}
+
+/**
+ * Poll a condition function until it returns true or timeout is reached
+ *
+ * @param conditionFn - Function that returns true when condition is met, false to continue polling
+ * @param options - Polling configuration
+ * @param timeoutErrorMessage - Custom error message for timeout
+ * @returns Promise that resolves when condition is met or rejects on timeout
+ *
+ * @example
+ * ```typescript
+ * // Wait for process to be ready
+ * await pollUntilTrue(
+ *   () => process.isRunning(),
+ *   { timeout: 5000, interval: 100 },
+ *   'Process failed to start'
+ * );
+ * ```
+ */
+export async function pollUntilTrue(
+  conditionFn: () => boolean | Promise<boolean>,
+  options: PollingOptions,
+  timeoutErrorMessage: string
+): Promise<void> {
+  const { timeout, interval = 100, initialDelay = 0 } = options;
+  const startTime = Date.now();
+
+  // Initial delay if specified
+  if (initialDelay > 0) {
+    await new Promise<void>((resolve: () => void): NodeJS.Timeout => setTimeout(resolve, initialDelay));
+  }
+
+  while (Date.now() - startTime < timeout) {
+    try {
+      // Condition met!
+      if (await conditionFn()) {
+        return;
+      }
+    } catch (error: unknown) {
+      Logger.getInstance().error(new Error(`${timeoutErrorMessage} after ${timeout}ms`), error);
+    }
+
+    // Wait before next check
+    await new Promise<void>((resolve: () => void): NodeJS.Timeout => setTimeout(resolve, interval));
+  }
+
+  // Timeout reached
+  throw new Error(`${timeoutErrorMessage} after ${timeout}ms`);
+}
+
+/**
+ * Poll an async operation until it succeeds or timeout is reached
+ *
+ * @param operationFn - Async function to retry until it succeeds
+ * @param options - Polling configuration
+ * @param timeoutErrorMessage - Custom error message for timeout
+ * @returns Promise that resolves with operation result or rejects on timeout
+ *
+ * @example
+ * ```typescript
+ * // Wait for ping to succeed
+ * await pollUntilSuccess(
+ *   () => client.ping(),
+ *   { timeout: 10000, interval: 500 },
+ *   'Failed to connect'
+ * );
+ * ```
+ */
+export async function pollUntilSuccess<T>(
+  operationFn: () => Promise<T>,
+  options: PollingOptions,
+  timeoutErrorMessage: string
+): Promise<T> {
+  const { timeout, interval = 100, initialDelay = 0 } = options;
+  const startTime = Date.now();
+
+  // Initial delay if specified
+  if (initialDelay > 0) {
+    await new Promise<void>((resolve: () => void): NodeJS.Timeout => setTimeout(resolve, initialDelay));
+  }
+
+  while (Date.now() - startTime < timeout) {
+    try {
+      // Success!
+      return await operationFn();
+    } catch (error: unknown) {
+      Logger.getInstance().error(new Error(`${timeoutErrorMessage} after ${timeout}ms`), error);
+      // Operation failed, continue polling if we have time
+      if (Date.now() - startTime < timeout) {
+        await new Promise<void>((resolve: () => void): NodeJS.Timeout => setTimeout(resolve, interval));
+      }
+    }
+  }
+
+  // Timeout reached
+  throw new Error(`${timeoutErrorMessage} after ${timeout}ms`);
+}

package/src/JsExecutor/types.ts

@@ -0,0 +1,130 @@
+/**
+ * Options for code execution
+ */
+export interface ExecutionOptions {
+  /**
+   * Maximum execution time in milliseconds
+   */
+  timeout?: number;
+
+  /**
+   * Maximum number of retries (default: 0)
+   */
+  retries?: number;
+
+  /**
+   * Name of the function to execute (default: 'main')
+   */
+  functionName?: string;
+
+  /**
+   * Allow network access (default: false)
+   */
+  allowNetwork?: boolean;
+
+  /**
+   * List of domains allowed for network access
+   * Only used when allowNetwork is true
+   */
+  allowedDomains?: string[];
+
+  /**
+   * Allow file system read access (default: false)
+   */
+  allowRead?: boolean;
+
+  /**
+   * Allow access to environment variables (default: false)
+   */
+  allowEnv?: boolean;
+
+  /**
+   * Enable debug mode with additional logging (default: false)
+   */
+  debugMode?: boolean;
+}
+
+/**
+ * Result of code execution
+ */
+export interface ExecutionResult {
+  /**
+   * Whether the execution was successful
+   */
+  success: boolean;
+
+  /**
+   * Execution result (if successful)
+   */
+  result?: any;
+
+  /**
+   * Execution error (if failed)
+   */
+  error?: Error;
+
+  /**
+   * Console output logs
+   */
+  logs: string[];
+
+  /**
+   * Execution time in milliseconds
+   */
+  executionTime: number;
+}
+
+/**
+ * Input data structure for the executor
+ */
+export interface ExecutorInput {
+  code: string;
+  args: Record<string, any>;
+  functionName: string;
+  skdsEndpointUrl: string;
+}
+
+/**
+ * Output data structure from the executor
+ */
+export interface ExecutorOutput {
+  result?: any;
+  error?: {
+    message: string;
+    name?: string;
+    stack?: string;
+  };
+  logs: string[];
+  executionTime?: number;
+}
+
+/**
+ * Process communication data structure
+ */
+export interface ProcessCommunicationData {
+  stdoutData: string;
+  stderrData: string;
+}
+
+/**
+ * Permission configuration for Deno execution
+ */
+export interface PermissionConfig {
+  allowNetwork: boolean;
+  allowedDomains: string[];
+  allowEnv: boolean;
+  allowRead: boolean;
+}
+
+export interface ICodeExecutor {
+  execute: (code: string, args: Record<string, any>, executionOptions: ExecutionOptions) => Promise<any>;
+}
+
+export interface IShutdownOptions {
+  /**
+   * Shutdown after timeout in milliseconds
+   * If not provided, the process will be terminated immediately
+   * If provided, the process will be terminated after the timeout, existing timeouts will be cancelled
+   */
+  afterTimeout?: number;
+}