shortcutxl 0.2.19 → 0.2.21

package/dist/custom/sandbox/lib/network/socks-proxy.js

@@ -0,0 +1,269 @@
+/**
+ * Node.js SOCKS5 proxy server.
+ *
+ * Implements RFC 1928 (SOCKS5) with no-auth method and CONNECT command only.
+ * Domain filtering is delegated to a callback.
+ *
+ * Covers: SSH, git-over-SSH, database connections, gRPC, and any
+ * SOCKS-aware tool that respects ALL_PROXY.
+ */
+import * as net from 'net';
+// SOCKS5 constants (RFC 1928)
+const SOCKS_VERSION = 0x05;
+const AUTH_NO_AUTH = 0x00;
+const AUTH_NO_ACCEPTABLE = 0xff;
+const CMD_CONNECT = 0x01;
+const ATYP_IPV4 = 0x01;
+const ATYP_DOMAIN = 0x03;
+const ATYP_IPV6 = 0x04;
+const REP_SUCCESS = 0x00;
+const REP_GENERAL_FAILURE = 0x01;
+const REP_CONNECTION_NOT_ALLOWED = 0x02;
+const REP_HOST_UNREACHABLE = 0x04;
+const REP_COMMAND_NOT_SUPPORTED = 0x07;
+const REP_ADDRESS_TYPE_NOT_SUPPORTED = 0x08;
+/** Max bytes buffered during handshake before we drop the connection. */
+const MAX_HANDSHAKE_BUFFER = 4096;
+/**
+ * Start a SOCKS5 proxy on a random localhost port.
+ *
+ * Supports CONNECT command with IPv4, IPv6, and domain name addressing.
+ * Only no-auth method is offered.
+ */
+export function startSocksProxy(options) {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer((client) => {
+            handleSocksClient(client, options.checkDomain);
+        });
+        server.on('error', reject);
+        // Bind to all interfaces — the socat bridge in WSL connects via the host IP
+        // (172.29.x.x), not 127.0.0.1. Windows Firewall blocks external access.
+        server.listen(0, '0.0.0.0', () => {
+            const addr = server.address();
+            if (!addr || typeof addr === 'string') {
+                server.close();
+                reject(new Error('Failed to get server address'));
+                return;
+            }
+            resolve({
+                port: addr.port,
+                stop: () => server.close()
+            });
+        });
+    });
+}
+// ---------------------------------------------------------------------------
+// Buffered reader — maintains a persistent data listener on the socket
+// ---------------------------------------------------------------------------
+class SocketReader {
+    socket;
+    buffer = Buffer.alloc(0);
+    waiting = null;
+    closed = false;
+    // Track our own handlers so detach() only removes ours
+    onDataHandler;
+    onErrorHandler;
+    onCloseHandler;
+    constructor(socket) {
+        this.socket = socket;
+        this.onDataHandler = (chunk) => this.onData(chunk);
+        this.onErrorHandler = () => this.onClose();
+        this.onCloseHandler = () => this.onClose();
+        socket.on('data', this.onDataHandler);
+        socket.on('error', this.onErrorHandler);
+        socket.on('close', this.onCloseHandler);
+    }
+    onData(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        if (this.buffer.length > MAX_HANDSHAKE_BUFFER && !this.waiting) {
+            // Buffer overflow during handshake — abort
+            this.closed = true;
+            this.socket.destroy();
+            return;
+        }
+        this.tryDeliver();
+    }
+    onClose() {
+        this.closed = true;
+        if (this.waiting) {
+            this.waiting.reject(new Error('socket closed'));
+            this.waiting = null;
+        }
+    }
+    tryDeliver() {
+        if (!this.waiting)
+            return;
+        if (this.buffer.length >= this.waiting.count) {
+            const { count, resolve } = this.waiting;
+            this.waiting = null;
+            const result = this.buffer.subarray(0, count);
+            this.buffer = this.buffer.subarray(count);
+            resolve(result);
+        }
+    }
+    /** Read exactly `count` bytes. Rejects on timeout or socket close. */
+    read(count, timeoutMs) {
+        if (this.buffer.length >= count) {
+            const result = this.buffer.subarray(0, count);
+            this.buffer = this.buffer.subarray(count);
+            return Promise.resolve(result);
+        }
+        if (this.closed) {
+            return Promise.reject(new Error('socket closed'));
+        }
+        return new Promise((resolve, reject) => {
+            this.waiting = { count, resolve, reject };
+            const timer = setTimeout(() => {
+                if (this.waiting) {
+                    this.waiting = null;
+                    reject(new Error('read timeout'));
+                }
+            }, timeoutMs);
+            const origResolve = resolve;
+            const origReject = reject;
+            this.waiting.resolve = (buf) => {
+                clearTimeout(timer);
+                origResolve(buf);
+            };
+            this.waiting.reject = (err) => {
+                clearTimeout(timer);
+                origReject(err);
+            };
+            this.tryDeliver();
+        });
+    }
+    /** Stop reading and return the underlying socket for piping. */
+    detach() {
+        this.socket.removeListener('data', this.onDataHandler);
+        this.socket.removeListener('error', this.onErrorHandler);
+        this.socket.removeListener('close', this.onCloseHandler);
+        if (this.buffer.length > 0) {
+            this.socket.unshift(this.buffer);
+            this.buffer = Buffer.alloc(0);
+        }
+        return this.socket;
+    }
+}
+// ---------------------------------------------------------------------------
+// SOCKS5 connection handler
+// ---------------------------------------------------------------------------
+async function handleSocksClient(client, checkDomain) {
+    const reader = new SocketReader(client);
+    try {
+        // Phase 1: Method negotiation
+        const greeting = await reader.read(2, 5000);
+        if (greeting[0] !== SOCKS_VERSION) {
+            client.destroy();
+            return;
+        }
+        const nmethods = greeting[1];
+        const methods = await reader.read(nmethods, 3000);
+        if (!methods.includes(AUTH_NO_AUTH)) {
+            client.write(Buffer.from([SOCKS_VERSION, AUTH_NO_ACCEPTABLE]));
+            client.destroy();
+            return;
+        }
+        client.write(Buffer.from([SOCKS_VERSION, AUTH_NO_AUTH]));
+        // Phase 2: CONNECT request
+        const header = await reader.read(4, 5000);
+        if (header[0] !== SOCKS_VERSION) {
+            client.destroy();
+            return;
+        }
+        const cmd = header[1];
+        const atyp = header[3];
+        if (cmd !== CMD_CONNECT) {
+            sendReply(client, REP_COMMAND_NOT_SUPPORTED);
+            client.destroy();
+            return;
+        }
+        // Parse address
+        let host;
+        if (atyp === ATYP_IPV4) {
+            const addr = await reader.read(4, 3000);
+            host = `${addr[0]}.${addr[1]}.${addr[2]}.${addr[3]}`;
+        }
+        else if (atyp === ATYP_DOMAIN) {
+            const lenBuf = await reader.read(1, 3000);
+            const domainLen = lenBuf[0];
+            const domainBuf = await reader.read(domainLen, 3000);
+            host = domainBuf.toString('utf-8');
+        }
+        else if (atyp === ATYP_IPV6) {
+            const addr = await reader.read(16, 3000);
+            const parts = [];
+            for (let i = 0; i < 16; i += 2) {
+                parts.push(((addr[i] << 8) | addr[i + 1]).toString(16));
+            }
+            host = parts.join(':');
+        }
+        else {
+            sendReply(client, REP_ADDRESS_TYPE_NOT_SUPPORTED);
+            client.destroy();
+            return;
+        }
+        const portBuf = await reader.read(2, 3000);
+        const port = (portBuf[0] << 8) | portBuf[1];
+        const allowed = await checkDomain(host);
+        if (!allowed) {
+            sendReply(client, REP_CONNECTION_NOT_ALLOWED);
+            client.destroy();
+            return;
+        }
+        // Detach the reader so we can pipe the raw socket
+        const rawClient = reader.detach();
+        // Track whether we've sent the SOCKS reply (exactly one allowed)
+        let replied = false;
+        const target = net.createConnection({ host, port }, () => {
+            replied = true;
+            sendReply(rawClient, REP_SUCCESS);
+            rawClient.pipe(target);
+            target.pipe(rawClient);
+        });
+        target.on('error', () => {
+            if (!replied) {
+                replied = true;
+                sendReply(rawClient, REP_HOST_UNREACHABLE);
+            }
+            rawClient.destroy();
+        });
+        rawClient.on('error', () => target.destroy());
+        rawClient.on('close', () => target.destroy());
+        target.on('close', () => rawClient.destroy());
+        target.setTimeout(10000, () => {
+            if (!replied) {
+                replied = true;
+                sendReply(rawClient, REP_GENERAL_FAILURE);
+            }
+            target.destroy();
+            rawClient.destroy();
+        });
+    }
+    catch {
+        client.destroy();
+    }
+}
+// ---------------------------------------------------------------------------
+// SOCKS5 reply
+// ---------------------------------------------------------------------------
+function sendReply(client, rep) {
+    const reply = Buffer.from([
+        SOCKS_VERSION,
+        rep,
+        0x00,
+        ATYP_IPV4,
+        0,
+        0,
+        0,
+        0, // BND.ADDR
+        0,
+        0 // BND.PORT
+    ]);
+    try {
+        client.write(reply);
+    }
+    catch {
+        // Client already gone
+    }
+}
+//# sourceMappingURL=socks-proxy.js.map

package/dist/custom/sandbox/{sandbox-paths.js → lib/paths.js}

@@ -2,7 +2,6 @@
  * Path translation between Windows and WSL2 mount paths.
  *
  * Only used at config-resolution time (not per-command).
- * The LLM is prompted to use Linux paths directly when sandbox is active.
  */
 /**
  * Convert a Windows absolute path to its WSL2 /mnt/ equivalent.
@@ -12,7 +11,6 @@
  * Returns the input unchanged if it doesn't look like a Windows absolute path.
  */
 export function toLinuxPath(winPath) {
-    // Match drive letter patterns: C:\, C:/, or already-linux paths
     const match = winPath.match(/^([A-Za-z]):[/\\](.*)/);
     if (!match)
         return winPath;
@@ -20,4 +18,4 @@ export function toLinuxPath(winPath) {
     const rest = match[2].replace(/\\/g, '/');
     return `/mnt/${drive}/${rest}`;
 }
-//# sourceMappingURL=sandbox-paths.js.map
+//# sourceMappingURL=paths.js.map

package/dist/custom/sandbox/lib/resolve.js

@@ -0,0 +1,320 @@
+/**
+ * Resolve caller-provided SandboxConfig into concrete SandboxState.
+ *
+ * Converts Windows paths to Linux /mnt/ paths and probes the WSL
+ * filesystem so that buildBwrapArgs() needs no I/O.
+ */
+import { spawnSync } from 'child_process';
+import { ETC_ENTRIES_FOR_NETWORK } from './bwrap.js';
+import { toLinuxPath } from './paths.js';
+export const DEFAULT_DISTRO = 'shortcutxl';
+/**
+ * Paths always write-protected, even within writable regions.
+ *
+ * Relative paths are expanded against each writable mount.
+ * These close real escape vectors: shell config injection,
+ * git hook planting, credential theft, config tampering.
+ */
+export const MANDATORY_DENY_PATHS = [
+    // Shell configs — code execution on next shell open
+    '.bashrc',
+    '.profile',
+    '.zshrc',
+    // Git — hook injection, repo redirect
+    '.gitconfig',
+    '.git/hooks',
+    // SSH — key exfiltration, authorized_keys injection
+    '.ssh',
+    // Environment — credential theft via auto-sourcing
+    '.env',
+    '.envrc',
+    // MCP — direct sandbox escape via server config tampering
+    '.mcp.json'
+];
+/**
+ * Resolve sandbox config + cwd into ready-to-use sandbox state.
+ *
+ * Probes the WSL distro for /lib64, /etc entries, resolv.conf,
+ * and deny path existence so that subsequent buildBwrapArgs() calls are pure.
+ */
+export function resolveSandboxConfig(config, cwd) {
+    const distro = config.distro ?? DEFAULT_DISTRO;
+    const networkMode = config.networkMode ?? 'none';
+    const needsNetwork = networkMode !== 'none';
+    const rawReadMounts = (config.readPaths ?? []).map(toLinuxPath);
+    const rawWriteMounts = (config.writePaths ?? []).map(toLinuxPath);
+    const denyPatterns = config.denyPaths ?? MANDATORY_DENY_PATHS;
+    // Resolve symlinks and reject paths that escape allowed boundaries.
+    // Allowed boundaries = union of all read + write paths.
+    const allBoundaries = [...rawReadMounts, ...rawWriteMounts];
+    const readMounts = resolveAndValidateMounts(distro, rawReadMounts, allBoundaries);
+    const writeMounts = resolveAndValidateMounts(distro, rawWriteMounts, allBoundaries);
+    // Probe for seccomp infrastructure (apply-seccomp binary + BPF filter).
+    // Both must exist for seccomp to be active. Graceful degradation if missing.
+    const seccompEnabled = config.seccomp !== false;
+    const SECCOMP_FILTER = '/etc/seccomp/unix-block.bpf';
+    const SECCOMP_BINARY = '/usr/local/bin/apply-seccomp';
+    const seccompFilterPath = seccompEnabled && existsInWsl(distro, SECCOMP_FILTER) && existsInWsl(distro, SECCOMP_BINARY)
+        ? SECCOMP_FILTER
+        : null;
+    return {
+        distro,
+        readMounts,
+        writeMounts,
+        workdir: toLinuxPath(cwd),
+        networkMode,
+        env: config.env ?? {},
+        denyMounts: resolveDenyMounts(distro, writeMounts, denyPatterns),
+        seccompFilterPath,
+        hasLib64: existsInWsl(distro, '/lib64'),
+        resolvedResolvConf: needsNetwork ? resolveWslPath(distro, '/etc/resolv.conf') : null,
+        existingEtcEntries: needsNetwork
+            ? ETC_ENTRIES_FOR_NETWORK.filter((e) => existsInWsl(distro, e))
+            : []
+    };
+}
+// ---------------------------------------------------------------------------
+// Symlink boundary checking
+// ---------------------------------------------------------------------------
+/**
+ * Batch-resolve symlinks via `readlink -f` and filter out paths that
+ * escape their allowed boundaries.
+ *
+ * A mount is valid if its resolved (real) path either:
+ *   1. Equals the original path (not a symlink, or symlink to itself), OR
+ *   2. Falls within one of the allowed boundary paths.
+ *
+ * Broken symlinks and non-existent paths are rejected (readlink -f fails).
+ *
+ * @param distro - WSL distro name
+ * @param mounts - Linux mount paths to validate
+ * @param allowedBoundaries - All configured mount paths (read + write) that
+ *   define the allowed scope. A resolved path is accepted if it starts with
+ *   any of these boundaries.
+ * @returns Only the mounts that pass boundary checking (using resolved paths).
+ */
+export function resolveAndValidateMounts(distro, mounts, allowedBoundaries) {
+    if (mounts.length === 0)
+        return [];
+    const resolved = batchResolveSymlinks(distro, mounts);
+    const validated = [];
+    for (const original of mounts) {
+        const real = resolved.get(original);
+        if (real == null)
+            continue; // broken symlink or doesn't exist — reject
+        // Accept if resolved path equals original (no symlink)
+        if (real === original) {
+            validated.push(original);
+            continue;
+        }
+        // Accept if resolved path falls within any allowed boundary
+        const withinBoundary = allowedBoundaries.some((boundary) => real === boundary || real.startsWith(boundary + '/'));
+        if (withinBoundary) {
+            validated.push(real); // use the resolved path
+        }
+        // Otherwise: symlink escapes boundaries — silently rejected
+    }
+    return validated;
+}
+/**
+ * Batch-resolve symlinks for multiple paths in a single WSL call.
+ * Returns a Map from original path to resolved path (null if resolution failed).
+ */
+function batchResolveSymlinks(distro, paths) {
+    const results = new Map();
+    const uncached = [];
+    for (const p of paths) {
+        const key = `resolve:${distro}:${p}`;
+        if (wslPathCache.has(key)) {
+            results.set(p, wslPathCache.get(key));
+        }
+        else {
+            uncached.push(p);
+        }
+    }
+    if (uncached.length === 0)
+        return results;
+    // Batch: "readlink -f '/p1' 2>/dev/null || echo '::FAIL::'; readlink -f '/p2' ..."
+    // Each readlink outputs one line on success, or ::FAIL:: on failure.
+    const script = uncached
+        .map((p) => {
+        const escaped = shellEscape(p);
+        return `readlink -f '${escaped}' 2>/dev/null || echo '::FAIL::'`;
+    })
+        .join('; ');
+    try {
+        const result = spawnSync('wsl', ['-d', distro, '--', 'sh', '-c', script], {
+            timeout: 5000,
+            encoding: 'utf-8',
+            windowsHide: true
+        });
+        const lines = (result.stdout ?? '').split('\n').map((l) => l.trim());
+        for (let i = 0; i < uncached.length; i++) {
+            const line = lines[i] ?? '::FAIL::';
+            const resolved = line === '::FAIL::' || line === '' ? null : line;
+            const key = `resolve:${distro}:${uncached[i]}`;
+            wslPathCache.set(key, resolved);
+            results.set(uncached[i], resolved);
+        }
+    }
+    catch {
+        for (const p of uncached) {
+            wslPathCache.set(`resolve:${distro}:${p}`, null);
+            results.set(p, null);
+        }
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Deny path resolution
+// ---------------------------------------------------------------------------
+/**
+ * Expand relative deny patterns against each writable mount and
+ * return only the paths that exist in WSL (bwrap can't overlay non-existent paths).
+ *
+ * If a deny path is a symlink, both the symlink and its resolved target
+ * are included so both the alias and the real path are protected.
+ *
+ * Non-existent deny paths are a known gap — sandboxed code could create them.
+ * This will be addressed by Phase 6 (seccomp).
+ */
+function resolveDenyMounts(distro, writeMounts, denyPatterns) {
+    if (denyPatterns.length === 0 || writeMounts.length === 0)
+        return [];
+    const candidates = [];
+    for (const mount of writeMounts) {
+        for (const pattern of denyPatterns) {
+            if (pattern.startsWith('/')) {
+                if (pattern.startsWith(mount + '/') || pattern === mount) {
+                    candidates.push(pattern);
+                }
+            }
+            else {
+                candidates.push(`${mount}/${pattern}`);
+            }
+        }
+    }
+    const unique = [...new Set(candidates)];
+    if (unique.length === 0)
+        return [];
+    // Check which candidates exist, then resolve symlinks
+    const existing = batchExistsInWsl(distro, unique);
+    const resolved = batchResolveSymlinks(distro, existing);
+    const result = new Set();
+    for (const original of existing) {
+        result.add(original);
+        const real = resolved.get(original);
+        if (real != null && real !== original) {
+            result.add(real); // also protect the resolved target
+        }
+    }
+    return [...result];
+}
+/** Escape a string for use inside single quotes in sh. */
+function shellEscape(s) {
+    // In single-quoted strings, the only character that can't appear is '.
+    // Replace each ' with the sequence: end quote, escaped quote, start quote.
+    return s.replace(/'/g, "'\\''");
+}
+/**
+ * Check multiple paths in a single WSL call.
+ * Returns the subset of paths that exist.
+ */
+function batchExistsInWsl(distro, paths) {
+    // Check cache first — return cached results and only probe uncached paths
+    const results = [];
+    const uncached = [];
+    for (const p of paths) {
+        const key = `exists:${distro}:${p}`;
+        if (wslPathCache.has(key)) {
+            if (wslPathCache.get(key) !== null)
+                results.push(p);
+        }
+        else {
+            uncached.push(p);
+        }
+    }
+    if (uncached.length === 0)
+        return results;
+    // Batch check: "test -e 'P1' && echo 'P1'; test -e 'P2' && echo 'P2'; ..."
+    const script = uncached
+        .map((p) => {
+        const escaped = shellEscape(p);
+        return `test -e '${escaped}' && echo '${escaped}'`;
+    })
+        .join('; ');
+    try {
+        const result = spawnSync('wsl', ['-d', distro, '--', 'sh', '-c', script], {
+            timeout: 5000,
+            encoding: 'utf-8',
+            windowsHide: true
+        });
+        const found = new Set((result.stdout ?? '')
+            .split('\n')
+            .map((l) => l.trim())
+            .filter(Boolean));
+        for (const p of uncached) {
+            const exists = found.has(p);
+            wslPathCache.set(`exists:${distro}:${p}`, exists ? 'true' : null);
+            if (exists)
+                results.push(p);
+        }
+    }
+    catch {
+        // On failure, mark all as non-existent
+        for (const p of uncached) {
+            wslPathCache.set(`exists:${distro}:${p}`, null);
+        }
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// WSL filesystem probes (cached per session)
+// ---------------------------------------------------------------------------
+const wslPathCache = new Map();
+/** Resolve a potentially-symlinked path inside the WSL distro to its real path. */
+function resolveWslPath(distro, path) {
+    const key = `resolve:${distro}:${path}`;
+    if (wslPathCache.has(key))
+        return wslPathCache.get(key);
+    try {
+        const result = spawnSync('wsl', ['-d', distro, '--', 'readlink', '-f', path], {
+            timeout: 3000,
+            encoding: 'utf-8',
+            windowsHide: true
+        });
+        const resolved = result.status === 0 ? (result.stdout ?? '').trim() || null : null;
+        wslPathCache.set(key, resolved);
+        return resolved;
+    }
+    catch {
+        wslPathCache.set(key, null);
+        return null;
+    }
+}
+/** Check if a path exists inside the WSL distro. Cached per session. */
+function existsInWsl(distro, path) {
+    const key = `exists:${distro}:${path}`;
+    if (wslPathCache.has(key))
+        return wslPathCache.get(key) !== null;
+    try {
+        const result = spawnSync('wsl', ['-d', distro, '--', 'test', '-e', path], {
+            timeout: 3000,
+            windowsHide: true
+        });
+        wslPathCache.set(key, result.status === 0 ? 'true' : null);
+        return result.status === 0;
+    }
+    catch {
+        wslPathCache.set(key, null);
+        return false;
+    }
+}
+/**
+ * Clear the WSL path cache.
+ * Call after distro changes (import, unregister) to force re-probing.
+ */
+export function clearResolveCache() {
+    wslPathCache.clear();
+}
+//# sourceMappingURL=resolve.js.map

package/dist/custom/sandbox/lib/smoke.js

@@ -0,0 +1,87 @@
+/**
+ * Smoke test for a WSL2 sandbox distro.
+ *
+ * Verifies that all expected binaries and Python packages are available.
+ */
+import { spawn } from 'child_process';
+/** Binaries that must exist in the distro. */
+const REQUIRED_BINARIES = ['bwrap', 'bash', 'python3', 'pip', 'curl', 'socat'];
+/** Python packages that must be importable. */
+const REQUIRED_PYTHON_PACKAGES = ['openpyxl', 'httpx'];
+/** Run a smoke test against the sandbox distro. */
+export async function runSandboxSmokeTestAsync(distro) {
+    const output = await runBatchedSmokeAsync(distro);
+    return parseSmokeTestOutput(output);
+}
+function buildSmokeScript() {
+    const binaryChecks = REQUIRED_BINARIES.map((bin) => `_p=$(which ${bin} 2>/dev/null) && echo "bin:${bin}:$_p:OK" || echo "bin:${bin}::FAIL"`);
+    const pythonChecks = REQUIRED_PYTHON_PACKAGES.map((pkg) => `_v=$(python3 -c 'import ${pkg}; print(${pkg}.__version__)' 2>/dev/null) && echo "py:${pkg}:$_v:OK" || echo "py:${pkg}::FAIL"`);
+    return [...binaryChecks, ...pythonChecks].join('; ');
+}
+function parseSmokeTestOutput(output) {
+    const checks = [];
+    const lines = output.split('\n').filter(Boolean);
+    const expectedBins = new Set(REQUIRED_BINARIES);
+    const expectedPkgs = new Set(REQUIRED_PYTHON_PACKAGES);
+    for (const line of lines) {
+        const match = line.match(/^(bin|py):([^:]+):(.*?):(OK|FAIL)\s*$/);
+        if (!match)
+            continue;
+        const [, type, name, detail, status] = match;
+        const isOk = status === 'OK';
+        if (type === 'bin') {
+            expectedBins.delete(name);
+            checks.push({ name: name, ok: isOk, detail: isOk ? detail || name : 'not found' });
+        }
+        else {
+            expectedPkgs.delete(name);
+            checks.push({ name: `python:${name}`, ok: isOk, detail: isOk ? detail : 'import failed' });
+        }
+    }
+    for (const bin of expectedBins) {
+        checks.push({ name: bin, ok: false, detail: 'not found' });
+    }
+    for (const pkg of expectedPkgs) {
+        checks.push({ name: `python:${pkg}`, ok: false, detail: 'import failed' });
+    }
+    return { ok: checks.every((c) => c.ok), checks };
+}
+function runBatchedSmokeAsync(distro) {
+    const script = buildSmokeScript();
+    return new Promise((resolve) => {
+        const child = spawn('wsl', ['-d', distro, '--', 'sh', '-c', script], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true
+        });
+        let output = '';
+        let settled = false;
+        child.stdout?.on('data', (chunk) => {
+            output += chunk.toString();
+        });
+        child.stderr?.on('data', (chunk) => {
+            output += chunk.toString();
+        });
+        child.on('error', () => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                resolve(output);
+            }
+        });
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                child.kill();
+                resolve(output);
+            }
+        }, 15_000);
+        child.on('close', () => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                resolve(output);
+            }
+        });
+    });
+}
+//# sourceMappingURL=smoke.js.map