secure-exec 0.0.1 → 0.1.0-rc.1

package/dist/bridge/index.d.ts

@@ -0,0 +1,10 @@
+import "./polyfills.js";
+import { _registerHandle, _unregisterHandle, _waitForActiveHandles, _getActiveHandles } from "./active-handles.js";
+import fs from "./fs.js";
+import os from "./os.js";
+import * as childProcess from "./child-process.js";
+import * as network from "./network.js";
+import process, { setupGlobals, setTimeout, clearTimeout, setInterval, clearInterval, setImmediate, clearImmediate, URL, URLSearchParams, TextEncoder, TextDecoder, Buffer, cryptoPolyfill, ProcessExitError } from "./process.js";
+import moduleModule, { createRequire, Module, SourceMap } from "./module.js";
+export { fs, os, childProcess, process, moduleModule as module, network, setupGlobals, setTimeout, clearTimeout, setInterval, clearInterval, setImmediate, clearImmediate, URL, URLSearchParams, TextEncoder, TextDecoder, Buffer, cryptoPolyfill, ProcessExitError, createRequire, Module, SourceMap, _registerHandle, _unregisterHandle, _waitForActiveHandles, _getActiveHandles, };
+export default fs;

package/dist/bridge/index.js

@@ -0,0 +1,41 @@
+// Bridge module entry point
+// This file is compiled to a single JS bundle that gets injected into the isolate
+//
+// Each module provides polyfills for Node.js built-in modules that need to
+// communicate with the host environment via isolated-vm bridge functions.
+// IMPORTANT: Import polyfills FIRST before any other modules!
+// Some packages (like whatwg-url) use TextEncoder/TextDecoder at module load time.
+// This import installs them on globalThis before other imports execute.
+import "./polyfills.js";
+// Active handles mechanism - must be imported early so other modules can use it.
+// See: docs-internal/node/ACTIVE_HANDLES.md
+import { _registerHandle, _unregisterHandle, _waitForActiveHandles, _getActiveHandles, } from "./active-handles.js";
+// File system module
+import fs from "./fs.js";
+// Operating system module
+import os from "./os.js";
+// Child process module
+import * as childProcess from "./child-process.js";
+// Network modules (fetch, dns, http, https)
+import * as network from "./network.js";
+// Process and global polyfills
+import process, { setupGlobals, setTimeout, clearTimeout, setInterval, clearInterval, setImmediate, clearImmediate, URL, URLSearchParams, TextEncoder, TextDecoder, Buffer, cryptoPolyfill, ProcessExitError, } from "./process.js";
+// Module system (createRequire, Module class)
+import moduleModule, { createRequire, Module, SourceMap } from "./module.js";
+// Export all modules
+export { 
+// Core modules
+fs, os, childProcess, process, moduleModule as module, 
+// Network
+network, 
+// Process globals
+setupGlobals, setTimeout, clearTimeout, setInterval, clearInterval, setImmediate, clearImmediate, URL, URLSearchParams, TextEncoder, TextDecoder, Buffer, cryptoPolyfill, ProcessExitError, 
+// Module utilities
+createRequire, Module, SourceMap, 
+// Active handles (see docs-internal/node/ACTIVE_HANDLES.md)
+_registerHandle, _unregisterHandle, _waitForActiveHandles, _getActiveHandles, };
+// Default export is fs for backward compatibility
+export default fs;
+// Auto-setup globals when bridge loads
+// This installs process, timers, URL, Buffer, crypto, etc. on globalThis
+setupGlobals();

package/dist/bridge/module.d.ts

@@ -0,0 +1,73 @@
+interface RequireFunction {
+    (request: string): unknown;
+    resolve: RequireResolve;
+    cache: Record<string, {
+        exports: unknown;
+    }>;
+    main: Module | undefined;
+    extensions: Record<string, (module: Module, filename: string) => void>;
+}
+interface RequireResolve {
+    (request: string, options?: {
+        paths?: string[];
+    }): string;
+    paths: (request: string) => string[] | null;
+}
+/**
+ * Create a require function that resolves relative to the given filename.
+ * This mimics Node.js's module.createRequire(filename).
+ */
+export declare function createRequire(filename: string | URL): RequireFunction;
+/**
+ * Module class constructor (for compatibility with promzard and similar)
+ */
+export declare class Module {
+    id: string;
+    path: string;
+    exports: unknown;
+    filename: string;
+    loaded: boolean;
+    children: Module[];
+    paths: string[];
+    parent: Module | null | undefined;
+    isPreloading: boolean;
+    constructor(id: string, parent?: Module | null);
+    require(request: string): unknown;
+    _compile(content: string, filename: string): unknown;
+    static _extensions: Record<string, (module: Module, filename: string) => void>;
+    static _cache: Record<string, {
+        exports: unknown;
+    }>;
+    static _resolveFilename(request: string, parent: Module | null | undefined, _isMain?: boolean, _options?: unknown): string;
+    static wrap(content: string): string;
+    static builtinModules: string[];
+    static isBuiltin(moduleName: string): boolean;
+    static createRequire: typeof createRequire;
+    static syncBuiltinESMExports(): void;
+    static findSourceMap(_path: string): undefined;
+    static _nodeModulePaths(from: string): string[];
+    static _load(request: string, parent: Module | null | undefined, _isMain?: boolean): unknown;
+    static runMain(): void;
+}
+export declare class SourceMap {
+    constructor(_payload: unknown);
+    get payload(): never;
+    set payload(_value: unknown);
+    findEntry(_line: number, _column: number): never;
+}
+declare const moduleModule: {
+    Module: typeof Module;
+    createRequire: typeof createRequire;
+    _extensions: Record<string, (module: Module, filename: string) => void>;
+    _cache: Record<string, {
+        exports: unknown;
+    }>;
+    builtinModules: string[];
+    isBuiltin: typeof Module.isBuiltin;
+    _resolveFilename: typeof Module._resolveFilename;
+    wrap: typeof Module.wrap;
+    syncBuiltinESMExports: typeof Module.syncBuiltinESMExports;
+    findSourceMap: typeof Module.findSourceMap;
+    SourceMap: typeof SourceMap;
+};
+export default moduleModule;

package/dist/bridge/module.js

@@ -0,0 +1,329 @@
+import { exposeCustomGlobal } from "../shared/global-exposure.js";
+// Path utilities for module resolution
+function _pathDirname(p) {
+    const lastSlash = p.lastIndexOf("/");
+    if (lastSlash === -1)
+        return ".";
+    if (lastSlash === 0)
+        return "/";
+    return p.slice(0, lastSlash);
+}
+function _pathResolve(...segments) {
+    let resolvedPath = "";
+    let resolvedAbsolute = false;
+    for (let i = segments.length - 1; i >= 0 && !resolvedAbsolute; i--) {
+        const segment = segments[i];
+        if (!segment)
+            continue;
+        resolvedPath = segment + "/" + resolvedPath;
+        resolvedAbsolute = segment.charAt(0) === "/";
+    }
+    // Normalize the path
+    const parts = resolvedPath.split("/").filter(Boolean);
+    const result = [];
+    for (const part of parts) {
+        if (part === "..") {
+            result.pop();
+        }
+        else if (part !== ".") {
+            result.push(part);
+        }
+    }
+    return (resolvedAbsolute ? "/" : "") + result.join("/") || ".";
+}
+function _parseFileUrl(url) {
+    // Handle file:// URLs
+    if (url.startsWith("file://")) {
+        // Remove file:// prefix
+        let path = url.slice(7);
+        // Handle file:///path on Unix (3 slashes = absolute path)
+        if (path.startsWith("/")) {
+            return path;
+        }
+        // Handle file://host/path (rare, treat host as empty)
+        return "/" + path;
+    }
+    return url;
+}
+/**
+ * Create a require function that resolves relative to the given filename.
+ * This mimics Node.js's module.createRequire(filename).
+ */
+export function createRequire(filename) {
+    if (typeof filename !== "string" && !(filename instanceof URL)) {
+        throw new TypeError("filename must be a string or URL");
+    }
+    // Parse file:// URLs
+    const filepath = _parseFileUrl(String(filename));
+    const dirname = _pathDirname(filepath);
+    const builtins = [
+        "fs",
+        "path",
+        "os",
+        "events",
+        "util",
+        "http",
+        "https",
+        "dns",
+        "child_process",
+        "stream",
+        "buffer",
+        "url",
+        "querystring",
+        "crypto",
+        "zlib",
+        "assert",
+        "tty",
+        "net",
+        "tls",
+    ];
+    // Create resolve.paths function
+    const resolvePaths = function (request) {
+        // For built-in modules, return null
+        if (builtins.includes(request) || request.startsWith("node:")) {
+            return null;
+        }
+        // For relative paths, return array starting from dirname
+        if (request.startsWith("./") ||
+            request.startsWith("../") ||
+            request.startsWith("/")) {
+            return [dirname];
+        }
+        // For bare specifiers, return node_modules search paths
+        const paths = [];
+        let current = dirname;
+        while (current !== "/") {
+            paths.push(current + "/node_modules");
+            current = _pathDirname(current);
+        }
+        paths.push("/node_modules");
+        return paths;
+    };
+    // Create resolve function
+    const resolve = function (request, _options) {
+        const resolved = _resolveModule.applySyncPromise(undefined, [
+            request,
+            dirname,
+        ]);
+        if (resolved === null) {
+            const err = new Error("Cannot find module '" + request + "'");
+            err.code = "MODULE_NOT_FOUND";
+            throw err;
+        }
+        return resolved;
+    };
+    resolve.paths = resolvePaths;
+    // Create a require function bound to this directory
+    const requireFn = function (request) {
+        return _requireFrom(request, dirname);
+    };
+    // Add require.resolve
+    requireFn.resolve = resolve;
+    // Add require.cache reference to global module cache
+    requireFn.cache = _moduleCache;
+    // Add require.main (null for dynamically created require)
+    requireFn.main = undefined;
+    // Add require.extensions (deprecated but still used by some tools)
+    requireFn.extensions = {
+        ".js": function (_module, _filename) {
+            // This is a stub - actual loading is handled by our require implementation
+        },
+        ".json": function (_module, _filename) {
+            // JSON loading stub
+        },
+        ".node": function (_module, _filename) {
+            throw new Error(".node extensions are not supported in sandbox");
+        },
+    };
+    return requireFn;
+}
+/**
+ * Module class constructor (for compatibility with promzard and similar)
+ */
+export class Module {
+    id;
+    path;
+    exports;
+    filename;
+    loaded;
+    children;
+    paths;
+    parent;
+    isPreloading;
+    constructor(id, parent) {
+        this.id = id;
+        this.path = _pathDirname(id);
+        this.exports = {};
+        this.filename = id;
+        this.loaded = false;
+        this.children = [];
+        this.paths = [];
+        this.parent = parent;
+        this.isPreloading = false;
+        // Build module paths
+        let current = this.path;
+        while (current !== "/") {
+            this.paths.push(current + "/node_modules");
+            current = _pathDirname(current);
+        }
+        this.paths.push("/node_modules");
+    }
+    require(request) {
+        return _requireFrom(request, this.path);
+    }
+    _compile(content, filename) {
+        // Create wrapper function and execute
+        const wrapper = new Function("exports", "require", "module", "__filename", "__dirname", content);
+        const moduleRequire = (request) => _requireFrom(request, this.path);
+        moduleRequire.resolve = (request) => {
+            const resolved = _resolveModule.applySyncPromise(undefined, [
+                request,
+                this.path,
+            ]);
+            if (resolved === null) {
+                const err = new Error("Cannot find module '" + request + "'");
+                err.code = "MODULE_NOT_FOUND";
+                throw err;
+            }
+            return resolved;
+        };
+        wrapper(this.exports, moduleRequire, this, filename, this.path);
+        this.loaded = true;
+        return this.exports;
+    }
+    static _extensions = {
+        ".js": function (module, filename) {
+            const fs = _requireFrom("fs", "/");
+            const content = fs.readFileSync(filename, "utf8");
+            module._compile(content, filename);
+        },
+        ".json": function (module, filename) {
+            const fs = _requireFrom("fs", "/");
+            const content = fs.readFileSync(filename, "utf8");
+            module.exports = JSON.parse(content);
+        },
+        ".node": function () {
+            throw new Error(".node extensions are not supported in sandbox");
+        },
+    };
+    static _cache = typeof _moduleCache !== "undefined"
+        ? _moduleCache
+        : {};
+    static _resolveFilename(request, parent, _isMain, _options) {
+        const parentDir = parent && parent.path ? parent.path : "/";
+        const resolved = _resolveModule.applySyncPromise(undefined, [
+            request,
+            parentDir,
+        ]);
+        if (resolved === null) {
+            const err = new Error("Cannot find module '" + request + "'");
+            err.code = "MODULE_NOT_FOUND";
+            throw err;
+        }
+        return resolved;
+    }
+    static wrap(content) {
+        return ("(function (exports, require, module, __filename, __dirname) { " +
+            content +
+            "\n});");
+    }
+    static builtinModules = [
+        "assert",
+        "buffer",
+        "child_process",
+        "crypto",
+        "dns",
+        "events",
+        "fs",
+        "http",
+        "https",
+        "net",
+        "os",
+        "path",
+        "querystring",
+        "stream",
+        "string_decoder",
+        "timers",
+        "tls",
+        "tty",
+        "url",
+        "util",
+        "zlib",
+        "vm",
+        "module",
+    ];
+    static isBuiltin(moduleName) {
+        const name = moduleName.replace(/^node:/, "");
+        return Module.builtinModules.includes(name);
+    }
+    static createRequire = createRequire;
+    static syncBuiltinESMExports() {
+        // No-op in our environment
+    }
+    static findSourceMap(_path) {
+        return undefined;
+    }
+    static _nodeModulePaths(from) {
+        // Return array of node_modules paths from the given directory up to root
+        const paths = [];
+        let current = from;
+        while (current !== "/") {
+            paths.push(current + "/node_modules");
+            current = _pathDirname(current);
+            if (current === ".")
+                break;
+        }
+        paths.push("/node_modules");
+        return paths;
+    }
+    static _load(request, parent, _isMain) {
+        // Use our require system
+        const parentDir = parent && parent.path ? parent.path : "/";
+        return _requireFrom(request, parentDir);
+    }
+    static runMain() {
+        // No-op - we don't have a main module in this context
+    }
+}
+// SourceMap class - not implemented
+export class SourceMap {
+    constructor(_payload) {
+        throw new Error("SourceMap is not implemented in sandbox");
+    }
+    get payload() {
+        throw new Error("SourceMap is not implemented in sandbox");
+    }
+    set payload(_value) {
+        throw new Error("SourceMap is not implemented in sandbox");
+    }
+    findEntry(_line, _column) {
+        throw new Error("SourceMap is not implemented in sandbox");
+    }
+}
+// Module namespace export matching Node.js 'module' module
+// Note: We don't strictly satisfy typeof nodeModule due to complex intersection types
+const moduleModule = {
+    Module: Module,
+    createRequire: createRequire,
+    // Module._extensions (deprecated alias)
+    _extensions: Module._extensions,
+    // Module._cache reference
+    _cache: Module._cache,
+    // Built-in module list
+    builtinModules: Module.builtinModules,
+    // isBuiltin check
+    isBuiltin: Module.isBuiltin,
+    // Module._resolveFilename (internal but sometimes used)
+    _resolveFilename: Module._resolveFilename,
+    // wrap function
+    wrap: Module.wrap,
+    // syncBuiltinESMExports (stub for ESM interop)
+    syncBuiltinESMExports: Module.syncBuiltinESMExports,
+    // findSourceMap (stub)
+    findSourceMap: Module.findSourceMap,
+    // SourceMap class (stub)
+    SourceMap: SourceMap,
+};
+// Expose to global for require() to use
+exposeCustomGlobal("_moduleModule", moduleModule);
+export default moduleModule;

package/dist/bridge/network.d.ts

@@ -0,0 +1,208 @@
+import type * as nodeHttp from "http";
+interface FetchOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | null;
+    mode?: string;
+    credentials?: string;
+    cache?: string;
+    redirect?: string;
+    referrer?: string;
+    integrity?: string;
+}
+interface FetchResponse {
+    ok: boolean;
+    status: number;
+    statusText: string;
+    headers: Map<string, string>;
+    url: string;
+    redirected: boolean;
+    type: string;
+    text(): Promise<string>;
+    json(): Promise<unknown>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<never>;
+    clone(): FetchResponse;
+}
+export declare function fetch(url: string | URL, options?: FetchOptions): Promise<FetchResponse>;
+export declare class Headers {
+    private _headers;
+    constructor(init?: HeadersInit | Headers | Record<string, string> | [string, string][]);
+    get(name: string): string | null;
+    set(name: string, value: string): void;
+    has(name: string): boolean;
+    delete(name: string): void;
+    entries(): IterableIterator<[string, string]>;
+    [Symbol.iterator](): IterableIterator<[string, string]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+    forEach(callback: (value: string, key: string, parent: Headers) => void): void;
+}
+export declare class Request {
+    url: string;
+    method: string;
+    headers: Headers;
+    body: string | null;
+    mode: string;
+    credentials: string;
+    cache: string;
+    redirect: string;
+    referrer: string;
+    integrity: string;
+    constructor(input: string | Request, init?: FetchOptions);
+    clone(): Request;
+}
+export declare class Response {
+    private _body;
+    status: number;
+    statusText: string;
+    headers: Headers;
+    ok: boolean;
+    type: string;
+    url: string;
+    redirected: boolean;
+    constructor(body?: string | null, init?: {
+        status?: number;
+        statusText?: string;
+        headers?: Record<string, string>;
+    });
+    text(): Promise<string>;
+    json(): Promise<unknown>;
+    clone(): Response;
+    static error(): Response;
+    static redirect(url: string, status?: number): Response;
+}
+type DnsCallback = (err: Error | null, address?: string, family?: number) => void;
+type DnsResolveCallback = (err: Error | null, addresses?: string[]) => void;
+export declare const dns: {
+    lookup(hostname: string, options: unknown, callback?: DnsCallback): void;
+    resolve(hostname: string, rrtype: string | DnsResolveCallback, callback?: DnsResolveCallback): void;
+    resolve4(hostname: string, callback: DnsResolveCallback): void;
+    resolve6(hostname: string, callback: DnsResolveCallback): void;
+    promises: {
+        lookup(hostname: string, _options?: unknown): Promise<{
+            address: string;
+            family: number;
+        }>;
+        resolve(hostname: string, rrtype?: string): Promise<string[]>;
+    };
+};
+type EventListener = (...args: unknown[]) => void;
+export declare class IncomingMessage {
+    headers: Record<string, string>;
+    rawHeaders: string[];
+    trailers: Record<string, string>;
+    rawTrailers: string[];
+    httpVersion: string;
+    httpVersionMajor: number;
+    httpVersionMinor: number;
+    method: string | null;
+    url: string;
+    statusCode: number | undefined;
+    statusMessage: string | undefined;
+    private _body;
+    private _isBinary;
+    private _listeners;
+    complete: boolean;
+    aborted: boolean;
+    socket: null;
+    private _bodyConsumed;
+    private _ended;
+    private _flowing;
+    readable: boolean;
+    readableEnded: boolean;
+    readableFlowing: boolean | null;
+    destroyed: boolean;
+    private _encoding?;
+    constructor(response?: {
+        headers?: Record<string, string>;
+        url?: string;
+        status?: number;
+        statusText?: string;
+        body?: string;
+    });
+    on(event: string, listener: EventListener): this;
+    once(event: string, listener: EventListener): this;
+    off(event: string, listener: EventListener): this;
+    removeListener(event: string, listener: EventListener): this;
+    removeAllListeners(event?: string): this;
+    emit(event: string, ...args: unknown[]): boolean;
+    setEncoding(encoding: string): this;
+    read(_size?: number): string | Buffer | null;
+    pipe<T extends NodeJS.WritableStream>(dest: T): T;
+    pause(): this;
+    resume(): this;
+    unpipe(_dest?: NodeJS.WritableStream): this;
+    destroy(err?: Error): this;
+    [Symbol.asyncIterator](): AsyncIterator<string | Buffer>;
+}
+export declare class ClientRequest {
+    private _options;
+    private _callback?;
+    private _listeners;
+    private _body;
+    private _ended;
+    socket: null;
+    finished: boolean;
+    aborted: boolean;
+    constructor(options: nodeHttp.RequestOptions, callback?: (res: IncomingMessage) => void);
+    private _execute;
+    private _buildUrl;
+    on(event: string, listener: EventListener): this;
+    once(event: string, listener: EventListener): this;
+    off(event: string, listener: EventListener): this;
+    private _emit;
+    write(data: string): boolean;
+    end(data?: string): this;
+    abort(): void;
+    setTimeout(_timeout: number): this;
+    setNoDelay(): this;
+    setSocketKeepAlive(): this;
+    flushHeaders(): void;
+}
+export declare const http: Partial<typeof nodeHttp>;
+export declare const https: Partial<typeof nodeHttp>;
+export declare const http2: {
+    Http2ServerRequest: {
+        new (): {};
+    };
+    Http2ServerResponse: {
+        new (): {};
+    };
+    createServer(): never;
+    createSecureServer(): never;
+};
+declare const _default: {
+    fetch: typeof fetch;
+    Headers: typeof Headers;
+    Request: typeof Request;
+    Response: typeof Response;
+    dns: {
+        lookup(hostname: string, options: unknown, callback?: DnsCallback): void;
+        resolve(hostname: string, rrtype: string | DnsResolveCallback, callback?: DnsResolveCallback): void;
+        resolve4(hostname: string, callback: DnsResolveCallback): void;
+        resolve6(hostname: string, callback: DnsResolveCallback): void;
+        promises: {
+            lookup(hostname: string, _options?: unknown): Promise<{
+                address: string;
+                family: number;
+            }>;
+            resolve(hostname: string, rrtype?: string): Promise<string[]>;
+        };
+    };
+    http: Partial<typeof nodeHttp>;
+    https: Partial<typeof nodeHttp>;
+    http2: {
+        Http2ServerRequest: {
+            new (): {};
+        };
+        Http2ServerResponse: {
+            new (): {};
+        };
+        createServer(): never;
+        createSecureServer(): never;
+    };
+    IncomingMessage: typeof IncomingMessage;
+    ClientRequest: typeof ClientRequest;
+};
+export default _default;