@bike4mind/cli 0.2.64-worktree-refactor-extract-search-query-builders.21815 → 0.2.64

package/dist/ImageStore-DaKT_Ew8.mjs

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { extname, join, resolve } from "path";
+import Database from "better-sqlite3";
+import sharp from "sharp";
+//#region src/storage/ImageStore.ts
+/**
+* Local image cache for CLI
+* Stores pasted/dropped images before upload to S3
+*/
+var ImageStore = class ImageStore {
+	static {
+		this.BASE_DIR = join(homedir(), ".bike4mind", "cli");
+	}
+	static {
+		this.IMAGES_DIR = join(ImageStore.BASE_DIR, "images");
+	}
+	static {
+		this.DB_PATH = join(ImageStore.BASE_DIR, "images.db");
+	}
+	static {
+		this.RETENTION_DAYS = 7;
+	}
+	static {
+		this.MAX_RAW_SIZE = 750 * 1024;
+	}
+	static {
+		this.MAX_PRECOMPRESS_SIZE = 50 * 1024 * 1024;
+	}
+	constructor() {
+		this.ensureDirectories();
+		this.db = new Database(ImageStore.DB_PATH);
+		this.initDatabase();
+		try {
+			this.cleanupOldImages();
+		} catch (err) {
+			console.warn("Failed to cleanup old images:", err);
+		}
+	}
+	ensureDirectories() {
+		mkdirSync(ImageStore.BASE_DIR, { recursive: true });
+		mkdirSync(ImageStore.IMAGES_DIR, { recursive: true });
+	}
+	initDatabase() {
+		this.db.exec(`
+			CREATE TABLE IF NOT EXISTS images (
+				hash TEXT PRIMARY KEY,
+				format TEXT NOT NULL,
+				size INTEGER NOT NULL,
+				timestamp INTEGER NOT NULL,
+				uploaded INTEGER NOT NULL DEFAULT 0,
+				s3_url TEXT,
+				original_filename TEXT
+			)
+		`);
+	}
+	/**
+	* Store an image locally with content-based hashing for deduplication
+	*/
+	async store(imageData, originalFilename) {
+		const { buffer: processedData, format: processedFormat } = await this.processImage(imageData, originalFilename);
+		const hash = this.generateHash(processedData);
+		const format = processedFormat;
+		const ext = format.toLowerCase();
+		const localPath = join(ImageStore.IMAGES_DIR, `${hash}.${ext}`);
+		const existing = this.getMetadata(hash);
+		if (existing) return {
+			hash,
+			placeholder: "",
+			localPath,
+			metadata: existing
+		};
+		writeFileSync(localPath, processedData);
+		const metadata = {
+			hash,
+			format,
+			size: processedData.length,
+			timestamp: Date.now(),
+			uploaded: false,
+			originalFilename
+		};
+		this.db.prepare(`INSERT INTO images (hash, format, size, timestamp, uploaded, original_filename)
+				 VALUES (?, ?, ?, ?, ?, ?)`).run(hash, format, metadata.size, metadata.timestamp, 0, originalFilename || null);
+		return {
+			hash,
+			placeholder: "",
+			localPath,
+			metadata
+		};
+	}
+	/**
+	* Get image metadata by hash
+	*/
+	getMetadata(hash) {
+		const row = this.db.prepare("SELECT * FROM images WHERE hash = ?").get(hash);
+		if (!row) return null;
+		return {
+			hash: row.hash,
+			format: row.format,
+			size: row.size,
+			timestamp: row.timestamp,
+			uploaded: Boolean(row.uploaded),
+			s3Url: row.s3_url,
+			originalFilename: row.original_filename
+		};
+	}
+	/**
+	* Read image data from local cache
+	*/
+	readImage(hash) {
+		const metadata = this.getMetadata(hash);
+		if (!metadata) return null;
+		const localPath = join(ImageStore.IMAGES_DIR, `${hash}.${metadata.format.toLowerCase()}`);
+		if (!resolve(localPath).startsWith(resolve(ImageStore.IMAGES_DIR))) throw new Error("Invalid image path");
+		if (!existsSync(localPath)) return null;
+		return readFileSync(localPath);
+	}
+	/**
+	* Generate content hash for deduplication
+	*/
+	generateHash(data) {
+		return createHash("sha256").update(data).digest("hex").substring(0, 16);
+	}
+	/**
+	* Process image: compress if needed to stay under size limit
+	*/
+	async processImage(data, originalFilename) {
+		if (data.length > ImageStore.MAX_PRECOMPRESS_SIZE) throw new Error(`Image too large to process (${Math.round(data.length / 1024 / 1024)}MB). Maximum size is ${ImageStore.MAX_PRECOMPRESS_SIZE / 1024 / 1024}MB.`);
+		const originalFormat = this.detectFormat(data, originalFilename);
+		if (data.length <= ImageStore.MAX_RAW_SIZE) return {
+			buffer: data,
+			format: originalFormat
+		};
+		let image = sharp(data);
+		const metadata = await image.metadata();
+		if (!metadata.width || !metadata.height) throw new Error("Unable to read image dimensions");
+		const maxDimension = 2048;
+		let width = metadata.width;
+		let height = metadata.height;
+		if (width > maxDimension || height > maxDimension) if (width > height) {
+			height = Math.round(height * maxDimension / width);
+			width = maxDimension;
+		} else {
+			width = Math.round(width * maxDimension / height);
+			height = maxDimension;
+		}
+		image = image.resize(width, height);
+		let quality = 85;
+		let buffer = await image.jpeg({ quality }).toBuffer();
+		while (buffer.length > ImageStore.MAX_RAW_SIZE && quality > 30) {
+			quality -= 10;
+			buffer = await image.jpeg({ quality }).toBuffer();
+		}
+		if (buffer.length > ImageStore.MAX_RAW_SIZE) throw new Error(`Unable to compress image below ${ImageStore.MAX_RAW_SIZE / 1024}KB limit`);
+		return {
+			buffer,
+			format: "jpg"
+		};
+	}
+	/**
+	* Detect image format from buffer or filename
+	*/
+	detectFormat(data, filename) {
+		if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) return "png";
+		if (data[0] === 255 && data[1] === 216 && data[2] === 255) return "jpg";
+		if (data[0] === 71 && data[1] === 73 && data[2] === 70) return "gif";
+		if (data[0] === 82 && data[1] === 73 && data[2] === 70 && data[3] === 70) return "webp";
+		if (filename) {
+			const ext = extname(filename).substring(1).toLowerCase();
+			if ([
+				"png",
+				"jpg",
+				"jpeg",
+				"gif",
+				"webp"
+			].includes(ext)) return ext === "jpeg" ? "jpg" : ext;
+		}
+		return "png";
+	}
+	/**
+	* Clean up images older than retention period
+	*/
+	cleanupOldImages() {
+		const cutoffTime = Date.now() - ImageStore.RETENTION_DAYS * 24 * 60 * 60 * 1e3;
+		const oldImages = this.db.prepare("SELECT hash, format FROM images WHERE timestamp < ?").all(cutoffTime);
+		for (const { hash, format } of oldImages) {
+			const localPath = join(ImageStore.IMAGES_DIR, `${hash}.${format.toLowerCase()}`);
+			if (existsSync(localPath)) unlinkSync(localPath);
+		}
+		this.db.prepare("DELETE FROM images WHERE timestamp < ?").run(cutoffTime);
+	}
+	/**
+	* Close database connection
+	*/
+	close() {
+		this.db.close();
+	}
+};
+//#endregion
+export { ImageStore };

package/dist/ProxyManager-Dl2nFk-A.mjs

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+import { EventEmitter } from "events";
+import http from "http";
+import net from "net";
+//#region src/sandbox/proxy/domainMatcher.ts
+/**
+* Domain matching utilities for the network proxy allowlist.
+* Pure functions, zero dependencies.
+*/
+/**
+* Normalize a domain for comparison: lowercase, strip port, strip trailing dot.
+*/
+function normalizeDomain(domain) {
+	let d = domain.toLowerCase().trim();
+	const colonIdx = d.lastIndexOf(":");
+	if (colonIdx > 0) {
+		const afterColon = d.slice(colonIdx + 1);
+		if (/^\d+$/.test(afterColon)) d = d.slice(0, colonIdx);
+	}
+	if (d.endsWith(".")) d = d.slice(0, -1);
+	return d;
+}
+/**
+* Check if a domain matches a pattern.
+* - Exact match: "github.com" matches "github.com"
+* - Wildcard: "*.github.com" matches "api.github.com" but NOT "github.com"
+*/
+function matchesDomain(domain, pattern) {
+	const d = normalizeDomain(domain);
+	const p = normalizeDomain(pattern);
+	if (d === p) return true;
+	if (p.startsWith("*.")) {
+		const suffix = p.slice(1);
+		return d.endsWith(suffix) && d.length > suffix.length;
+	}
+	return false;
+}
+/**
+* Check if a domain is in the allowed list.
+*/
+function isDomainAllowed(domain, allowedDomains) {
+	if (!domain || allowedDomains.length === 0) return false;
+	return allowedDomains.some((pattern) => matchesDomain(domain, pattern));
+}
+//#endregion
+//#region src/sandbox/proxy/HttpConnectProxy.ts
+/**
+* HTTP CONNECT proxy for network domain filtering.
+*
+* Intercepts outbound HTTP/HTTPS connections from sandboxed commands
+* and filters by domain allowlist. Uses only Node.js built-ins.
+*
+* - CONNECT handler (HTTPS): Parse domain → check allowlist → tunnel or 403
+* - HTTP handler (forward proxy): Parse host → check allowlist → forward or 403
+*/
+var HttpConnectProxy = class extends EventEmitter {
+	constructor(options) {
+		super();
+		this.server = null;
+		this.activeSockets = /* @__PURE__ */ new Set();
+		this.allowedDomains = [...options.allowedDomains];
+		this.requestedPort = options.port ?? 0;
+	}
+	async start() {
+		if (this.server) throw new Error("Proxy is already running");
+		return new Promise((resolve, reject) => {
+			const server = http.createServer((req, res) => {
+				this.handleHttpRequest(req, res);
+			});
+			server.on("connect", (req, clientSocket, head) => {
+				this.handleConnect(req, clientSocket, head);
+			});
+			server.on("connection", (socket) => {
+				this.activeSockets.add(socket);
+				socket.on("close", () => this.activeSockets.delete(socket));
+			});
+			server.on("error", reject);
+			server.listen(this.requestedPort, "127.0.0.1", () => {
+				const addr = server.address();
+				if (!addr || typeof addr === "string") {
+					reject(/* @__PURE__ */ new Error("Failed to get server address"));
+					return;
+				}
+				this.server = server;
+				resolve(addr.port);
+			});
+		});
+	}
+	async stop() {
+		if (!this.server) return;
+		for (const socket of this.activeSockets) socket.destroy();
+		this.activeSockets.clear();
+		return new Promise((resolve, reject) => {
+			this.server.close((err) => {
+				this.server = null;
+				if (err) reject(err);
+				else resolve();
+			});
+		});
+	}
+	updateAllowedDomains(domains) {
+		this.allowedDomains = [...domains];
+	}
+	getPort() {
+		if (!this.server) return null;
+		const addr = this.server.address();
+		if (!addr || typeof addr === "string") return null;
+		return addr.port;
+	}
+	isRunning() {
+		return this.server !== null;
+	}
+	emitEvent(type, domain, method) {
+		const event = {
+			type,
+			domain,
+			method,
+			timestamp: /* @__PURE__ */ new Date()
+		};
+		this.emit("proxy-event", event);
+	}
+	/**
+	* Handle CONNECT requests (HTTPS tunneling).
+	*/
+	handleConnect(req, clientSocket, head) {
+		const target = req.url || "";
+		const [host] = target.split(":");
+		const port = parseInt(target.split(":")[1] || "443", 10);
+		if (!isDomainAllowed(host, this.allowedDomains)) {
+			this.emitEvent("blocked", host, "CONNECT");
+			clientSocket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
+			clientSocket.end();
+			return;
+		}
+		this.emitEvent("allowed", host, "CONNECT");
+		const serverSocket = net.connect(port, host, () => {
+			clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+			if (head.length > 0) serverSocket.write(head);
+			serverSocket.pipe(clientSocket);
+			clientSocket.pipe(serverSocket);
+		});
+		serverSocket.setTimeout(5e3, () => {
+			serverSocket.destroy();
+			clientSocket.write("HTTP/1.1 504 Gateway Timeout\r\n\r\n");
+			clientSocket.end();
+		});
+		serverSocket.on("error", () => {
+			clientSocket.write("HTTP/1.1 502 Bad Gateway\r\n\r\n");
+			clientSocket.end();
+		});
+		clientSocket.on("error", () => {
+			serverSocket.destroy();
+		});
+	}
+	/**
+	* Handle plain HTTP forward proxy requests.
+	*/
+	handleHttpRequest(req, res) {
+		const url = req.url || "";
+		let host;
+		try {
+			host = new URL(url).hostname;
+		} catch {
+			host = (req.headers.host || "").split(":")[0];
+		}
+		if (!host || !isDomainAllowed(host, this.allowedDomains)) {
+			this.emitEvent("blocked", host || "unknown", req.method || "GET");
+			res.writeHead(403, { "Content-Type": "text/plain" });
+			res.end("Blocked by sandbox network proxy");
+			return;
+		}
+		this.emitEvent("allowed", host, req.method || "GET");
+		const parsed = new URL(url);
+		const proxyReq = http.request({
+			hostname: parsed.hostname,
+			port: parsed.port || 80,
+			path: parsed.pathname + parsed.search,
+			method: req.method,
+			headers: req.headers
+		}, (proxyRes) => {
+			res.writeHead(proxyRes.statusCode || 502, proxyRes.headers);
+			proxyRes.pipe(res);
+		});
+		proxyReq.on("error", () => {
+			res.writeHead(502, { "Content-Type": "text/plain" });
+			res.end("Bad Gateway");
+		});
+		req.pipe(proxyReq);
+	}
+};
+//#endregion
+//#region src/sandbox/proxy/ProxyManager.ts
+var ProxyManager = class {
+	constructor(networkConfig) {
+		this.proxy = null;
+		this.eventHandlers = /* @__PURE__ */ new Set();
+		this.networkConfig = {
+			...networkConfig,
+			allowedDomains: [...networkConfig.allowedDomains]
+		};
+	}
+	async start() {
+		if (!this.networkConfig.enabled) return;
+		if (this.proxy?.isRunning()) return;
+		this.proxy = new HttpConnectProxy({ allowedDomains: this.networkConfig.allowedDomains });
+		this.proxy.on("proxy-event", (event) => {
+			for (const handler of this.eventHandlers) handler(event);
+		});
+		await this.proxy.start();
+	}
+	async stop() {
+		if (!this.proxy) return;
+		await this.proxy.stop();
+		this.proxy = null;
+	}
+	/**
+	* Get proxy env vars for injecting into sandboxed processes.
+	* Returns both upper and lowercase variants for maximum compatibility.
+	*/
+	getProxyEnv() {
+		if (!this.proxy?.isRunning()) return {};
+		const port = this.proxy.getPort();
+		if (!port) return {};
+		const proxyUrl = `http://127.0.0.1:${port}`;
+		const noProxy = "localhost,127.0.0.1,::1";
+		return {
+			HTTP_PROXY: proxyUrl,
+			http_proxy: proxyUrl,
+			HTTPS_PROXY: proxyUrl,
+			https_proxy: proxyUrl,
+			NO_PROXY: noProxy,
+			no_proxy: noProxy
+		};
+	}
+	addAllowedDomain(domain) {
+		if (!this.networkConfig.allowedDomains.includes(domain)) {
+			this.networkConfig.allowedDomains.push(domain);
+			this.proxy?.updateAllowedDomains(this.networkConfig.allowedDomains);
+		}
+	}
+	getAllowedDomains() {
+		return [...this.networkConfig.allowedDomains];
+	}
+	isRunning() {
+		return this.proxy?.isRunning() ?? false;
+	}
+	getPort() {
+		return this.proxy?.getPort() ?? null;
+	}
+	/**
+	* Subscribe to proxy events. Returns an unsubscribe function.
+	*/
+	onEvent(handler) {
+		this.eventHandlers.add(handler);
+		return () => this.eventHandlers.delete(handler);
+	}
+};
+//#endregion
+export { ProxyManager as t };

package/dist/ProxyManager-kiOD1X8-.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { t as ProxyManager } from "./ProxyManager-Dl2nFk-A.mjs";
+export { ProxyManager };

package/dist/SandboxOrchestrator-BEW3rqYi.mjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+import { t as DEFAULT_SANDBOX_CONFIG } from "./types-DBEjF9YS.mjs";
+//#region src/sandbox/SandboxOrchestrator.ts
+var SandboxOrchestrator = class {
+	constructor(config, runtime, proxyManager) {
+		this.stats = {
+			sandboxed: 0,
+			unsandboxed: 0,
+			blocked: 0,
+			violations: 0
+		};
+		this.violationStore = null;
+		this.config = config ?? DEFAULT_SANDBOX_CONFIG;
+		this.runtime = runtime ?? null;
+		this.proxyManager = proxyManager ?? null;
+	}
+	/**
+	* Determine whether a command should be sandboxed.
+	*
+	* Decision logic:
+	* 1. If sandbox is disabled → unsandboxed (no permission change)
+	* 2. If command matches an excluded command → unsandboxed (requires permission)
+	* 3. If runtime is not available → unsandboxed with warning
+	* 4. Otherwise → sandbox the command
+	*/
+	shouldSandbox(command, cwd) {
+		if (!this.config.enabled || this.config.mode === "disabled") return {
+			type: "unsandboxed",
+			requiresPermission: true
+		};
+		const baseCommand = this.getBaseCommand(command);
+		if (this.isExcludedCommand(baseCommand)) {
+			if (!this.config.allowUnsandboxedCommands) return {
+				type: "blocked",
+				reason: `Command '${baseCommand}' is excluded from sandboxing and unsandboxed commands are not allowed`
+			};
+			return {
+				type: "unsandboxed",
+				requiresPermission: true,
+				reason: `Command '${baseCommand}' is excluded from sandboxing`
+			};
+		}
+		if (!this.runtime) return {
+			type: "unsandboxed",
+			requiresPermission: true,
+			reason: "Sandbox runtime not available on this platform"
+		};
+		const proxyEnv = this.proxyManager?.getProxyEnv() ?? {};
+		return {
+			type: "sandbox",
+			wrappedCommand: this.runtime.wrapCommand({
+				command,
+				cwd,
+				filesystemConfig: this.config.filesystem,
+				env: proxyEnv,
+				...this.runtime.platform === "linux" && this.config.platform.linux.seccompProfile && { seccompProfile: this.config.platform.linux.seccompProfile }
+			})
+		};
+	}
+	/** Get the current sandbox mode */
+	getMode() {
+		return this.config.mode;
+	}
+	/** Set the sandbox mode (does not persist — caller must save config) */
+	setMode(mode) {
+		this.config.mode = mode;
+		this.config.enabled = mode !== "disabled";
+	}
+	/** Check if sandbox is enabled and runtime is available */
+	isAvailable() {
+		return this.runtime !== null && this.runtime.isAvailable();
+	}
+	/** Check if sandbox is currently active (enabled + available) */
+	isActive() {
+		return this.config.enabled && this.config.mode !== "disabled" && this.isAvailable();
+	}
+	/** Get the current sandbox configuration */
+	getConfig() {
+		return this.config;
+	}
+	/** Update config (does not persist — caller must save) */
+	updateConfig(config) {
+		this.config = config;
+	}
+	/** Get the ProxyManager instance (if any) */
+	getProxyManager() {
+		return this.proxyManager;
+	}
+	/** Start the network proxy (if configured) */
+	async startProxy() {
+		await this.proxyManager?.start();
+	}
+	/** Stop the network proxy */
+	async stopProxy() {
+		await this.proxyManager?.stop();
+	}
+	/** Get full status information for display */
+	getStatus() {
+		return {
+			mode: this.config.mode,
+			enabled: this.config.enabled,
+			platform: this.runtime?.platform ?? null,
+			runtimeAvailable: this.runtime?.isAvailable() ?? false,
+			runtimeName: this.runtime?.name ?? null,
+			proxyRunning: this.proxyManager?.isRunning() ?? false,
+			proxyPort: this.proxyManager?.getPort() ?? null,
+			config: this.config,
+			stats: { ...this.stats }
+		};
+	}
+	recordSandboxed() {
+		this.stats.sandboxed++;
+	}
+	recordUnsandboxed() {
+		this.stats.unsandboxed++;
+	}
+	recordBlocked() {
+		this.stats.blocked++;
+	}
+	recordViolations(count = 1) {
+		this.stats.violations += count;
+	}
+	getStats() {
+		return { ...this.stats };
+	}
+	resetStats() {
+		this.stats = {
+			sandboxed: 0,
+			unsandboxed: 0,
+			blocked: 0,
+			violations: 0
+		};
+	}
+	setViolationStore(store) {
+		this.violationStore = store;
+	}
+	getViolationStore() {
+		return this.violationStore;
+	}
+	/** Record a violation to store and increment stats */
+	async recordViolation(violation) {
+		this.stats.violations++;
+		await this.violationStore?.record(violation).catch(() => {});
+	}
+	/**
+	* Extract the base command name from a full command string.
+	* e.g., "docker compose up -d" → "docker"
+	*/
+	getBaseCommand(command) {
+		const first = command.trim().replace(/^(\w+=\S+\s+)*/, "").split(/\s+/)[0] || "";
+		return first.split("/").pop() || first;
+	}
+	/** Check if a command is in the excluded list */
+	isExcludedCommand(baseCommand) {
+		return this.config.excludedCommands.some((excluded) => baseCommand === excluded);
+	}
+};
+//#endregion
+export { SandboxOrchestrator as t };

package/dist/SandboxOrchestrator-CHZgSR3P.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { t as SandboxOrchestrator } from "./SandboxOrchestrator-BEW3rqYi.mjs";
+export { SandboxOrchestrator };

package/dist/SandboxRuntimeAdapter-C1B4t20N.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import { accessSync, constants } from "fs";
+import os from "os";
+import path from "path";
+//#region src/sandbox/runtime/SandboxRuntimeAdapter.ts
+/**
+* Abstract sandbox runtime adapter with platform detection and factory.
+*/
+/**
+* Detect the current platform.
+* Returns null if the platform is not supported for sandboxing.
+*/
+function detectPlatform() {
+	const platform = os.platform();
+	if (platform === "darwin") return "darwin";
+	if (platform === "linux") return "linux";
+	return null;
+}
+/**
+* Check if a binary exists on the system PATH.
+* Uses pure filesystem checks instead of shell execution to avoid command injection.
+*/
+function isBinaryAvailable(binary) {
+	const pathDirs = (process.env.PATH || "").split(path.delimiter);
+	for (const dir of pathDirs) try {
+		accessSync(path.join(dir, binary), constants.X_OK);
+		return true;
+	} catch {}
+	return false;
+}
+/**
+* Expand environment variables ($HOME, $USER) in a path string.
+*/
+function expandPath(pathStr) {
+	return pathStr.replace(/\$HOME/g, os.homedir()).replace(/\$USER/g, os.userInfo().username).replace(/~\//g, `${os.homedir()}/`);
+}
+/**
+* Factory function to create the appropriate sandbox runtime for the current platform.
+* Returns null if the platform is unsupported or the runtime binary is not available.
+*/
+async function createSandboxRuntime() {
+	const platform = detectPlatform();
+	if (!platform) return null;
+	if (platform === "darwin") {
+		const { SeatbeltRuntime } = await import("./SeatbeltRuntime-D4m0VOcD.mjs");
+		const runtime = new SeatbeltRuntime();
+		return runtime.isAvailable() ? runtime : null;
+	}
+	if (platform === "linux") {
+		const { BubblewrapRuntime } = await import("./BubblewrapRuntime-BHbtqvLx.mjs");
+		const runtime = new BubblewrapRuntime();
+		return runtime.isAvailable() ? runtime : null;
+	}
+	return null;
+}
+//#endregion
+export { isBinaryAvailable as i, detectPlatform as n, expandPath as r, createSandboxRuntime as t };

package/dist/SandboxRuntimeAdapter-D7UAG13n.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { i as isBinaryAvailable, n as detectPlatform, r as expandPath, t as createSandboxRuntime } from "./SandboxRuntimeAdapter-C1B4t20N.mjs";
+export { createSandboxRuntime, detectPlatform, expandPath, isBinaryAvailable };