@secure-exec/browser 0.0.0-main.bccb3a2

package/dist/os-filesystem.js

@@ -0,0 +1,402 @@
+/**
+ * In-memory filesystem for browser environments.
+ *
+ * In-memory filesystem with POSIX extensions (symlinks, hard links, chmod,
+ * chown, utimes, truncate) needed by the kernel VFS interface.
+ */
+const S_IFREG = 0o100000;
+const S_IFDIR = 0o040000;
+const S_IFLNK = 0o120000;
+const MAX_SYMLINK_DEPTH = 40;
+function normalizePath(path) {
+    if (!path)
+        return "/";
+    let normalized = path.startsWith("/") ? path : `/${path}`;
+    normalized = normalized.replace(/\/+/g, "/");
+    if (normalized.length > 1 && normalized.endsWith("/")) {
+        normalized = normalized.slice(0, -1);
+    }
+    // Resolve . and ..
+    const parts = normalized.split("/");
+    const resolved = [];
+    for (const part of parts) {
+        if (part === "." || part === "")
+            continue;
+        if (part === "..") {
+            resolved.pop();
+        }
+        else {
+            resolved.push(part);
+        }
+    }
+    return `/${resolved.join("/")}` || "/";
+}
+function dirname(path) {
+    const parts = normalizePath(path).split("/").filter(Boolean);
+    if (parts.length <= 1)
+        return "/";
+    return `/${parts.slice(0, -1).join("/")}`;
+}
+let nextIno = 1;
+export class InMemoryFileSystem {
+    entries = new Map();
+    constructor() {
+        // Root directory
+        this.entries.set("/", this.newDir());
+    }
+    // --- Core operations ---
+    async readFile(path) {
+        const entry = this.resolveEntry(path);
+        if (!entry || entry.type !== "file") {
+            throw this.enoent("open", path);
+        }
+        entry.atimeMs = Date.now();
+        return entry.data;
+    }
+    async readTextFile(path) {
+        const data = await this.readFile(path);
+        return new TextDecoder().decode(data);
+    }
+    async readDir(path) {
+        return (await this.readDirWithTypes(path)).map((e) => e.name);
+    }
+    async readDirWithTypes(path) {
+        const resolved = this.resolvePath(path);
+        const dir = this.entries.get(resolved);
+        if (!dir || dir.type !== "dir") {
+            throw this.enoent("scandir", path);
+        }
+        const prefix = resolved === "/" ? "/" : `${resolved}/`;
+        const names = new Map();
+        for (const [entryPath, entry] of this.entries) {
+            if (entryPath.startsWith(prefix)) {
+                const rest = entryPath.slice(prefix.length);
+                if (rest && !rest.includes("/")) {
+                    names.set(rest, {
+                        name: rest,
+                        isDirectory: entry.type === "dir",
+                        isSymbolicLink: entry.type === "symlink",
+                    });
+                }
+            }
+        }
+        return Array.from(names.values());
+    }
+    async writeFile(path, content) {
+        const normalized = normalizePath(path);
+        // Ensure parent exists
+        await this.mkdir(dirname(normalized), { recursive: true });
+        const data = typeof content === "string" ? new TextEncoder().encode(content) : content;
+        const existing = this.entries.get(normalized);
+        if (existing && existing.type === "file") {
+            existing.data = data;
+            existing.mtimeMs = Date.now();
+            existing.ctimeMs = Date.now();
+            return;
+        }
+        const now = Date.now();
+        this.entries.set(normalized, {
+            type: "file",
+            data,
+            mode: S_IFREG | 0o644,
+            uid: 1000,
+            gid: 1000,
+            nlink: 1,
+            ino: nextIno++,
+            atimeMs: now,
+            mtimeMs: now,
+            ctimeMs: now,
+            birthtimeMs: now,
+        });
+    }
+    async createDir(path) {
+        const normalized = normalizePath(path);
+        const parent = dirname(normalized);
+        if (!this.entries.has(parent)) {
+            throw this.enoent("mkdir", path);
+        }
+        if (!this.entries.has(normalized)) {
+            this.entries.set(normalized, this.newDir());
+        }
+    }
+    async mkdir(path, options) {
+        const normalized = normalizePath(path);
+        if (options?.recursive !== false) {
+            // Recursive: create all missing parents
+            const parts = normalized.split("/").filter(Boolean);
+            let current = "";
+            for (const part of parts) {
+                current += `/${part}`;
+                if (!this.entries.has(current)) {
+                    this.entries.set(current, this.newDir());
+                }
+            }
+        }
+        else {
+            await this.createDir(path);
+        }
+    }
+    async exists(path) {
+        try {
+            const resolved = this.resolvePath(path);
+            return this.entries.has(resolved);
+        }
+        catch {
+            return false;
+        }
+    }
+    async stat(path) {
+        const entry = this.resolveEntry(path);
+        if (!entry)
+            throw this.enoent("stat", path);
+        return this.toStat(entry);
+    }
+    async removeFile(path) {
+        const resolved = this.resolvePath(path);
+        const entry = this.entries.get(resolved);
+        if (!entry || entry.type === "dir") {
+            throw this.enoent("unlink", path);
+        }
+        this.entries.delete(resolved);
+    }
+    async removeDir(path) {
+        const resolved = this.resolvePath(path);
+        if (resolved === "/") {
+            throw new Error("EPERM: operation not permitted, rmdir '/'");
+        }
+        const entry = this.entries.get(resolved);
+        if (!entry || entry.type !== "dir") {
+            throw this.enoent("rmdir", path);
+        }
+        // Check if empty
+        const prefix = `${resolved}/`;
+        for (const key of this.entries.keys()) {
+            if (key.startsWith(prefix)) {
+                throw new Error(`ENOTEMPTY: directory not empty, rmdir '${path}'`);
+            }
+        }
+        this.entries.delete(resolved);
+    }
+    async realpath(path) {
+        return this.resolvePath(path);
+    }
+    async rename(oldPath, newPath) {
+        const oldResolved = this.resolvePath(oldPath);
+        const newNorm = normalizePath(newPath);
+        const entry = this.entries.get(oldResolved);
+        if (!entry)
+            throw this.enoent("rename", oldPath);
+        // Ensure parent of target exists
+        if (!this.entries.has(dirname(newNorm))) {
+            throw this.enoent("rename", newPath);
+        }
+        if (entry.type !== "dir") {
+            this.entries.set(newNorm, entry);
+            this.entries.delete(oldResolved);
+            return;
+        }
+        // Move directory and all children
+        const prefix = `${oldResolved}/`;
+        const toMove = [];
+        for (const [key, val] of this.entries) {
+            if (key === oldResolved || key.startsWith(prefix)) {
+                toMove.push([key, val]);
+            }
+        }
+        for (const [key] of toMove) {
+            this.entries.delete(key);
+        }
+        for (const [key, val] of toMove) {
+            const newKey = key === oldResolved ? newNorm : newNorm + key.slice(oldResolved.length);
+            this.entries.set(newKey, val);
+        }
+    }
+    // --- Symlinks ---
+    async symlink(target, linkPath) {
+        const normalized = normalizePath(linkPath);
+        if (this.entries.has(normalized)) {
+            throw new Error(`EEXIST: file already exists, symlink '${linkPath}'`);
+        }
+        const now = Date.now();
+        this.entries.set(normalized, {
+            type: "symlink",
+            target,
+            mode: S_IFLNK | 0o777,
+            uid: 1000,
+            gid: 1000,
+            nlink: 1,
+            ino: nextIno++,
+            atimeMs: now,
+            mtimeMs: now,
+            ctimeMs: now,
+            birthtimeMs: now,
+        });
+    }
+    async readlink(path) {
+        const normalized = normalizePath(path);
+        const entry = this.entries.get(normalized);
+        if (!entry || entry.type !== "symlink") {
+            throw this.enoent("readlink", path);
+        }
+        return entry.target;
+    }
+    async lstat(path) {
+        const normalized = normalizePath(path);
+        const entry = this.entries.get(normalized);
+        if (!entry)
+            throw this.enoent("lstat", path);
+        return this.toStat(entry);
+    }
+    // --- Links ---
+    async link(oldPath, newPath) {
+        const entry = this.resolveEntry(oldPath);
+        if (!entry || entry.type !== "file") {
+            throw this.enoent("link", oldPath);
+        }
+        const newNorm = normalizePath(newPath);
+        if (this.entries.has(newNorm)) {
+            throw new Error(`EEXIST: file already exists, link '${newPath}'`);
+        }
+        entry.nlink++;
+        this.entries.set(newNorm, entry);
+    }
+    // --- Permissions & Metadata ---
+    async chmod(path, mode) {
+        const entry = this.resolveEntry(path);
+        if (!entry)
+            throw this.enoent("chmod", path);
+        const callerTypeBits = mode & 0o170000;
+        if (callerTypeBits !== 0) {
+            entry.mode = mode;
+        }
+        else {
+            entry.mode = (entry.mode & 0o170000) | (mode & 0o7777);
+        }
+        entry.ctimeMs = Date.now();
+    }
+    async chown(path, uid, gid) {
+        const entry = this.resolveEntry(path);
+        if (!entry)
+            throw this.enoent("chown", path);
+        entry.uid = uid;
+        entry.gid = gid;
+        entry.ctimeMs = Date.now();
+    }
+    async utimes(path, atime, mtime) {
+        const entry = this.resolveEntry(path);
+        if (!entry)
+            throw this.enoent("utimes", path);
+        entry.atimeMs = atime;
+        entry.mtimeMs = mtime;
+        entry.ctimeMs = Date.now();
+    }
+    async truncate(path, length) {
+        const entry = this.resolveEntry(path);
+        if (!entry || entry.type !== "file") {
+            throw this.enoent("truncate", path);
+        }
+        if (length < entry.data.length) {
+            entry.data = entry.data.slice(0, length);
+        }
+        else if (length > entry.data.length) {
+            const newData = new Uint8Array(length);
+            newData.set(entry.data);
+            entry.data = newData;
+        }
+        entry.mtimeMs = Date.now();
+        entry.ctimeMs = Date.now();
+    }
+    async pread(path, offset, length) {
+        const entry = this.resolveEntry(path);
+        if (!entry || entry.type !== "file") {
+            throw this.enoent("open", path);
+        }
+        entry.atimeMs = Date.now();
+        if (offset >= entry.data.length)
+            return new Uint8Array(0);
+        return entry.data.slice(offset, Math.min(offset + length, entry.data.length));
+    }
+    async pwrite(path, offset, data) {
+        const entry = this.resolveEntry(path);
+        if (!entry || entry.type !== "file") {
+            throw this.enoent("open", path);
+        }
+        const endPos = offset + data.length;
+        const newContent = new Uint8Array(Math.max(entry.data.length, endPos));
+        newContent.set(entry.data);
+        newContent.set(data, offset);
+        entry.data = newContent;
+        const now = Date.now();
+        entry.mtimeMs = now;
+        entry.ctimeMs = now;
+    }
+    // --- Helpers ---
+    /**
+     * Resolve symlinks to get the final path. Returns the normalized path
+     * after following all symlinks.
+     */
+    resolvePath(path, depth = 0) {
+        if (depth > MAX_SYMLINK_DEPTH) {
+            throw new Error(`ELOOP: too many levels of symbolic links, '${path}'`);
+        }
+        const normalized = normalizePath(path);
+        const entry = this.entries.get(normalized);
+        if (!entry)
+            return normalized;
+        if (entry.type === "symlink") {
+            const target = entry.target.startsWith("/")
+                ? entry.target
+                : `${dirname(normalized)}/${entry.target}`;
+            return this.resolvePath(target, depth + 1);
+        }
+        return normalized;
+    }
+    /** Resolve a path and return the entry (following symlinks). */
+    resolveEntry(path) {
+        const resolved = this.resolvePath(path);
+        return this.entries.get(resolved);
+    }
+    newDir() {
+        const now = Date.now();
+        return {
+            type: "dir",
+            mode: S_IFDIR | 0o755,
+            uid: 1000,
+            gid: 1000,
+            nlink: 2,
+            ino: nextIno++,
+            atimeMs: now,
+            mtimeMs: now,
+            ctimeMs: now,
+            birthtimeMs: now,
+        };
+    }
+    toStat(entry) {
+        const size = entry.type === "file" ? entry.data.length : 4096;
+        return {
+            mode: entry.mode,
+            size,
+            blocks: size === 0 ? 0 : Math.ceil(size / 512),
+            dev: 1,
+            rdev: 0,
+            isDirectory: entry.type === "dir",
+            isSymbolicLink: entry.type === "symlink",
+            atimeMs: entry.atimeMs,
+            mtimeMs: entry.mtimeMs,
+            ctimeMs: entry.ctimeMs,
+            birthtimeMs: entry.birthtimeMs,
+            ino: entry.ino,
+            nlink: entry.nlink,
+            uid: entry.uid,
+            gid: entry.gid,
+        };
+    }
+    enoent(op, path) {
+        const err = new Error(`ENOENT: no such file or directory, ${op} '${path}'`);
+        err.code = "ENOENT";
+        return err;
+    }
+}
+export function createInMemoryFileSystem() {
+    return new InMemoryFileSystem();
+}

package/dist/permission-validation.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Validate permission callback source strings before revival via new Function().
+ *
+ * Permission callbacks are serialized with fn.toString() on the host and revived
+ * in the Web Worker. Because revival uses new Function(), the source must be
+ * validated to prevent code injection.
+ */
+/**
+ * Validate that a permission callback source string is safe to revive.
+ *
+ * Returns true if the source appears to be a safe function expression.
+ * Returns false if the source contains blocked patterns that could indicate
+ * code injection.
+ */
+export declare function validatePermissionSource(source: string): boolean;

package/dist/permission-validation.js

@@ -0,0 +1,62 @@
+/**
+ * Validate permission callback source strings before revival via new Function().
+ *
+ * Permission callbacks are serialized with fn.toString() on the host and revived
+ * in the Web Worker. Because revival uses new Function(), the source must be
+ * validated to prevent code injection.
+ */
+/**
+ * Dangerous patterns that should never appear in a permission callback.
+ * These could be used to escape the sandbox or access host resources.
+ */
+const BLOCKED_PATTERNS = [
+    // Code execution / eval
+    /\beval\s*\(/,
+    /\bFunction\s*\(/,
+    /\bnew\s+Function\b/,
+    // Module loading
+    /\bimport\s*\(/,
+    /\bimportScripts\s*\(/,
+    /\brequire\s*\(/,
+    // Global object access
+    /\bglobalThis\b/,
+    /\bself\b/,
+    /\bwindow\b/,
+    // Process/system access
+    /\bprocess\s*\.\s*(?:exit|kill|binding|_linkedBinding|env)\b/,
+    // Network / IO escape
+    /\bXMLHttpRequest\b/,
+    /\bWebSocket\b/,
+    /\bfetch\s*\(/,
+    // Prototype pollution / constructor abuse
+    /\bconstructor\s*\[/,
+    /\b__proto__\b/,
+    /Object\s*\.\s*(?:defineProperty|setPrototypeOf|assign)\b/,
+    // Dynamic property access on dangerous objects
+    /\bpostMessage\b/,
+];
+/**
+ * Validate that a permission callback source string is safe to revive.
+ *
+ * Returns true if the source appears to be a safe function expression.
+ * Returns false if the source contains blocked patterns that could indicate
+ * code injection.
+ */
+export function validatePermissionSource(source) {
+    if (!source || typeof source !== "string")
+        return false;
+    const trimmed = source.trim();
+    // Must look like a function expression (arrow function or function keyword)
+    const startsLikeFunction = trimmed.startsWith("function") ||
+        trimmed.startsWith("(") ||
+        // Single-param arrow functions: x => ...
+        /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*=>/.test(trimmed);
+    if (!startsLikeFunction)
+        return false;
+    // Check for blocked patterns
+    for (const pattern of BLOCKED_PATTERNS) {
+        if (pattern.test(source))
+            return false;
+    }
+    return true;
+}

package/dist/runtime-driver.d.ts

@@ -0,0 +1,34 @@
+import type { ExecOptions, ExecResult, NetworkAdapter, NodeRuntimeDriver, NodeRuntimeDriverFactory, RunResult, RuntimeDriverOptions } from "./runtime.js";
+export interface BrowserRuntimeDriverFactoryOptions {
+    workerUrl?: URL | string;
+}
+export declare class BrowserRuntimeDriver implements NodeRuntimeDriver {
+    private readonly worker;
+    private readonly pending;
+    private readonly controlToken;
+    private readonly defaultOnStdio?;
+    private readonly defaultTimingMitigation;
+    private readonly networkAdapter;
+    private readonly syncBridge;
+    private readonly syncFilesystem;
+    private readonly ready;
+    private readonly encoder;
+    private nextId;
+    private disposed;
+    constructor(options: RuntimeDriverOptions, factoryOptions?: BrowserRuntimeDriverFactoryOptions);
+    get network(): Pick<NetworkAdapter, "fetch" | "dnsLookup" | "httpRequest">;
+    private handleWorkerError;
+    private handleWorkerMessage;
+    private handleSyncRequest;
+    private rejectAllPending;
+    private clearWorkerHandlers;
+    private resetSyncBridgeState;
+    private cleanup;
+    private callWorker;
+    run<T = unknown>(code: string, filePath?: string): Promise<RunResult<T>>;
+    exec(code: string, options?: ExecOptions): Promise<ExecResult>;
+    dispatchExtensionRequest(namespace: string, payload: Uint8Array): Promise<Uint8Array>;
+    dispose(): void;
+    terminate(): Promise<void>;
+}
+export declare function createBrowserRuntimeDriverFactory(factoryOptions?: BrowserRuntimeDriverFactoryOptions): NodeRuntimeDriverFactory;