@secure-exec/core 0.1.1-rc.2 → 0.1.1-rc.3

package/dist/bridge/child-process.js

@@ -376,8 +376,13 @@ function execSync(command, options) {
     }
     // Default maxBuffer 1MB (Node.js convention)
     const maxBuffer = opts.maxBuffer ?? 1024 * 1024;
-    // Use synchronous bridge call
-    const result = _childProcessSpawnSync("bash", JSON.stringify(["-c", command]), JSON.stringify({ cwd: opts.cwd, env: opts.env, maxBuffer }));
+    // 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, maxBuffer }),
+    ]);
+    const result = JSON.parse(jsonResult);
     if (result.maxBufferExceeded) {
         const err = new Error("stdout maxBuffer length exceeded");
         err.code = "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
@@ -418,7 +423,11 @@ function spawn(command, args, options) {
         // 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(command, JSON.stringify(argsArray), JSON.stringify({ cwd: effectiveCwd, env: opts.env }));
+        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
@@ -430,12 +439,12 @@ function spawn(command, args, options) {
             if (typeof _childProcessStdinWrite === "undefined")
                 return false;
             const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
-            _childProcessStdinWrite(sessionId, bytes);
+            _childProcessStdinWrite.applySync(undefined, [sessionId, bytes]);
             return true;
         };
         child.stdin.end = () => {
             if (typeof _childProcessStdinClose !== "undefined") {
-                _childProcessStdinClose(sessionId);
+                _childProcessStdinClose.applySync(undefined, [sessionId]);
             }
             child.stdin.writable = false;
         };
@@ -448,7 +457,7 @@ function spawn(command, args, options) {
                 : signal === "SIGINT" || signal === 2
                     ? 2
                     : 15;
-            _childProcessKill(sessionId, sig);
+            _childProcessKill.applySync(undefined, [sessionId, sig]);
             child.killed = true;
             child.signalCode = (typeof signal === "string" ? signal : "SIGTERM");
             return true;
@@ -492,8 +501,13 @@ function spawnSync(command, args, options) {
         const effectiveCwd = opts.cwd ?? (typeof process !== "undefined" ? process.cwd() : "/");
         // Pass maxBuffer through to host for enforcement
         const maxBuffer = opts.maxBuffer;
-        // Args and options passed as JSON strings for transferability
-        const result = _childProcessSpawnSync(command, JSON.stringify(argsArray), JSON.stringify({ cwd: effectiveCwd, env: opts.env, maxBuffer }));
+        // Args passed as JSON string for transferability
+        const jsonResult = _childProcessSpawnSync.applySyncPromise(undefined, [
+            command,
+            JSON.stringify(argsArray),
+            JSON.stringify({ cwd: effectiveCwd, env: opts.env, maxBuffer }),
+        ]);
+        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;
         if (result.maxBufferExceeded) {

package/dist/bridge/fs.js

@@ -919,13 +919,13 @@ const fs = {
         try {
             if (encoding) {
                 // Text mode - use text read
-                const content = _fs.readFile(pathStr);
+                const content = _fs.readFile.applySyncPromise(undefined, [pathStr]);
                 return content;
             }
             else {
-                // Binary mode - host returns raw Uint8Array via MessagePack bin
-                const binaryData = _fs.readFileBinary(pathStr);
-                return Buffer.from(binaryData);
+                // Binary mode - use binary read with base64 encoding
+                const base64Content = _fs.readFileBinary.applySyncPromise(undefined, [pathStr]);
+                return Buffer.from(base64Content, "base64");
             }
         }
         catch (err) {
@@ -952,16 +952,17 @@ const fs = {
         if (typeof data === "string") {
             // Text mode - use text write
             // Return the result so async callers (fs.promises) can await it.
-            return _fs.writeFile(pathStr, data);
+            return _fs.writeFile.applySyncPromise(undefined, [pathStr, data]);
         }
         else if (ArrayBuffer.isView(data)) {
-            // Binary mode - send raw Uint8Array via MessagePack bin
+            // Binary mode - convert to base64 and use binary write
             const uint8 = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-            return _fs.writeFileBinary(pathStr, uint8);
+            const base64 = Buffer.from(uint8).toString("base64");
+            return _fs.writeFileBinary.applySyncPromise(undefined, [pathStr, base64]);
         }
         else {
             // Fallback to text mode
-            return _fs.writeFile(pathStr, String(data));
+            return _fs.writeFile.applySyncPromise(undefined, [pathStr, String(data)]);
         }
     },
     appendFileSync(path, data, options) {
@@ -974,9 +975,9 @@ const fs = {
     readdirSync(path, options) {
         const rawPath = toPathString(path);
         const pathStr = rawPath;
-        let entries;
+        let entriesJson;
         try {
-            entries = _fs.readDir(pathStr);
+            entriesJson = _fs.readDir.applySyncPromise(undefined, [pathStr]);
         }
         catch (err) {
             // Convert "entry not found" and similar errors to proper ENOENT
@@ -986,6 +987,7 @@ const fs = {
             }
             throw err;
         }
+        const entries = JSON.parse(entriesJson);
         if (options?.withFileTypes) {
             return entries.map((e) => new Dirent(e.name, e.isDirectory, rawPath));
         }
@@ -995,12 +997,12 @@ const fs = {
         const rawPath = toPathString(path);
         const pathStr = rawPath;
         const recursive = typeof options === "object" ? options?.recursive ?? false : false;
-        _fs.mkdir(pathStr, recursive);
+        _fs.mkdir.applySyncPromise(undefined, [pathStr, recursive]);
         return recursive ? rawPath : undefined;
     },
     rmdirSync(path, _options) {
         const pathStr = toPathString(path);
-        _fs.rmdir(pathStr);
+        _fs.rmdir.applySyncPromise(undefined, [pathStr]);
     },
     rmSync(path, options) {
         const pathStr = toPathString(path);
@@ -1040,14 +1042,14 @@ const fs = {
     },
     existsSync(path) {
         const pathStr = toPathString(path);
-        return _fs.exists(pathStr);
+        return _fs.exists.applySyncPromise(undefined, [pathStr]);
     },
     statSync(path, _options) {
         const rawPath = toPathString(path);
         const pathStr = rawPath;
-        let stat;
+        let statJson;
         try {
-            stat = _fs.stat(pathStr);
+            statJson = _fs.stat.applySyncPromise(undefined, [pathStr]);
         }
         catch (err) {
             // Convert various "not found" errors to proper ENOENT
@@ -1060,21 +1062,23 @@ const fs = {
             }
             throw err;
         }
+        const stat = JSON.parse(statJson);
         return new Stats(stat);
     },
     lstatSync(path, _options) {
         const pathStr = toPathString(path);
-        const stat = bridgeCall(() => _fs.lstat(pathStr), "lstat", pathStr);
+        const statJson = bridgeCall(() => _fs.lstat.applySyncPromise(undefined, [pathStr]), "lstat", pathStr);
+        const stat = JSON.parse(statJson);
         return new Stats(stat);
     },
     unlinkSync(path) {
         const pathStr = toPathString(path);
-        _fs.unlink(pathStr);
+        _fs.unlink.applySyncPromise(undefined, [pathStr]);
     },
     renameSync(oldPath, newPath) {
         const oldPathStr = toPathString(oldPath);
         const newPathStr = toPathString(newPath);
-        _fs.rename(oldPathStr, newPathStr);
+        _fs.rename.applySyncPromise(undefined, [oldPathStr, newPathStr]);
     },
     copyFileSync(src, dest, _mode) {
         // readFileSync and writeFileSync already normalize paths
@@ -1336,35 +1340,35 @@ const fs = {
     chmodSync(path, mode) {
         const pathStr = toPathString(path);
         const modeNum = typeof mode === "string" ? parseInt(mode, 8) : mode;
-        bridgeCall(() => _fs.chmod(pathStr, modeNum), "chmod", pathStr);
+        bridgeCall(() => _fs.chmod.applySyncPromise(undefined, [pathStr, modeNum]), "chmod", pathStr);
     },
     chownSync(path, uid, gid) {
         const pathStr = toPathString(path);
-        bridgeCall(() => _fs.chown(pathStr, uid, gid), "chown", pathStr);
+        bridgeCall(() => _fs.chown.applySyncPromise(undefined, [pathStr, uid, gid]), "chown", pathStr);
     },
     linkSync(existingPath, newPath) {
         const existingStr = toPathString(existingPath);
         const newStr = toPathString(newPath);
-        bridgeCall(() => _fs.link(existingStr, newStr), "link", newStr);
+        bridgeCall(() => _fs.link.applySyncPromise(undefined, [existingStr, newStr]), "link", newStr);
     },
     symlinkSync(target, path, _type) {
         const targetStr = toPathString(target);
         const pathStr = toPathString(path);
-        bridgeCall(() => _fs.symlink(targetStr, pathStr), "symlink", pathStr);
+        bridgeCall(() => _fs.symlink.applySyncPromise(undefined, [targetStr, pathStr]), "symlink", pathStr);
     },
     readlinkSync(path, _options) {
         const pathStr = toPathString(path);
-        return bridgeCall(() => _fs.readlink(pathStr), "readlink", pathStr);
+        return bridgeCall(() => _fs.readlink.applySyncPromise(undefined, [pathStr]), "readlink", pathStr);
     },
     truncateSync(path, len) {
         const pathStr = toPathString(path);
-        bridgeCall(() => _fs.truncate(pathStr, len ?? 0), "truncate", pathStr);
+        bridgeCall(() => _fs.truncate.applySyncPromise(undefined, [pathStr, len ?? 0]), "truncate", pathStr);
     },
     utimesSync(path, atime, mtime) {
         const pathStr = toPathString(path);
         const atimeNum = typeof atime === "number" ? atime : new Date(atime).getTime() / 1000;
         const mtimeNum = typeof mtime === "number" ? mtime : new Date(mtime).getTime() / 1000;
-        bridgeCall(() => _fs.utimes(pathStr, atimeNum, mtimeNum), "utimes", pathStr);
+        bridgeCall(() => _fs.utimes.applySyncPromise(undefined, [pathStr, atimeNum, mtimeNum]), "utimes", pathStr);
     },
     // Async methods - wrap sync methods in callbacks/promises
     //

package/dist/bridge/module.js

@@ -78,7 +78,10 @@ export function createRequire(filename) {
     };
     // Create resolve function
     const resolve = function (request, _options) {
-        const resolved = _resolveModule(request, dirname);
+        const resolved = _resolveModule.applySyncPromise(undefined, [
+            request,
+            dirname,
+        ]);
         if (resolved === null) {
             const err = new Error("Cannot find module '" + request + "'");
             err.code = "MODULE_NOT_FOUND";
@@ -152,7 +155,10 @@ export class Module {
         const wrapper = new Function("exports", "require", "module", "__filename", "__dirname", content);
         const moduleRequire = (request) => _requireFrom(request, this.path);
         moduleRequire.resolve = (request) => {
-            const resolved = _resolveModule(request, this.path);
+            const resolved = _resolveModule.applySyncPromise(undefined, [
+                request,
+                this.path,
+            ]);
             if (resolved === null) {
                 const err = new Error("Cannot find module '" + request + "'");
                 err.code = "MODULE_NOT_FOUND";
@@ -184,7 +190,10 @@ export class Module {
         : {};
     static _resolveFilename(request, parent, _isMain, _options) {
         const parentDir = parent && parent.path ? parent.path : "/";
-        const resolved = _resolveModule(request, parentDir);
+        const resolved = _resolveModule.applySyncPromise(undefined, [
+            request,
+            parentDir,
+        ]);
         if (resolved === null) {
             const err = new Error("Cannot find module '" + request + "'");
             err.code = "MODULE_NOT_FOUND";

package/dist/bridge/network.d.ts

@@ -24,7 +24,7 @@ interface FetchResponse {
     blob(): Promise<never>;
     clone(): FetchResponse;
 }
-export declare function fetch(url: string | URL, options?: FetchOptions): Promise<FetchResponse>;
+export declare function fetch(input: string | URL | Request, options?: FetchOptions): Promise<FetchResponse>;
 export declare class Headers {
     private _headers;
     constructor(init?: HeadersInit | Headers | Record<string, string> | [string, string][]);
@@ -214,6 +214,92 @@ export declare const http2: {
     createServer(): never;
     createSecureServer(): never;
 };
+declare class NetSocket {
+    remoteAddress: string;
+    remotePort: number;
+    remoteFamily: string;
+    localAddress: string;
+    localPort: number;
+    connecting: boolean;
+    pending: boolean;
+    destroyed: boolean;
+    writable: boolean;
+    readable: boolean;
+    readyState: "opening" | "open" | "readOnly" | "writeOnly" | "closed";
+    bytesRead: number;
+    bytesWritten: number;
+    private _listeners;
+    /** @internal socket ID shared with TLS upgrade bridge */
+    _socketId: number;
+    private _connectHost;
+    private _connectPort;
+    _readableState: {
+        endEmitted: boolean;
+        ended: boolean;
+    };
+    _writableState: {
+        finished: boolean;
+        errorEmitted: boolean;
+        ended: boolean;
+    };
+    constructor(_options?: Record<string, unknown>);
+    connect(...args: unknown[]): this;
+    setTimeout(_ms: number, _cb?: () => void): this;
+    setNoDelay(_noDelay?: boolean): this;
+    setKeepAlive(_enable?: boolean, _delay?: number): this;
+    setMaxListeners(_n: number): this;
+    getMaxListeners(): number;
+    ref(): this;
+    unref(): this;
+    cork(): void;
+    uncork(): void;
+    pause(): this;
+    resume(): this;
+    pipe<T>(destination: T): T;
+    address(): {
+        address: string;
+        family: string;
+        port: number;
+    };
+    listeners(event: string): EventListener[];
+    rawListeners(event: string): EventListener[];
+    eventNames(): string[];
+    prependListener(event: string, listener: EventListener): this;
+    prependOnceListener(event: string, listener: EventListener): this;
+    on(event: string, listener: EventListener): this;
+    addListener(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;
+    listenerCount(event: string): number;
+    [key: string | symbol]: unknown;
+    write(data: unknown, encodingOrCb?: string | (() => void), cb?: (() => void)): boolean;
+    end(data?: unknown, encodingOrCb?: string | (() => void), cb?: (() => void)): this;
+    destroy(err?: Error): this;
+    _onConnect(): void;
+    _onData(dataBase64: string): void;
+    _onEnd(): void;
+    _onError(message: string): void;
+    _onClose(hadError: boolean): void;
+    private _cleanup;
+}
+declare function netIsIP(input: string): number;
+export declare const net: {
+    Socket: typeof import("net").Socket;
+    connect(portOrOpts: number | Record<string, unknown>, hostOrCb?: string | (() => void), cb?: () => void): NetSocket;
+    createConnection(portOrOpts: number | Record<string, unknown>, hostOrCb?: string | (() => void), cb?: () => void): NetSocket;
+    createServer(): never;
+    isIP: typeof netIsIP;
+    isIPv4(input: string): boolean;
+    isIPv6(input: string): boolean;
+};
+export declare const tlsModule: {
+    TLSSocket: typeof import("tls").TLSSocket;
+    connect(options: Record<string, unknown>): NetSocket;
+    createSecureContext(_options?: Record<string, unknown>): Record<string, unknown>;
+};
 declare const _default: {
     fetch: typeof fetch;
     Headers: typeof Headers;
@@ -244,6 +330,20 @@ declare const _default: {
         createServer(): never;
         createSecureServer(): never;
     };
+    net: {
+        Socket: typeof import("net").Socket;
+        connect(portOrOpts: number | Record<string, unknown>, hostOrCb?: string | (() => void), cb?: () => void): NetSocket;
+        createConnection(portOrOpts: number | Record<string, unknown>, hostOrCb?: string | (() => void), cb?: () => void): NetSocket;
+        createServer(): never;
+        isIP: typeof netIsIP;
+        isIPv4(input: string): boolean;
+        isIPv6(input: string): boolean;
+    };
+    tls: {
+        TLSSocket: typeof import("tls").TLSSocket;
+        connect(options: Record<string, unknown>): NetSocket;
+        createSecureContext(_options?: Record<string, unknown>): Record<string, unknown>;
+    };
     IncomingMessage: typeof IncomingMessage;
     ClientRequest: typeof ClientRequest;
 };