@comake/skl-js-engine 1.0.8 → 1.1.0

package/dist/JsExecutor/PermissionBuilder.d.ts

@@ -0,0 +1,13 @@
+import type { PermissionConfig } from './types';
+/**
+ * Builds Deno permissions array based on options
+ * @param config - Permission configuration
+ * @returns Array of permission strings for Deno command
+ */
+export declare function buildDenoPermissions(config: PermissionConfig): string[];
+/**
+ * Validates permission configuration
+ * @param config - Permission configuration to validate
+ * @throws Error if configuration is invalid
+ */
+export declare function validatePermissionConfig(config: PermissionConfig): void;

package/dist/JsExecutor/PermissionBuilder.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePermissionConfig = exports.buildDenoPermissions = void 0;
+/**
+ * Builds Deno permissions array based on options
+ * @param config - Permission configuration
+ * @returns Array of permission strings for Deno command
+ */
+function buildDenoPermissions(config) {
+    const permissions = [];
+    // Add network permissions if enabled
+    if (config.allowNetwork) {
+        if (config.allowedDomains.length > 0) {
+            permissions.push(`--allow-net=${config.allowedDomains.join(',')}`);
+        }
+        else {
+            permissions.push('--allow-net');
+        }
+    }
+    // Add env permissions if enabled
+    if (config.allowEnv) {
+        permissions.push('--allow-env');
+    }
+    // Add read permissions if enabled
+    if (config.allowRead) {
+        permissions.push('--allow-read');
+    }
+    return permissions;
+}
+exports.buildDenoPermissions = buildDenoPermissions;
+/**
+ * Basic domain validation
+ * @param domain - Domain to validate
+ * @returns True if domain format is valid
+ */
+function isValidDomain(domain) {
+    // Basic domain validation - can be enhanced as needed
+    const domainRegex = /^[\dA-Za-z]([\dA-Za-z-]{0,61}[\dA-Za-z])?(\.[\dA-Za-z]([\dA-Za-z-]{0,61}[\dA-Za-z])?)*$/u;
+    return domainRegex.test(domain) && domain.length <= 253;
+}
+/**
+ * Validates permission configuration
+ * @param config - Permission configuration to validate
+ * @throws Error if configuration is invalid
+ */
+function validatePermissionConfig(config) {
+    if (config.allowedDomains.length > 0 && !config.allowNetwork) {
+        throw new Error('allowedDomains specified but allowNetwork is false');
+    }
+    // Validate domain format
+    for (const domain of config.allowedDomains) {
+        if (!isValidDomain(domain)) {
+            throw new Error(`Invalid domain format: ${domain}`);
+        }
+    }
+}
+exports.validatePermissionConfig = validatePermissionConfig;
+//# sourceMappingURL=PermissionBuilder.js.map

package/dist/JsExecutor/PermissionBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PermissionBuilder.js","sourceRoot":"","sources":["../../src/JsExecutor/PermissionBuilder.ts"],"names":[],"mappings":";;;AAEA;;;;GAIG;AACH,SAAgB,oBAAoB,CAAC,MAAwB;IAC3D,MAAM,WAAW,GAAa,EAAE,CAAC;IAEjC,qCAAqC;IACrC,IAAI,MAAM,CAAC,YAAY,EAAE;QACvB,IAAI,MAAM,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE;YACpC,WAAW,CAAC,IAAI,CAAC,eAAe,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;SACpE;aAAM;YACL,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;SACjC;KACF;IAED,iCAAiC;IACjC,IAAI,MAAM,CAAC,QAAQ,EAAE;QACnB,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;KACjC;IAED,kCAAkC;IAClC,IAAI,MAAM,CAAC,SAAS,EAAE;QACpB,WAAW,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;KAClC;IAED,OAAO,WAAW,CAAC;AACrB,CAAC;AAvBD,oDAuBC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,MAAc;IACnC,sDAAsD;IACtD,MAAM,WAAW,GAAG,0FAA0F,CAAC;IAC/G,OAAO,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC;AAC1D,CAAC;AAED;;;;GAIG;AACH,SAAgB,wBAAwB,CAAC,MAAwB;IAC/D,IAAI,MAAM,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE;QAC5D,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;KACvE;IAED,yBAAyB;IACzB,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,cAAc,EAAE;QAC1C,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE;YAC1B,MAAM,IAAI,KAAK,CAAC,0BAA0B,MAAM,EAAE,CAAC,CAAC;SACrD;KACF;AACH,CAAC;AAXD,4DAWC"}

package/dist/JsExecutor/constants.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Constants for JSExecutor configuration
+ */
+export declare const EXECUTION_CONSTANTS: {
+    readonly defaultTimeout: 5000;
+    readonly defaultFunctionName: "main";
+    readonly maxOutputLength: 500;
+    readonly denoCommand: "deno";
+    readonly denoFlags: readonly ["run", "--unstable-detect-cjs", "--quiet", "--unstable-sloppy-imports"];
+    readonly processSignals: {
+        readonly term: "SIGTERM";
+    };
+};
+/**
+ * Default execution options
+ */
+export declare const DEFAULT_EXECUTION_OPTIONS: {
+    readonly timeout: 5000;
+    readonly functionName: "main";
+    readonly allowNetwork: false;
+    readonly allowedDomains: readonly [];
+    readonly allowEnv: true;
+    readonly allowRead: false;
+    readonly debugMode: false;
+    readonly retries: 0;
+};

package/dist/JsExecutor/constants.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EXECUTION_OPTIONS = exports.EXECUTION_CONSTANTS = void 0;
+/**
+ * Constants for JSExecutor configuration
+ */
+exports.EXECUTION_CONSTANTS = {
+    defaultTimeout: 5000,
+    defaultFunctionName: 'main',
+    maxOutputLength: 500,
+    denoCommand: 'deno',
+    denoFlags: ['run', '--unstable-detect-cjs', '--quiet', '--unstable-sloppy-imports'],
+    processSignals: {
+        term: 'SIGTERM'
+    }
+};
+/**
+ * Default execution options
+ */
+exports.DEFAULT_EXECUTION_OPTIONS = {
+    timeout: exports.EXECUTION_CONSTANTS.defaultTimeout,
+    functionName: exports.EXECUTION_CONSTANTS.defaultFunctionName,
+    allowNetwork: false,
+    allowedDomains: [],
+    allowEnv: true,
+    allowRead: false,
+    debugMode: false,
+    retries: 0
+};
+//# sourceMappingURL=constants.js.map

package/dist/JsExecutor/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/JsExecutor/constants.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACU,QAAA,mBAAmB,GAAG;IACjC,cAAc,EAAE,IAAI;IACpB,mBAAmB,EAAE,MAAM;IAC3B,eAAe,EAAE,GAAG;IACpB,WAAW,EAAE,MAAM;IACnB,SAAS,EAAE,CAAE,KAAK,EAAE,uBAAuB,EAAE,SAAS,EAAE,2BAA2B,CAAE;IACrF,cAAc,EAAE;QACd,IAAI,EAAE,SAAS;KAChB;CACO,CAAC;AAEX;;GAEG;AACU,QAAA,yBAAyB,GAAG;IACvC,OAAO,EAAE,2BAAmB,CAAC,cAAc;IAC3C,YAAY,EAAE,2BAAmB,CAAC,mBAAmB;IACrD,YAAY,EAAE,KAAK;IACnB,cAAc,EAAE,EAAE;IAClB,QAAQ,EAAE,IAAI;IACd,SAAS,EAAE,KAAK;IAChB,SAAS,EAAE,KAAK;IAChB,OAAO,EAAE,CAAC;CACF,CAAC"}

package/dist/JsExecutor/denoUtils.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import type { ChildProcess } from 'node:child_process';
+/**
+ * Spawns a Deno process with the given arguments
+ * @param commandArgs - Command line arguments for Deno
+ * @returns The spawned child process
+ * @throws ProcessSpawnError if the process fails to spawn
+ */
+export declare function spawnDenoProcess(commandArgs: string[]): ChildProcess;

package/dist/JsExecutor/denoUtils.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnDenoProcess = void 0;
+const node_child_process_1 = require("node:child_process");
+const constants_1 = require("./constants");
+const errors_1 = require("./errors");
+/**
+ * Spawns a Deno process with the given arguments
+ * @param commandArgs - Command line arguments for Deno
+ * @returns The spawned child process
+ * @throws ProcessSpawnError if the process fails to spawn
+ */
+function spawnDenoProcess(commandArgs) {
+    try {
+        return (0, node_child_process_1.spawn)(constants_1.EXECUTION_CONSTANTS.denoCommand, commandArgs, {
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+    }
+    catch (error) {
+        throw new errors_1.ProcessSpawnError(error);
+    }
+}
+exports.spawnDenoProcess = spawnDenoProcess;
+//# sourceMappingURL=denoUtils.js.map

package/dist/JsExecutor/denoUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"denoUtils.js","sourceRoot":"","sources":["../../src/JsExecutor/denoUtils.ts"],"names":[],"mappings":";;;AACA,2DAA2C;AAC3C,2CAAkD;AAClD,qCAA6C;AAE7C;;;;;GAKG;AACH,SAAgB,gBAAgB,CAAC,WAAqB;IACpD,IAAI;QACF,OAAO,IAAA,0BAAK,EAAC,+BAAmB,CAAC,WAAW,EAAE,WAAW,EAAE;YACzD,KAAK,EAAE,CAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAE;SAClC,CAAC,CAAC;KACJ;IAAC,OAAO,KAAc,EAAE;QACvB,MAAM,IAAI,0BAAiB,CAAC,KAAc,CAAC,CAAC;KAC7C;AACH,CAAC;AARD,4CAQC"}

package/dist/JsExecutor/errors.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Custom error classes for better error handling in JSExecutor
+ */
+/**
+ * Error thrown when code execution times out
+ */
+export declare class ExecutionTimeoutError extends Error {
+    constructor(timeout: number);
+}
+/**
+ * Error thrown when the Deno process fails to spawn
+ */
+export declare class ProcessSpawnError extends Error {
+    constructor(originalError: Error);
+}
+/**
+ * Error thrown when the executor output cannot be parsed
+ */
+export declare class OutputParsingError extends Error {
+    constructor(rawOutput: string, originalError: Error);
+}
+/**
+ * Error thrown when code execution fails in general
+ */
+export declare class CodeExecutionError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when the JSExecutor is not initialized
+ */
+export declare class NotInitializedError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when the JSExecutor is already initialized
+ */
+export declare class AlreadyInitializedError extends Error {
+    constructor(message: string);
+}

package/dist/JsExecutor/errors.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Custom error classes for better error handling in JSExecutor
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlreadyInitializedError = exports.NotInitializedError = exports.CodeExecutionError = exports.OutputParsingError = exports.ProcessSpawnError = exports.ExecutionTimeoutError = void 0;
+/**
+ * Error thrown when code execution times out
+ */
+class ExecutionTimeoutError extends Error {
+    constructor(timeout) {
+        super(`Execution timed out after ${timeout}ms`);
+        this.name = 'ExecutionTimeoutError';
+    }
+}
+exports.ExecutionTimeoutError = ExecutionTimeoutError;
+/**
+ * Error thrown when the Deno process fails to spawn
+ */
+class ProcessSpawnError extends Error {
+    constructor(originalError) {
+        super(`Failed to spawn Deno process: ${originalError.message}`);
+        this.name = 'ProcessSpawnError';
+    }
+}
+exports.ProcessSpawnError = ProcessSpawnError;
+/**
+ * Error thrown when the executor output cannot be parsed
+ */
+class OutputParsingError extends Error {
+    constructor(rawOutput, originalError) {
+        super(`Failed to parse output: ${originalError.message}`);
+        this.name = 'OutputParsingError';
+    }
+}
+exports.OutputParsingError = OutputParsingError;
+/**
+ * Error thrown when code execution fails in general
+ */
+class CodeExecutionError extends Error {
+    constructor(message) {
+        super(`Failed to execute code: ${message}`);
+        this.name = 'CodeExecutionError';
+    }
+}
+exports.CodeExecutionError = CodeExecutionError;
+/**
+ * Error thrown when the JSExecutor is not initialized
+ */
+class NotInitializedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NotInitializedError';
+    }
+}
+exports.NotInitializedError = NotInitializedError;
+/**
+ * Error thrown when the JSExecutor is already initialized
+ */
+class AlreadyInitializedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AlreadyInitializedError';
+    }
+}
+exports.AlreadyInitializedError = AlreadyInitializedError;
+//# sourceMappingURL=errors.js.map

package/dist/JsExecutor/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/JsExecutor/errors.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH;;GAEG;AACH,MAAa,qBAAsB,SAAQ,KAAK;IAC9C,YAAmB,OAAe;QAChC,KAAK,CAAC,6BAA6B,OAAO,IAAI,CAAC,CAAC;QAChD,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;IACtC,CAAC;CACF;AALD,sDAKC;AAED;;GAEG;AACH,MAAa,iBAAkB,SAAQ,KAAK;IAC1C,YAAmB,aAAoB;QACrC,KAAK,CAAC,iCAAiC,aAAa,CAAC,OAAO,EAAE,CAAC,CAAC;QAChE,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF;AALD,8CAKC;AAED;;GAEG;AACH,MAAa,kBAAmB,SAAQ,KAAK;IAC3C,YAAmB,SAAiB,EAAE,aAAoB;QACxD,KAAK,CAAC,2BAA2B,aAAa,CAAC,OAAO,EAAE,CAAC,CAAC;QAC1D,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IACnC,CAAC;CACF;AALD,gDAKC;AAED;;GAEG;AACH,MAAa,kBAAmB,SAAQ,KAAK;IAC3C,YAAmB,OAAe;QAChC,KAAK,CAAC,2BAA2B,OAAO,EAAE,CAAC,CAAC;QAC5C,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IACnC,CAAC;CACF;AALD,gDAKC;AAED;;GAEG;AACH,MAAa,mBAAoB,SAAQ,KAAK;IAC5C,YAAmB,OAAe;QAChC,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;IACpC,CAAC;CACF;AALD,kDAKC;AAED;;GAEG;AACH,MAAa,uBAAwB,SAAQ,KAAK;IAChD,YAAmB,OAAe;QAChC,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC;IACxC,CAAC;CACF;AALD,0DAKC"}

package/dist/JsExecutor/examples/basic/index.js

@@ -0,0 +1,46 @@
+"use strict";
+// /* eslint-disable func-style */
+// /* eslint-disable no-console */
+// import path from 'node:path';
+// import { JsonRpcServer } from '../../transport/JsonRpcServer';
+// import { StdioTransport } from '../../transport/StdioTransport';
+// const server = new JsonRpcServer();
+// // Register methods that the child process can call
+// server.registerMethod('getTime', async(): Promise<{ result: string }> => {
+//   console.log('📅 Child requested current time');
+//   return {
+//     result: new Date().toISOString()
+//   };
+// });
+// // Handle notifications from child
+// server.registerMethod('childNotification', async(params: { message: string; timestamp: string }): Promise<void> => {
+//   console.log('📨 Received notification from child:', params);
+//   // Notifications don't return responses
+// });
+// const stdioTransport = new StdioTransport(path.resolve(__dirname, './process.ts'), server);
+// stdioTransport.setName('basic-example-parent');
+// const main = async(): Promise<void> => {
+//   console.log('🚀 Starting parent process');
+//   await stdioTransport.initialize();
+//   console.log('✅ Child process initialized');
+//   // Example: Make some calls to the child process using the new ergonomic API
+//   try {
+//     // Test basic ping
+//     // const pingResult = await stdioTransport.request('ping');
+//     // console.log('🏓 Ping result:', pingResult);
+//     // // Test child calling back to parent
+//     const callParentResult = await stdioTransport.request('callParent');
+//     console.log('🔄 Child callback result:', callParentResult);
+//     // // Test child sending notification
+//     // const notifyResult = await stdioTransport.request('sendNotification');
+//     // console.log('📤 Notification test result:', notifyResult);
+//     // // Test execute code method
+//     // const executeResult = await stdioTransport.request('executeCode', 'console.log("Hello from executed code!")');
+//     // console.log('⚡ Execute result:', executeResult);
+//     await stdioTransport.close();
+//   } catch (error: unknown) {
+//     console.error('❌ Error testing child methods:', (error as Error).message);
+//   }
+// };
+// main().catch(console.error);
+//# sourceMappingURL=index.js.map

package/dist/JsExecutor/examples/basic/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/JsExecutor/examples/basic/index.ts"],"names":[],"mappings":";AAAA,kCAAkC;AAClC,kCAAkC;AAClC,gCAAgC;AAChC,iEAAiE;AACjE,mEAAmE;AAEnE,sCAAsC;AAEtC,sDAAsD;AACtD,6EAA6E;AAC7E,oDAAoD;AACpD,aAAa;AACb,uCAAuC;AACvC,OAAO;AACP,MAAM;AAEN,qCAAqC;AACrC,uHAAuH;AACvH,iEAAiE;AACjE,4CAA4C;AAC5C,MAAM;AAEN,8FAA8F;AAC9F,kDAAkD;AAElD,2CAA2C;AAC3C,+CAA+C;AAC/C,uCAAuC;AACvC,gDAAgD;AAEhD,iFAAiF;AACjF,UAAU;AACV,yBAAyB;AACzB,kEAAkE;AAClE,qDAAqD;AAErD,8CAA8C;AAC9C,2EAA2E;AAC3E,kEAAkE;AAElE,4CAA4C;AAC5C,gFAAgF;AAChF,oEAAoE;AAEpE,qCAAqC;AACrC,wHAAwH;AACxH,0DAA0D;AAC1D,oCAAoC;AACpC,+BAA+B;AAC/B,iFAAiF;AACjF,MAAM;AACN,KAAK;AAEL,+BAA+B"}

package/dist/JsExecutor/examples/basic/process.js

@@ -0,0 +1,34 @@
+"use strict";
+// /* eslint-disable @typescript-eslint/ban-ts-comment */
+// // @ts-nocheck
+// import { BidirectionalStdioTransport } from '../../transport/StdioTransport.ts';
+// // Create a single transport that handles both server and client functionality
+// const transport = new BidirectionalStdioTransport();
+// transport.setName('basic-example-process');
+// // Register methods that the parent can call (server functionality)
+// transport.registerMethod('executeCode', async(message: string): Promise<{ result: string }> => ({
+//   result: 'Hello from the process'
+// }));
+// transport.registerMethod('ping', async(): Promise<string> => 'pong');
+// // Register a method that demonstrates calling back to the parent (client functionality)
+// transport.registerMethod('callParent', async(): Promise<{ result: string }> => {
+//   try {
+//     // Call the parent's getTime method
+//     const result = await transport.request('getTime');
+//     return { result: `Parent getTime returned: ${JSON.stringify(result)}` };
+//   } catch (error: unknown) {
+//     return { result: `Error calling parent: ${(error as Error).message}` };
+//   }
+// });
+// // Register a method that sends notifications to parent
+// transport.registerMethod('sendNotification', async(): Promise<{ result: string }> => {
+//   // Send a notification (no response expected)
+//   await transport.notify('childNotification', {
+//     message: 'Hello from child process',
+//     timestamp: new Date().toISOString()
+//   });
+//   return { result: 'Notification sent to parent' };
+// });
+// // Initialize the transport (this sets up stdio communication)
+// await transport.initialize();
+//# sourceMappingURL=process.js.map

package/dist/JsExecutor/examples/basic/process.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.js","sourceRoot":"","sources":["../../../../src/JsExecutor/examples/basic/process.ts"],"names":[],"mappings":";AAAA,yDAAyD;AAEzD,iBAAiB;AACjB,mFAAmF;AAEnF,iFAAiF;AACjF,uDAAuD;AACvD,8CAA8C;AAE9C,sEAAsE;AACtE,oGAAoG;AACpG,qCAAqC;AACrC,OAAO;AAEP,wEAAwE;AAExE,2FAA2F;AAC3F,mFAAmF;AACnF,UAAU;AACV,0CAA0C;AAC1C,yDAAyD;AACzD,+EAA+E;AAC/E,+BAA+B;AAC/B,8EAA8E;AAC9E,MAAM;AACN,MAAM;AAEN,0DAA0D;AAC1D,yFAAyF;AACzF,kDAAkD;AAClD,kDAAkD;AAClD,2CAA2C;AAC3C,0CAA0C;AAC1C,QAAQ;AACR,sDAAsD;AACtD,MAAM;AAEN,iEAAiE;AACjE,gCAAgC"}

package/dist/JsExecutor/examples/jsExecutor/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/JsExecutor/examples/jsExecutor/index.js

@@ -0,0 +1,48 @@
+"use strict";
+/* eslint-disable func-style */
+/* eslint-disable no-console */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const jsExecutor_1 = require("../../jsExecutor");
+const jsExecutor = new jsExecutor_1.JSExecutor(node_path_1.default.resolve(__dirname, './process.ts'), {
+    async getTime() {
+        return new Date().toISOString();
+    }
+});
+const main = async () => {
+    await jsExecutor.initialize();
+    try {
+        const result = await jsExecutor.execute(`
+    async function main() {
+            // Using SKL accessor - this gets converted to request('getTime', ...)
+            return await SKL.getTime({}, {
+                timeout: 50000,
+                retries: 0
+            });
+            
+            // Alternative: direct request call (still works)
+            // return await request('getTime', {}, {
+            //     timeout: 50000,
+            //     retries: 0
+            // });
+    }
+`, {}, {
+            timeout: 50000,
+            functionName: 'main',
+            retries: 0
+        });
+        console.log({ result });
+        // eslint-disable-next-line @typescript-eslint/no-implicit-any-catch
+    }
+    catch (error) {
+        console.error({ error });
+    }
+    finally {
+        await jsExecutor.shutdown();
+    }
+};
+main().catch(console.error);
+//# sourceMappingURL=index.js.map

package/dist/JsExecutor/examples/jsExecutor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/JsExecutor/examples/jsExecutor/index.ts"],"names":[],"mappings":";AAAA,+BAA+B;AAC/B,+BAA+B;;;;;AAE/B,0DAA6B;AAC7B,iDAA8C;AAE9C,MAAM,UAAU,GAAG,IAAI,uBAAU,CAAC,mBAAI,CAAC,OAAO,CAAC,SAAS,EAAE,cAAc,CAAC,EAAE;IACzE,KAAK,CAAC,OAAO;QACX,OAAO,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAClC,CAAC;CACF,CAAC,CAAC;AAEH,MAAM,IAAI,GAAG,KAAK,IAAkB,EAAE;IACpC,MAAM,UAAU,CAAC,UAAU,EAAE,CAAC;IAE9B,IAAI;QACF,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,OAAO,CACrC;;;;;;;;;;;;;;CAcL,EACK,EAAE,EACF;YACE,OAAO,EAAE,KAAK;YACd,YAAY,EAAE,MAAM;YACpB,OAAO,EAAE,CAAC;SACX,CACF,CAAC;QAEF,OAAO,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;QAC1B,oEAAoE;KACnE;IAAC,OAAO,KAAK,EAAE;QACd,OAAO,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;KAC1B;YAAS;QACR,MAAM,UAAU,CAAC,QAAQ,EAAE,CAAC;KAC7B;AACH,CAAC,CAAC;AAEF,IAAI,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC"}

package/dist/JsExecutor/examples/jsExecutor/process.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/JsExecutor/examples/jsExecutor/process.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/naming-convention */
+/* eslint-disable @typescript-eslint/no-empty-function */
+/* eslint-disable prefer-arrow-callback */
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+// @ts-nocheck
+const ChildStdioTransport_ts_1 = require("../../transport/stdio/ChildStdioTransport.ts");
+// Create a single transport that handles both server and client functionality
+const transport = new ChildStdioTransport_ts_1.ChildStdioTransport();
+transport.setName('jsExecutor-example-process');
+// Register methods that the parent can call (server functionality)
+transport.registerMethod('executeCode', async (message) => {
+    const AsyncFunction = Object.getPrototypeOf(async function () { }).constructor;
+    const executeCode = new AsyncFunction('args', 'console', 'request', 'SKL', `
+        ${message.code}
+        try {
+          if (typeof ${message.functionName} === 'function') {
+            return await ${message.functionName}(args);
+          }
+          throw new Error('Function name is not defined');
+        } catch (error) {
+          throw error;
+        }
+      `);
+    // Const sklEngine = new SKLEngine({
+    //   skdsEndpointUrl: 'http://localhost:3000'
+    // });
+    // Create SKL proxy that converts method calls to request calls
+    const SKL = new Proxy({}, {
+        get(target, prop) {
+            if (typeof prop === 'string') {
+                return async (...args) => {
+                    // Convert method call to request call
+                    // SKL.getTime() becomes request('getTime', {}, options)
+                    const [params = {}, options = {}] = args;
+                    return await transport.request(prop, params, options);
+                };
+            }
+        }
+    });
+    const result = await executeCode(message.args, console, transport.request.bind(transport), SKL);
+    return { result };
+});
+transport.registerMethod('ping', async () => 'pong');
+// Register a method that demonstrates calling back to the parent (client functionality)
+// transport.registerMethod('callParent', async(): Promise<{ result: string }> => {
+//   try {
+//     // Call the parent's getTime method
+//     const result = await transport.request('getTime');
+//     return { result: `Parent getTime returned: ${JSON.stringify(result)}` };
+//   } catch (error: unknown) {
+//     return { result: `Error calling parent: ${(error as Error).message}` };
+//   }
+// });
+// Initialize the transport (this sets up stdio communication)
+await transport.initialize();
+//# sourceMappingURL=process.js.map

package/dist/JsExecutor/examples/jsExecutor/process.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.js","sourceRoot":"","sources":["../../../../src/JsExecutor/examples/jsExecutor/process.ts"],"names":[],"mappings":";;AAAA,yDAAyD;AACzD,yDAAyD;AACzD,0CAA0C;AAC1C,qEAAqE;AACrE,sDAAsD;AACtD,cAAc;AACd,yFAAmF;AAQnF,8EAA8E;AAC9E,MAAM,SAAS,GAAG,IAAI,4CAAmB,EAAE,CAAC;AAC5C,SAAS,CAAC,OAAO,CAAC,4BAA4B,CAAC,CAAC;AAEhD,mEAAmE;AACnE,SAAS,CAAC,cAAc,CACtB,aAAa,EACb,KAAK,EAAC,OAA2B,EAA+B,EAAE;IAChE,MAAM,aAAa,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,eAAa,CAAC,CAAC,CAAC,WAAW,CAAC;IAC7E,MAAM,WAAW,GAAG,IAAI,aAAa,CACnC,MAAM,EACN,SAAS,EACT,SAAS,EACT,KAAK,EACL;UACI,OAAO,CAAC,IAAI;;uBAEC,OAAO,CAAC,YAAY;2BAChB,OAAO,CAAC,YAAY;;;;;;OAMxC,CACF,CAAC;IAEF,oCAAoC;IACpC,6CAA6C;IAC7C,MAAM;IAEN,+DAA+D;IAC/D,MAAM,GAAG,GAAG,IAAI,KAAK,CAAC,EAAE,EAAE;QACxB,GAAG,CAAC,MAAM,EAAE,IAAI;YACd,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;gBAC5B,OAAO,KAAK,EAAC,GAAG,IAAW,EAAE,EAAE;oBAC7B,sCAAsC;oBACtC,wDAAwD;oBACxD,MAAM,CAAE,MAAM,GAAG,EAAE,EAAE,OAAO,GAAG,EAAE,CAAE,GAAG,IAAI,CAAC;oBAC3C,OAAO,MAAM,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;gBACxD,CAAC,CAAC;aACH;QACH,CAAC;KACF,CAAC,CAAC;IAEH,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,CAAC;IAChG,OAAO,EAAE,MAAM,EAAE,CAAC;AACpB,CAAC,CACF,CAAC;AAEF,SAAS,CAAC,cAAc,CAAC,MAAM,EAAE,KAAK,IAAoB,EAAE,CAAC,MAAM,CAAC,CAAC;AAErE,wFAAwF;AACxF,mFAAmF;AACnF,UAAU;AACV,0CAA0C;AAC1C,yDAAyD;AACzD,+EAA+E;AAC/E,+BAA+B;AAC/B,8EAA8E;AAC9E,MAAM;AACN,MAAM;AAEN,8DAA8D;AAC9D,MAAM,SAAS,CAAC,UAAU,EAAE,CAAC"}

package/dist/JsExecutor/index.d.ts

@@ -0,0 +1,6 @@
+export { DEFAULT_EXECUTION_OPTIONS, EXECUTION_CONSTANTS } from './constants';
+export { CodeExecutionError, ExecutionTimeoutError, OutputParsingError, ProcessSpawnError } from './errors';
+export { JSExecutor } from './jsExecutor';
+export { buildDenoPermissions, validatePermissionConfig } from './PermissionBuilder';
+export * from './transport';
+export type { ExecutionOptions, ExecutionResult, ExecutorInput, ExecutorOutput, PermissionConfig, ProcessCommunicationData } from './types';

package/dist/JsExecutor/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePermissionConfig = exports.buildDenoPermissions = exports.JSExecutor = exports.ProcessSpawnError = exports.OutputParsingError = exports.ExecutionTimeoutError = exports.CodeExecutionError = exports.EXECUTION_CONSTANTS = exports.DEFAULT_EXECUTION_OPTIONS = void 0;
+// Main executor class
+// Constants
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "DEFAULT_EXECUTION_OPTIONS", { enumerable: true, get: function () { return constants_1.DEFAULT_EXECUTION_OPTIONS; } });
+Object.defineProperty(exports, "EXECUTION_CONSTANTS", { enumerable: true, get: function () { return constants_1.EXECUTION_CONSTANTS; } });
+// Error classes
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "CodeExecutionError", { enumerable: true, get: function () { return errors_1.CodeExecutionError; } });
+Object.defineProperty(exports, "ExecutionTimeoutError", { enumerable: true, get: function () { return errors_1.ExecutionTimeoutError; } });
+Object.defineProperty(exports, "OutputParsingError", { enumerable: true, get: function () { return errors_1.OutputParsingError; } });
+Object.defineProperty(exports, "ProcessSpawnError", { enumerable: true, get: function () { return errors_1.ProcessSpawnError; } });
+var jsExecutor_1 = require("./jsExecutor");
+Object.defineProperty(exports, "JSExecutor", { enumerable: true, get: function () { return jsExecutor_1.JSExecutor; } });
+// Utility functions (for advanced usage)
+var PermissionBuilder_1 = require("./PermissionBuilder");
+Object.defineProperty(exports, "buildDenoPermissions", { enumerable: true, get: function () { return PermissionBuilder_1.buildDenoPermissions; } });
+Object.defineProperty(exports, "validatePermissionConfig", { enumerable: true, get: function () { return PermissionBuilder_1.validatePermissionConfig; } });
+__exportStar(require("./transport"), exports);
+//# sourceMappingURL=index.js.map

package/dist/JsExecutor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/JsExecutor/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,sBAAsB;AACtB,YAAY;AACZ,yCAA6E;AAApE,sHAAA,yBAAyB,OAAA;AAAE,gHAAA,mBAAmB,OAAA;AACvD,gBAAgB;AAChB,mCAA4G;AAAnG,4GAAA,kBAAkB,OAAA;AAAE,+GAAA,qBAAqB,OAAA;AAAE,4GAAA,kBAAkB,OAAA;AAAE,2GAAA,iBAAiB,OAAA;AACzF,2CAA0C;AAAjC,wGAAA,UAAU,OAAA;AACnB,yCAAyC;AACzC,yDAAqF;AAA5E,yHAAA,oBAAoB,OAAA;AAAE,6HAAA,wBAAwB,OAAA;AACvD,8CAA4B"}

package/dist/JsExecutor/jsExecutor.d.ts

@@ -0,0 +1,67 @@
+import type { TransportConfig } from './transport';
+import type { ExecutionOptions, IShutdownOptions } from './types';
+export declare type IJSCallbacks = Record<string, (...args: any[]) => any>;
+/**
+ * JSExecutor V2 with enhanced abort control for immediate shutdown
+ *
+ * @example Writing abort-aware callbacks:
+ * ```typescript
+ * const jsExecutor = new JSExecutorV2(scriptPath, {
+ *   async myCallback(): Promise<string> {
+ *     return new Promise((resolve, reject) => {
+ *       const timeoutId = setTimeout(() => resolve('done'), 5000);
+ *
+ *       // Listen to the global abort signal to clean up resources
+ *       const abortSignal = JSExecutorV2.getGlobalAbortSignal();
+ *       const onAbort = () => {
+ *         clearTimeout(timeoutId);
+ *         reject(new Error('Operation aborted'));
+ *       };
+ *
+ *       if (abortSignal.aborted) {
+ *         onAbort();
+ *         return;
+ *       }
+ *
+ *       abortSignal.addEventListener('abort', onAbort);
+ *     });
+ *   }
+ * });
+ * ```
+ */
+export declare class JSExecutor {
+    private readonly executorScriptPath;
+    private readonly callbacks;
+    private isInitialized;
+    private server?;
+    private transport?;
+    private readonly abortController;
+    private static readonly globalAbortController;
+    private shutdownTimeout?;
+    constructor(executorScriptPath: string, callbacks: IJSCallbacks);
+    /**
+     * Static method to check if any JSExecutor instance is being shut down
+     * Callbacks can use this to check if they should abort their operations
+     */
+    static isShuttingDown(): boolean;
+    /**
+     * Get the global abort signal that callbacks can listen to
+     * This allows callbacks to immediately abort when any JSExecutor shuts down
+     */
+    static getGlobalAbortSignal(): AbortSignal;
+    initialize(config?: TransportConfig, executionOptions?: ExecutionOptions): Promise<void>;
+    shutdown(options?: IShutdownOptions): Promise<void>;
+    private shutdownCore;
+    private rpcComplaintCallback;
+    /**
+     * Wrap a callback with abort functionality
+     * The callback will be automatically aborted if JSExecutor is shut down
+     */
+    private wrapCallbackWithAbort;
+    execute(code: string, args: Record<string, any>, executionOptions: ExecutionOptions): Promise<any>;
+    /**
+     * Legacy method for backward compatibility
+     * @deprecated Use execute() instead
+     */
+    call(methodName: string, ...args: any[]): Promise<any>;
+}