secure-exec 0.0.1 → 0.1.0-rc.1

package/dist/bridge/child-process.js

@@ -0,0 +1,523 @@
+// @ts-nocheck
+// child_process module polyfill for isolated-vm
+// Provides Node.js child_process module emulation that bridges to host
+//
+// Uses the active handles mechanism to keep the sandbox alive while child
+// processes are running. See: docs-internal/node/ACTIVE_HANDLES.md
+import { exposeCustomGlobal } from "../shared/global-exposure.js";
+// Active children registry - maps session ID to ChildProcess
+const activeChildren = new Map();
+// Global dispatcher - host calls this when data arrives
+const childProcessDispatch = (sessionId, type, data) => {
+    const child = activeChildren.get(sessionId);
+    if (!child)
+        return;
+    if (type === "stdout") {
+        const buf = typeof Buffer !== "undefined" ? Buffer.from(data) : data;
+        child.stdout.emit("data", buf);
+    }
+    else if (type === "stderr") {
+        const buf = typeof Buffer !== "undefined" ? Buffer.from(data) : data;
+        child.stderr.emit("data", buf);
+    }
+    else if (type === "exit") {
+        child.exitCode = data;
+        child.stdout.emit("end");
+        child.stderr.emit("end");
+        child.emit("close", data, null);
+        child.emit("exit", data, null);
+        activeChildren.delete(sessionId);
+        // Unregister handle - allows sandbox to exit if no other handles remain
+        // See: docs-internal/node/ACTIVE_HANDLES.md
+        if (typeof _unregisterHandle === "function") {
+            _unregisterHandle(`child:${sessionId}`);
+        }
+    }
+};
+exposeCustomGlobal("_childProcessDispatch", childProcessDispatch);
+// ChildProcess class - simplified interface, not strictly satisfying nodeChildProcess.ChildProcess
+class ChildProcess {
+    _listeners = {};
+    _onceListeners = {};
+    pid = Math.floor(Math.random() * 10000) + 1000;
+    killed = false;
+    exitCode = null;
+    signalCode = null;
+    connected = false;
+    spawnfile = "";
+    spawnargs = [];
+    stdin;
+    stdout;
+    stderr;
+    stdio;
+    constructor() {
+        // Create stdin stream stub
+        this.stdin = {
+            writable: true,
+            _buffer: [],
+            write(data) {
+                this._buffer.push(data);
+                return true;
+            },
+            end() {
+                this.writable = false;
+            },
+            on() {
+                return this;
+            },
+            once() {
+                return this;
+            },
+            emit() {
+                return false;
+            },
+        };
+        // Create stdout stream stub
+        this.stdout = {
+            readable: true,
+            _data: "",
+            _listeners: {},
+            _onceListeners: {},
+            on(event, listener) {
+                if (!this._listeners[event])
+                    this._listeners[event] = [];
+                this._listeners[event].push(listener);
+                return this;
+            },
+            once(event, listener) {
+                if (!this._onceListeners[event])
+                    this._onceListeners[event] = [];
+                this._onceListeners[event].push(listener);
+                return this;
+            },
+            emit(event, ...args) {
+                if (this._listeners[event]) {
+                    this._listeners[event].forEach((fn) => fn(...args));
+                }
+                if (this._onceListeners[event]) {
+                    this._onceListeners[event].forEach((fn) => fn(...args));
+                    this._onceListeners[event] = [];
+                }
+                return true;
+            },
+            read() {
+                return null;
+            },
+            setEncoding() {
+                return this;
+            },
+            pipe(dest) {
+                return dest;
+            },
+        };
+        // Create stderr stream stub
+        this.stderr = {
+            readable: true,
+            _data: "",
+            _listeners: {},
+            _onceListeners: {},
+            on(event, listener) {
+                if (!this._listeners[event])
+                    this._listeners[event] = [];
+                this._listeners[event].push(listener);
+                return this;
+            },
+            once(event, listener) {
+                if (!this._onceListeners[event])
+                    this._onceListeners[event] = [];
+                this._onceListeners[event].push(listener);
+                return this;
+            },
+            emit(event, ...args) {
+                if (this._listeners[event]) {
+                    this._listeners[event].forEach((fn) => fn(...args));
+                }
+                if (this._onceListeners[event]) {
+                    this._onceListeners[event].forEach((fn) => fn(...args));
+                    this._onceListeners[event] = [];
+                }
+                return true;
+            },
+            read() {
+                return null;
+            },
+            setEncoding() {
+                return this;
+            },
+            pipe(dest) {
+                return dest;
+            },
+        };
+        this.stdio = [this.stdin, this.stdout, this.stderr];
+    }
+    on(event, listener) {
+        if (!this._listeners[event])
+            this._listeners[event] = [];
+        this._listeners[event].push(listener);
+        return this;
+    }
+    once(event, listener) {
+        if (!this._onceListeners[event])
+            this._onceListeners[event] = [];
+        this._onceListeners[event].push(listener);
+        return this;
+    }
+    off(event, listener) {
+        if (this._listeners[event]) {
+            const idx = this._listeners[event].indexOf(listener);
+            if (idx !== -1)
+                this._listeners[event].splice(idx, 1);
+        }
+        return this;
+    }
+    removeListener(event, listener) {
+        return this.off(event, listener);
+    }
+    emit(event, ...args) {
+        let handled = false;
+        if (this._listeners[event]) {
+            this._listeners[event].forEach((fn) => {
+                fn(...args);
+                handled = true;
+            });
+        }
+        if (this._onceListeners[event]) {
+            this._onceListeners[event].forEach((fn) => {
+                fn(...args);
+                handled = true;
+            });
+            this._onceListeners[event] = [];
+        }
+        return handled;
+    }
+    kill(_signal) {
+        this.killed = true;
+        this.signalCode = (typeof _signal === "string" ? _signal : "SIGTERM");
+        return true;
+    }
+    ref() {
+        return this;
+    }
+    unref() {
+        return this;
+    }
+    disconnect() {
+        this.connected = false;
+    }
+    _complete(stdout, stderr, code) {
+        this.exitCode = code;
+        // Emit data events for stdout/stderr as single chunks
+        if (stdout) {
+            const buf = typeof Buffer !== "undefined" ? Buffer.from(stdout) : stdout;
+            this.stdout.emit("data", buf);
+        }
+        if (stderr) {
+            const buf = typeof Buffer !== "undefined" ? Buffer.from(stderr) : stderr;
+            this.stderr.emit("data", buf);
+        }
+        // Emit end events
+        this.stdout.emit("end");
+        this.stderr.emit("end");
+        // Emit close event (code, signal)
+        this.emit("close", code, this.signalCode);
+        // Emit exit event
+        this.emit("exit", code, this.signalCode);
+    }
+}
+// exec - execute shell command, callback when done
+// Uses spawn("bash", ["-c", command]) internally
+// NOTE: WASIX bash returns incorrect exit codes (45 instead of 0) for -c flag,
+// so error will be set even on successful commands. The stdout/stderr are correct.
+function exec(command, options, callback) {
+    if (typeof options === "function") {
+        callback = options;
+        options = {};
+    }
+    // Use spawn with shell to execute the command
+    const child = spawn("bash", ["-c", command], { shell: false });
+    child.spawnargs = ["bash", "-c", command];
+    child.spawnfile = "bash";
+    // Collect output and invoke callback
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+        stdout += String(data);
+    });
+    child.stderr.on("data", (data) => {
+        stderr += String(data);
+    });
+    child.on("close", (code) => {
+        if (callback) {
+            if (code !== 0) {
+                const err = new Error("Command failed: " + command);
+                err.code = code;
+                err.killed = false;
+                err.signal = null;
+                err.cmd = command;
+                err.stdout = stdout;
+                err.stderr = stderr;
+                callback(err, stdout, stderr);
+            }
+            else {
+                callback(null, stdout, stderr);
+            }
+        }
+    });
+    child.on("error", (err) => {
+        if (callback) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            error.code = 1;
+            error.stdout = stdout;
+            error.stderr = stderr;
+            callback(error, stdout, stderr);
+        }
+    });
+    return child;
+}
+// execSync - synchronous shell execution
+// Uses spawnSync("bash", ["-c", command]) internally
+function execSync(command, options) {
+    const opts = options || {};
+    if (typeof _childProcessSpawnSync === "undefined") {
+        throw new Error("child_process.execSync requires CommandExecutor to be configured");
+    }
+    // Use synchronous bridge call - result is JSON string
+    const jsonResult = _childProcessSpawnSync.applySyncPromise(undefined, [
+        "bash",
+        JSON.stringify(["-c", command]),
+        JSON.stringify({ cwd: opts.cwd, env: opts.env }),
+    ]);
+    const result = JSON.parse(jsonResult);
+    if (result.code !== 0) {
+        const err = new Error("Command failed: " + command);
+        err.status = result.code;
+        err.stdout = result.stdout;
+        err.stderr = result.stderr;
+        err.output = [null, result.stdout, result.stderr];
+        throw err;
+    }
+    if (opts.encoding === "buffer" || !opts.encoding) {
+        return typeof Buffer !== "undefined" ? Buffer.from(result.stdout) : result.stdout;
+    }
+    return result.stdout;
+}
+// spawn - spawn a command with streaming
+function spawn(command, args, options) {
+    let argsArray = [];
+    let opts = {};
+    if (!Array.isArray(args)) {
+        opts = args || {};
+    }
+    else {
+        argsArray = args;
+        opts = options || {};
+    }
+    const child = new ChildProcess();
+    child.spawnfile = command;
+    child.spawnargs = [command, ...argsArray];
+    // Check if streaming mode is available
+    if (typeof _childProcessSpawnStart !== "undefined") {
+        // Use process.cwd() as default if no cwd specified
+        // This ensures process.chdir() changes are reflected in child processes
+        const effectiveCwd = opts.cwd ?? (typeof process !== "undefined" ? process.cwd() : "/");
+        // Streaming mode - spawn immediately
+        const sessionId = _childProcessSpawnStart.applySync(undefined, [
+            command,
+            JSON.stringify(argsArray),
+            JSON.stringify({ cwd: effectiveCwd, env: opts.env }),
+        ]);
+        activeChildren.set(sessionId, child);
+        // Register handle to keep sandbox alive until child exits
+        // See: docs-internal/node/ACTIVE_HANDLES.md
+        if (typeof _registerHandle === "function") {
+            _registerHandle(`child:${sessionId}`, `child_process: ${command} ${argsArray.join(" ")}`);
+        }
+        // Override stdin methods for streaming
+        child.stdin.write = (data) => {
+            if (typeof _childProcessStdinWrite === "undefined")
+                return false;
+            const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+            _childProcessStdinWrite.applySync(undefined, [sessionId, bytes]);
+            return true;
+        };
+        child.stdin.end = () => {
+            if (typeof _childProcessStdinClose !== "undefined") {
+                _childProcessStdinClose.applySync(undefined, [sessionId]);
+            }
+            child.stdin.writable = false;
+        };
+        // Override kill method
+        child.kill = (signal) => {
+            if (typeof _childProcessKill === "undefined")
+                return false;
+            const sig = signal === "SIGKILL" || signal === 9
+                ? 9
+                : signal === "SIGINT" || signal === 2
+                    ? 2
+                    : 15;
+            _childProcessKill.applySync(undefined, [sessionId, sig]);
+            child.killed = true;
+            child.signalCode = (typeof signal === "string" ? signal : "SIGTERM");
+            return true;
+        };
+        return child;
+    }
+    // Fallback: no CommandExecutor available
+    const err = new Error("child_process.spawn requires CommandExecutor to be configured");
+    // Emit error asynchronously to match Node.js behavior
+    setTimeout(() => {
+        child.emit("error", err);
+        child._complete("", err.message, 1);
+    }, 0);
+    return child;
+}
+// spawnSync - synchronous spawn
+function spawnSync(command, args, options) {
+    let argsArray = [];
+    let opts = {};
+    if (!Array.isArray(args)) {
+        opts = args || {};
+    }
+    else {
+        argsArray = args;
+        opts = options || {};
+    }
+    if (typeof _childProcessSpawnSync === "undefined") {
+        return {
+            pid: 0,
+            output: [null, "", "child_process.spawnSync requires CommandExecutor to be configured"],
+            stdout: "",
+            stderr: "child_process.spawnSync requires CommandExecutor to be configured",
+            status: 1,
+            signal: null,
+            error: new Error("child_process.spawnSync requires CommandExecutor to be configured"),
+        };
+    }
+    try {
+        // Use process.cwd() as default if no cwd specified
+        // This ensures process.chdir() changes are reflected in child processes
+        const effectiveCwd = opts.cwd ?? (typeof process !== "undefined" ? process.cwd() : "/");
+        // Args passed as JSON string for transferability
+        const jsonResult = _childProcessSpawnSync.applySyncPromise(undefined, [
+            command,
+            JSON.stringify(argsArray),
+            JSON.stringify({ cwd: effectiveCwd, env: opts.env }),
+        ]);
+        const result = JSON.parse(jsonResult);
+        const stdoutBuf = typeof Buffer !== "undefined" ? Buffer.from(result.stdout) : result.stdout;
+        const stderrBuf = typeof Buffer !== "undefined" ? Buffer.from(result.stderr) : result.stderr;
+        return {
+            pid: Math.floor(Math.random() * 10000) + 1000,
+            output: [null, stdoutBuf, stderrBuf],
+            stdout: stdoutBuf,
+            stderr: stderrBuf,
+            status: result.code,
+            signal: null,
+            error: undefined,
+        };
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        const stderrBuf = typeof Buffer !== "undefined" ? Buffer.from(errMsg) : errMsg;
+        return {
+            pid: 0,
+            output: [null, "", stderrBuf],
+            stdout: typeof Buffer !== "undefined" ? Buffer.from("") : "",
+            stderr: stderrBuf,
+            status: 1,
+            signal: null,
+            error: err instanceof Error ? err : new Error(String(err)),
+        };
+    }
+}
+// execFile - execute a file directly
+function execFile(file, args, options, callback) {
+    let argsArray = [];
+    let opts = {};
+    let cb;
+    if (typeof args === "function") {
+        cb = args;
+    }
+    else if (typeof options === "function") {
+        argsArray = args.slice();
+        cb = options;
+    }
+    else {
+        argsArray = Array.isArray(args) ? args : [];
+        opts = options || {};
+        cb = callback;
+    }
+    // execFile is like spawn but with callback
+    const child = spawn(file, argsArray, opts);
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+        stdout += String(data);
+    });
+    child.stderr.on("data", (data) => {
+        stderr += String(data);
+    });
+    child.on("close", (code) => {
+        if (cb) {
+            if (code !== 0) {
+                const err = new Error("Command failed: " + file);
+                err.code = code;
+                err.stdout = stdout;
+                err.stderr = stderr;
+                cb(err, stdout, stderr);
+            }
+            else {
+                cb(null, stdout, stderr);
+            }
+        }
+    });
+    child.on("error", (err) => {
+        if (cb) {
+            cb(err, stdout, stderr);
+        }
+    });
+    return child;
+}
+// execFileSync
+function execFileSync(file, args, options) {
+    let argsArray = [];
+    let opts = {};
+    if (!Array.isArray(args)) {
+        opts = args || {};
+    }
+    else {
+        argsArray = args;
+        opts = options || {};
+    }
+    const result = spawnSync(file, argsArray, opts);
+    if (result.status !== 0) {
+        const err = new Error("Command failed: " + file);
+        err.status = result.status ?? undefined;
+        err.stdout = String(result.stdout);
+        err.stderr = String(result.stderr);
+        throw err;
+    }
+    if (opts.encoding === "buffer" || !opts.encoding) {
+        return result.stdout;
+    }
+    return typeof result.stdout === "string" ? result.stdout : result.stdout.toString(opts.encoding);
+}
+// fork - intentionally not implemented (IPC between processes not supported in sandbox)
+function fork(_modulePath, _args, _options) {
+    throw new Error("child_process.fork is not supported in sandbox");
+}
+// Create the child_process module
+const childProcess = {
+    ChildProcess,
+    exec,
+    execSync,
+    spawn,
+    spawnSync,
+    execFile,
+    execFileSync,
+    fork,
+};
+// Expose to global for require() to use
+exposeCustomGlobal("_childProcessModule", childProcess);
+export { ChildProcess, exec, execSync, spawn, spawnSync, execFile, execFileSync, fork };
+export default childProcess;