@nodetool-ai/sandbox-runtime 0.0.0-stage → 0.8.9-bootstrap.0

package/vendor/quickjs/sandbox/asyncVersion/createAsyncEvalCodeFunction.js

@@ -0,0 +1,76 @@
+import { createTimeInterval } from '../../createTimeInterval.js';
+import { rejectAndFlushPendingHostPromises } from '../expose/pendingHostPromises.js';
+import { getMaxIntervalAmount } from '../getMaxIntervalAmount.js';
+import { getMaxTimeoutAmount } from '../getMaxTimeoutAmount.js';
+import { handleEvalError } from '../handleEvalError.js';
+import { handleToNative } from '../handleToNative/handleToNative.js';
+import { provideTimingFunctions } from '../provide/provideTimingFunctions.js';
+export const createAsyncEvalCodeFunction = (input, scope) => {
+    const { ctx, sandboxOptions, transpileFile } = input;
+    return async (code, filename = '/src/index.js', evalOptions) => {
+        const eventLoopinterval = createTimeInterval(() => ctx.runtime.executePendingJobs(), 0);
+        const timeoutMs = sandboxOptions.executionTimeout ?? 0;
+        let timeoutId;
+        let nativePromise;
+        let timedOut = false;
+        const { dispose: disposeTimer } = provideTimingFunctions(ctx, {
+            maxTimeoutCount: getMaxTimeoutAmount(sandboxOptions),
+            maxIntervalCount: getMaxIntervalAmount(sandboxOptions),
+        });
+        const disposeStep = () => {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            eventLoopinterval?.clear();
+            disposeTimer();
+        };
+        try {
+            const jsCode = transpileFile(code);
+            const evalResult = await ctx.evalCodeAsync(jsCode, filename, {
+                strict: true,
+                strip: false,
+                backtraceBarrier: true,
+                ...evalOptions,
+                type: 'module',
+            });
+            const handle = scope.manage(ctx.unwrapResult(evalResult));
+            const native = handleToNative(ctx, handle, scope);
+            nativePromise = (async () => {
+                const res = await native;
+                return res.default;
+            })();
+            const result = await Promise.race([
+                nativePromise,
+                new Promise((_resolve, reject) => {
+                    if (timeoutMs > 0) {
+                        timeoutId = setTimeout(() => {
+                            timedOut = true;
+                            const err = new Error('The script execution has exceeded the maximum allowed time limit.');
+                            err.name = 'ExecutionTimeout';
+                            reject(err);
+                        }, timeoutMs);
+                    }
+                }),
+            ]);
+            return { ok: true, data: result };
+        }
+        catch (err) {
+            return handleEvalError(err);
+        }
+        finally {
+            if (timedOut && nativePromise) {
+                // Reject unresolved host-injected promises to avoid leaving QuickJS promises
+                // pending while disposing the runtime after timeout.
+                await rejectAndFlushPendingHostPromises(ctx);
+                // Force-fast interrupt handling and give pending guest jobs a short window to settle.
+                ctx.runtime.setInterruptHandler(() => true);
+                const cleanupWait = Math.min(Math.max(timeoutMs, 50), 1000);
+                await Promise.race([
+                    nativePromise.catch(() => undefined),
+                    new Promise(resolve => setTimeout(resolve, cleanupWait)),
+                ]);
+            }
+            disposeStep();
+        }
+    };
+};

package/vendor/quickjs/sandbox/asyncVersion/createAsyncValidateCodeFunction.d.ts

@@ -0,0 +1,3 @@
+import type { CodeFunctionAsyncInput } from '../../types/CodeFunctionInput.js';
+import type { SandboxValidateCode } from '../../types/SandboxValidateCode.js';
+export declare const createAsyncValidateCodeFunction: (input: CodeFunctionAsyncInput) => SandboxValidateCode;

package/vendor/quickjs/sandbox/asyncVersion/createAsyncValidateCodeFunction.js

@@ -0,0 +1,22 @@
+import { handleEvalError } from '../handleEvalError.js';
+export const createAsyncValidateCodeFunction = (input) => {
+    const { ctx } = input;
+    return async (code, filename = '/src/index.js', evalOptions) => {
+        try {
+            ctx
+                .unwrapResult(await ctx.evalCodeAsync(code, filename, {
+                strict: true,
+                strip: true,
+                backtraceBarrier: true,
+                ...evalOptions,
+                type: 'module',
+                compileOnly: true,
+            }))
+                .dispose();
+            return { ok: true };
+        }
+        catch (err) {
+            return handleEvalError(err);
+        }
+    };
+};

package/vendor/quickjs/sandbox/asyncVersion/executeAsyncSandboxFunction.d.ts

@@ -0,0 +1,12 @@
+import type { IFs } from 'memfs';
+import type { QuickJSAsyncContext, Scope } from 'quickjs-emscripten-core';
+import type { AsyncSandboxFunction } from '../../types/SandboxFunction.js';
+import type { SandboxAsyncOptions } from '../../types/SandboxOptions.js';
+export declare const executeAsyncSandboxFunction: <T>(input: {
+    ctx: QuickJSAsyncContext;
+    fs: IFs;
+    scope: Scope;
+    sandboxOptions: SandboxAsyncOptions;
+    sandboxedFunction: AsyncSandboxFunction<T>;
+    transpileFile: (input: string) => string;
+}) => Promise<T>;

package/vendor/quickjs/sandbox/asyncVersion/executeAsyncSandboxFunction.js

@@ -0,0 +1,9 @@
+import { createAsyncEvalCodeFunction } from './createAsyncEvalCodeFunction.js';
+import { createAsyncValidateCodeFunction } from './createAsyncValidateCodeFunction.js';
+export const executeAsyncSandboxFunction = async (input) => {
+    const { ctx, sandboxOptions, sandboxedFunction, fs, transpileFile } = input;
+    const opt = { ctx, sandboxOptions, transpileFile };
+    const evalCode = createAsyncEvalCodeFunction(opt, input.scope);
+    const validateCode = createAsyncValidateCodeFunction(opt);
+    return await sandboxedFunction({ ctx, evalCode, validateCode, mountedFs: fs });
+};

package/vendor/quickjs/sandbox/asyncVersion/getAsyncModuleLoader.d.ts

@@ -0,0 +1,4 @@
+import type { IFs } from 'memfs';
+import type { JSModuleLoaderAsync } from 'quickjs-emscripten-core';
+import type { RuntimeOptions } from '../../types/RuntimeOptions.js';
+export declare const getAsyncModuleLoader: (fs: IFs, _runtimeOptions: RuntimeOptions) => JSModuleLoaderAsync;

package/vendor/quickjs/sandbox/asyncVersion/getAsyncModuleLoader.js

@@ -0,0 +1,30 @@
+import { join } from 'node:path';
+export const getAsyncModuleLoader = (fs, _runtimeOptions) => {
+    const moduleLoader = (inputName, _context) => {
+        let name = inputName;
+        // if it does not exist
+        if (!fs.existsSync(name)) {
+            // try to add the .js extension
+            if (fs.existsSync(`${name}.js`)) {
+                name = `${name}.js`;
+            }
+            else {
+                return { error: new Error(`Module '${inputName}' not installed or available`) };
+            }
+        }
+        // if it is a folder, we need to use the index.js file
+        if (fs.lstatSync(name).isDirectory()) {
+            name = join(name, 'index.js');
+            if (!fs.existsSync(name)) {
+                return { error: new Error(`Module '${inputName}' not installed or available`) };
+            }
+        }
+        // workaround: as we can not provide the real import.meta.url functionality, we replace it dynamically with the current value string
+        const value = fs.readFileSync(name)?.toString().replaceAll('import.meta.url', `'file://${name}'`);
+        if (!value) {
+            return { error: new Error(`Module '${name}' not installed or available`) };
+        }
+        return { value };
+    };
+    return moduleLoader;
+};

package/vendor/quickjs/sandbox/asyncVersion/modulePathNormalizerAsync.d.ts

@@ -0,0 +1,2 @@
+import type { JSModuleNormalizerAsync } from 'quickjs-emscripten-core';
+export declare const modulePathNormalizerAsync: JSModuleNormalizerAsync;

package/vendor/quickjs/sandbox/asyncVersion/modulePathNormalizerAsync.js

@@ -0,0 +1,12 @@
+import { join, resolve } from 'node:path';
+export const modulePathNormalizerAsync = async (baseName, requestedName) => {
+    // relative import
+    if (requestedName.startsWith('.')) {
+        const parts = baseName.split('/');
+        parts.pop();
+        return resolve(`/${parts.join('/')}`, requestedName);
+    }
+    // module import
+    const moduleName = requestedName.replace('node:', '');
+    return join('/node_modules', moduleName);
+};

package/vendor/quickjs/sandbox/asyncVersion/prepareAsyncNodeCompatibility.d.ts

@@ -0,0 +1,3 @@
+import type { QuickJSAsyncContext } from 'quickjs-emscripten-core';
+import type { SandboxAsyncOptions } from '../../types/SandboxOptions.js';
+export declare const prepareAsyncNodeCompatibility: (vm: QuickJSAsyncContext, sandboxOptions: SandboxAsyncOptions) => Promise<void>;

package/vendor/quickjs/sandbox/asyncVersion/prepareAsyncNodeCompatibility.js

@@ -0,0 +1,11 @@
+export const prepareAsyncNodeCompatibility = async (vm, sandboxOptions) => {
+    vm.unwrapResult(await vm.evalCodeAsync(`
+      import 'node:buffer';
+      import 'node:util';
+      import 'node:url';
+      import '@node_compatibility/headers';
+      import '@node_compatibility/request';
+      import '@node_compatibility/response';
+      ${sandboxOptions.enableTestUtils ? "import 'test'" : ''}
+      `, undefined, { type: 'module' })).dispose();
+};

package/vendor/quickjs/sandbox/asyncVersion/prepareAsyncSandbox.d.ts

@@ -0,0 +1,4 @@
+import type { IFs } from 'memfs';
+import type { QuickJSAsyncContext, Scope } from 'quickjs-emscripten-core';
+import type { SandboxBaseOptions } from '../../types/SandboxOptions.js';
+export declare const prepareAsyncSandbox: (ctx: QuickJSAsyncContext, scope: Scope, sandboxOptions: SandboxBaseOptions, fs: IFs) => void;

package/vendor/quickjs/sandbox/asyncVersion/prepareAsyncSandbox.js

@@ -0,0 +1,10 @@
+import { provideConsole } from '../provide/provideConsole.js';
+import { provideEnv } from '../provide/provideEnv.js';
+import { provideFs } from '../provide/provideFs.js';
+import { provideHttp } from '../provide/provideHttp.js';
+export const prepareAsyncSandbox = (ctx, scope, sandboxOptions, fs) => {
+    provideFs(ctx, scope, sandboxOptions, fs);
+    provideConsole(ctx, scope, sandboxOptions);
+    provideEnv(ctx, scope, sandboxOptions);
+    provideHttp(ctx, scope, sandboxOptions, { fs: sandboxOptions.allowFs ? fs : undefined });
+};

package/vendor/quickjs/sandbox/expose/expose.d.ts

@@ -0,0 +1,3 @@
+import { type QuickJSAsyncContext, type QuickJSContext, type QuickJSHandle, Scope } from 'quickjs-emscripten-core';
+export declare const getHandle: (scope: Scope, ctx: QuickJSContext | QuickJSAsyncContext, name: string, input: unknown) => QuickJSHandle;
+export declare const expose: (ctx: QuickJSContext | QuickJSAsyncContext, _parentScope: Scope, input: Record<string, unknown>, parent?: QuickJSHandle) => void;

package/vendor/quickjs/sandbox/expose/expose.js

@@ -0,0 +1,155 @@
+import { Scope } from 'quickjs-emscripten-core';
+import { HEADERS_MARKER } from '../../adapter/fetch.js';
+import { handleToNative } from '../handleToNative/handleToNative.js';
+import { isES2015Class } from './isES2015Class.js';
+import { isObject } from './isObject.js';
+import { registerPendingHostPromise, unregisterPendingHostPromise } from './pendingHostPromises.js';
+export const getHandle = (scope, ctx, name, input) => {
+    // null
+    if (input === null) {
+        return ctx.null;
+    }
+    // null
+    if (input === undefined) {
+        return ctx.undefined;
+    }
+    // Map serialized fetch headers from host to a native Headers instance in guest.
+    if (input && typeof input === 'object' && HEADERS_MARKER in input && '_headers' in input) {
+        const headersValue = input._headers;
+        const headersJson = JSON.stringify(headersValue);
+        return ctx.unwrapResult(ctx.evalCode(`new Headers(${headersJson})`));
+    }
+    // Array Buffer
+    if (input instanceof ArrayBuffer) {
+        return ctx.newArrayBuffer(input);
+    }
+    // Promise
+    if (input instanceof Promise) {
+        const promise = ctx.newPromise();
+        registerPendingHostPromise(ctx, promise);
+        promise.settled.finally(() => {
+            unregisterPendingHostPromise(ctx, promise);
+            if (ctx.alive) {
+                ctx.runtime.executePendingJobs();
+            }
+        });
+        input.then(r => {
+            if (!ctx.alive || !promise.alive) {
+                return;
+            }
+            const handle = getHandle(scope, ctx, '', r);
+            promise.resolve(handle);
+            handle.dispose();
+        }, e => {
+            if (!ctx.alive || !promise.alive) {
+                return;
+            }
+            const handle = getHandle(scope, ctx, '', e);
+            promise.reject(handle);
+            handle.dispose();
+        });
+        return promise.handle;
+    }
+    switch (typeof input) {
+        case 'number':
+            return ctx.newNumber(input);
+        case 'string':
+            return ctx.newString(input);
+        case 'boolean':
+            return input ? ctx.true : ctx.false;
+        case 'bigint':
+            return ctx.newBigInt(input);
+        case 'symbol':
+            return ctx.newSymbolFor(input);
+        case 'function':
+            return ctx.newFunction(name, function (...args) {
+                const s = new Scope();
+                const that = handleToNative(ctx, this, s);
+                if (this) {
+                    this.dispose();
+                }
+                if (isES2015Class(input) && isObject(that)) {
+                    const result = new input(...args);
+                    for (const [key, value] of Object.entries(result)) {
+                        ctx.setProp(this, key, getHandle(s, ctx, key, value));
+                    }
+                    s.dispose();
+                    return this;
+                }
+                const rawParam = [];
+                for (const param of args) {
+                    const p = s.manage(param);
+                    rawParam.push(handleToNative(ctx, p, s));
+                }
+                try {
+                    const handle = getHandle(s, ctx, '', input.apply(that, rawParam));
+                    return handle;
+                }
+                finally {
+                    s.dispose();
+                }
+            });
+    }
+    if (typeof input === 'object' || input === null) {
+        if (input instanceof Date) {
+            const x = ctx.evalCode(`new Date(${input.getTime()})`);
+            return x.unwrap();
+        }
+        const prototype = Object.getPrototypeOf(input);
+        const prototypeHandle = prototype && prototype !== Object.prototype && prototype !== Array.prototype
+            ? getHandle(scope, ctx, '', prototype)
+            : undefined;
+        const handle = Array.isArray(input) ? ctx.newArray() : ctx.newObject(prototypeHandle);
+        setProperties(ctx, scope, input, handle);
+        prototypeHandle?.dispose();
+        return handle;
+    }
+    throw new Error(`unsupported data type in ${name} ${typeof input}`);
+};
+const setProperties = (ctx, scope, 
+// biome-ignore lint/complexity/noBannedTypes: ok here
+input, parent) => {
+    const descs = ctx.newObject();
+    const setEntry = (key, desc) => {
+        const keyHandle = getHandle(scope, ctx, '', key);
+        const valueHandle = typeof desc.value === 'undefined' ? undefined : getHandle(scope, ctx, '', desc.value);
+        const getterHandle = typeof desc.get === 'undefined' ? undefined : getHandle(scope, ctx, '', desc.get);
+        const setterHandle = typeof desc.set === 'undefined' ? undefined : getHandle(scope, ctx, '', desc.set);
+        const descObj = ctx.newObject();
+        for (const [k, v] of Object.entries(desc)) {
+            const v2 = k === 'value' ? valueHandle : k === 'get' ? getterHandle : k === 'set' ? setterHandle : v ? ctx.true : ctx.false;
+            if (v2) {
+                ctx.setProp(descObj, k, v2);
+            }
+        }
+        ctx.setProp(descs, keyHandle, descObj);
+        keyHandle.dispose();
+        valueHandle?.dispose();
+        getterHandle?.dispose();
+        setterHandle?.dispose();
+        descObj.dispose();
+    };
+    const desc = Object.getOwnPropertyDescriptors(input);
+    for (const [k, v] of Object.entries(desc)) {
+        setEntry(k, v);
+    }
+    for (const k of Object.getOwnPropertySymbols(desc)) {
+        setEntry(k, desc[k]);
+    }
+    const fnHandle = ctx.unwrapResult(ctx.evalCode('Object.defineProperties'));
+    const callHandle = ctx.unwrapResult(ctx.callFunction(fnHandle, ctx.undefined, parent, descs));
+    callHandle.dispose();
+    fnHandle.dispose();
+    descs.dispose();
+};
+const addProp = (scope, ctx, parent, name, value) => {
+    const handle = scope.manage(getHandle(scope, ctx, name, value));
+    ctx.setProp(parent, name, handle);
+};
+export const expose = (ctx, _parentScope, input, parent) => {
+    const scope = new Scope();
+    for (const [key, value] of Object.entries(input)) {
+        addProp(scope, ctx, parent ?? ctx.global, key, value);
+    }
+    scope.dispose();
+};

package/vendor/quickjs/sandbox/expose/isES2015Class.d.ts

@@ -0,0 +1 @@
+export declare function isES2015Class(cls: any): cls is new (...args: any[]) => any;

package/vendor/quickjs/sandbox/expose/isES2015Class.js

@@ -0,0 +1,4 @@
+const classRegex = new RegExp(/^class\s/);
+export function isES2015Class(cls) {
+    return typeof cls === 'function' && classRegex.test(Function.prototype.toString.call(cls));
+}

package/vendor/quickjs/sandbox/expose/isObject.d.ts

@@ -0,0 +1 @@
+export declare function isObject(value: any): value is object | Function;

package/vendor/quickjs/sandbox/expose/isObject.js

@@ -0,0 +1,4 @@
+// biome-ignore lint/complexity/noBannedTypes: ok here
+export function isObject(value) {
+    return typeof value === 'function' || (typeof value === 'object' && value !== null);
+}

package/vendor/quickjs/sandbox/expose/pendingHostPromises.d.ts

@@ -0,0 +1,6 @@
+import type { QuickJSAsyncContext, QuickJSContext, QuickJSDeferredPromise } from 'quickjs-emscripten-core';
+type ContextType = QuickJSContext | QuickJSAsyncContext;
+export declare const registerPendingHostPromise: (ctx: ContextType, promise: QuickJSDeferredPromise) => void;
+export declare const unregisterPendingHostPromise: (ctx: ContextType, promise: QuickJSDeferredPromise) => void;
+export declare const rejectAndFlushPendingHostPromises: (ctx: ContextType, message?: string, maxWaitMs?: number) => Promise<void>;
+export {};

package/vendor/quickjs/sandbox/expose/pendingHostPromises.js

@@ -0,0 +1,40 @@
+const pendingHostPromises = new WeakMap();
+export const registerPendingHostPromise = (ctx, promise) => {
+    const current = pendingHostPromises.get(ctx);
+    if (current) {
+        current.add(promise);
+        return;
+    }
+    pendingHostPromises.set(ctx, new Set([promise]));
+};
+export const unregisterPendingHostPromise = (ctx, promise) => {
+    const current = pendingHostPromises.get(ctx);
+    if (!current) {
+        return;
+    }
+    current.delete(promise);
+    if (current.size === 0) {
+        pendingHostPromises.delete(ctx);
+    }
+};
+export const rejectAndFlushPendingHostPromises = async (ctx, message = 'Sandbox timed out before async host call finished.', maxWaitMs = 100) => {
+    const current = pendingHostPromises.get(ctx);
+    if (!current || current.size === 0) {
+        return;
+    }
+    const pending = Array.from(current);
+    for (const deferred of pending) {
+        try {
+            const errHandle = ctx.newError(new Error(message));
+            deferred.reject(errHandle);
+            errHandle.dispose();
+        }
+        catch {
+            // ignore rejected/dead deferred or context teardown race
+        }
+    }
+    await Promise.race([
+        Promise.allSettled(pending.map(p => p.settled)),
+        new Promise(resolve => setTimeout(resolve, maxWaitMs)),
+    ]);
+};

package/vendor/quickjs/sandbox/getMaxIntervalAmount.d.ts

@@ -0,0 +1,8 @@
+import type { SandboxBaseOptions } from '../index.js';
+/**
+ * Determines the maximum allowed amount of concurrent intervals.
+ *
+ * @param runtimeOptions - The sandbox options containing `maxIntervalCount`.
+ * @returns The configured `maxIntervalCount` or `10` if none is set.
+ */
+export declare const getMaxIntervalAmount: (runtimeOptions: SandboxBaseOptions) => number;

package/vendor/quickjs/sandbox/getMaxIntervalAmount.js

@@ -0,0 +1,12 @@
+/**
+ * Determines the maximum allowed amount of concurrent intervals.
+ *
+ * @param runtimeOptions - The sandbox options containing `maxIntervalCount`.
+ * @returns The configured `maxIntervalCount` or `10` if none is set.
+ */
+export const getMaxIntervalAmount = (runtimeOptions) => {
+    if (!runtimeOptions.maxIntervalCount || runtimeOptions.maxIntervalCount <= 0) {
+        return 10;
+    }
+    return runtimeOptions.maxIntervalCount;
+};

package/vendor/quickjs/sandbox/getMaxTimeoutAmount.d.ts

@@ -0,0 +1,8 @@
+import type { SandboxBaseOptions } from '../index.js';
+/**
+ * Determines the maximum allowed amount of concurrent timeouts.
+ *
+ * @param runtimeOptions - The sandbox options containing `maxTimeoutCount`.
+ * @returns The configured `maxTimeoutCount` or `10` if none is set.
+ */
+export declare const getMaxTimeoutAmount: (runtimeOptions: SandboxBaseOptions) => number;

package/vendor/quickjs/sandbox/getMaxTimeoutAmount.js

@@ -0,0 +1,12 @@
+/**
+ * Determines the maximum allowed amount of concurrent timeouts.
+ *
+ * @param runtimeOptions - The sandbox options containing `maxTimeoutCount`.
+ * @returns The configured `maxTimeoutCount` or `10` if none is set.
+ */
+export const getMaxTimeoutAmount = (runtimeOptions) => {
+    if (!runtimeOptions.maxTimeoutCount || runtimeOptions.maxTimeoutCount <= 0) {
+        return 10;
+    }
+    return runtimeOptions.maxTimeoutCount;
+};

package/vendor/quickjs/sandbox/handleEvalError.d.ts

@@ -0,0 +1,2 @@
+import type { ErrorResponse } from '../types/ErrorResponse.js';
+export declare const handleEvalError: (err: unknown) => ErrorResponse;

package/vendor/quickjs/sandbox/handleEvalError.js

@@ -0,0 +1,21 @@
+export const handleEvalError = (err) => {
+    return err instanceof Error
+        ? {
+            ok: false,
+            error: {
+                name: err.name,
+                message: err.message,
+                stack: err.stack,
+            },
+            isSyntaxError: err.name === 'SyntaxError',
+        }
+        : {
+            ok: false,
+            error: {
+                name: 'UnknownError',
+                message: typeof err === 'string' ? err : 'An unknown error occurred.',
+                stack: '',
+            },
+            isSyntaxError: false,
+        };
+};

package/vendor/quickjs/sandbox/handleToNative/handleToNative.d.ts

@@ -0,0 +1,9 @@
+import { type QuickJSAsyncContext, type QuickJSContext, type QuickJSHandle, Scope } from 'quickjs-emscripten-core';
+/**
+ * Serialize data from guest to host
+ *
+ * @param ctx The sandbox context
+ * @param handle The QuickJS handle to serialize
+ * @returns
+ */
+export declare const handleToNative: (ctx: QuickJSContext | QuickJSAsyncContext, handle: QuickJSHandle, rootScope?: Scope) => any;