@secure-exec/nodejs 0.2.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 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,75 @@
+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;
+/**
+ * Polyfill of Node.js `Module` class for sandbox compatibility. Provides
+ * `_compile`, `_resolveFilename`, `_load`, `_extensions`, and `_cache` statics
+ * that npm tooling (promzard, resolve, etc.) relies on.
+ */
+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,325 @@
+import { exposeCustomGlobal, exposeMutableRuntimeStateGlobal, } from "@secure-exec/core/internal/shared/global-exposure";
+// Module polyfill for the sandbox
+// Provides module.createRequire and other module utilities for npm compatibility
+// Seed the mutable CommonJS loader state before requireSetup runs.
+const initialModuleCache = {};
+const initialPendingModules = {};
+const initialCurrentModule = {
+    id: "/<entry>.js",
+    filename: "/<entry>.js",
+    dirname: "/",
+    exports: {},
+    loaded: false,
+};
+exposeMutableRuntimeStateGlobal("_moduleCache", initialModuleCache);
+exposeMutableRuntimeStateGlobal("_pendingModules", initialPendingModules);
+exposeMutableRuntimeStateGlobal("_currentModule", initialCurrentModule);
+// 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 _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",
+        "_http_common",
+        "https",
+        "dns",
+        "dgram",
+        "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;
+}
+/**
+ * Polyfill of Node.js `Module` class for sandbox compatibility. Provides
+ * `_compile`, `_resolveFilename`, `_load`, `_extensions`, and `_cache` statics
+ * that npm tooling (promzard, resolve, etc.) relies on.
+ */
+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;