@bike4mind/cli 0.2.29-feat-rate-limit-tracking.18919 → 0.2.29-feat-cli-sandbox.18924

package/dist/BubblewrapRuntime-HSAAHKZN.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import {
+  expandPath,
+  isBinaryAvailable
+} from "./chunk-QJCBARQN.js";
+
+// src/sandbox/runtime/BubblewrapRuntime.ts
+import os from "os";
+var SYSTEM_RO_BINDS = ["/usr", "/bin", "/lib", "/lib64", "/sbin", "/etc"];
+var SPECIAL_MOUNTS = {
+  dev: "/dev",
+  proc: "/proc",
+  tmp: "/tmp"
+};
+var BubblewrapRuntime = class {
+  constructor() {
+    this.platform = "linux";
+    this.name = "bubblewrap";
+  }
+  isAvailable() {
+    return isBinaryAvailable("bwrap");
+  }
+  wrapCommand(options) {
+    const { command, cwd, filesystemConfig, env } = options;
+    const expandedDenied = filesystemConfig.deniedPaths.map(expandPath);
+    const expandedAllowed = filesystemConfig.allowedReadPaths.map(expandPath);
+    const args = [];
+    for (const sysPath of SYSTEM_RO_BINDS) {
+      args.push("--ro-bind-try", sysPath, sysPath);
+    }
+    args.push("--dev", SPECIAL_MOUNTS.dev);
+    args.push("--proc", SPECIAL_MOUNTS.proc);
+    args.push("--tmpfs", SPECIAL_MOUNTS.tmp);
+    args.push("--bind", cwd, cwd);
+    const homeDir = os.homedir();
+    args.push("--ro-bind", homeDir, homeDir);
+    for (const allowedPath of expandedAllowed) {
+      if (!allowedPath.startsWith(homeDir)) {
+        args.push("--ro-bind-try", allowedPath, allowedPath);
+      }
+    }
+    for (const deniedPath of expandedDenied) {
+      args.push("--tmpfs", deniedPath);
+    }
+    args.push("--unshare-all");
+    args.push("--share-net");
+    args.push("--die-with-parent");
+    if (options.seccompProfile) {
+      args.push("--seccomp", options.seccompProfile);
+    }
+    for (const [key, value] of Object.entries(env ?? {})) {
+      args.push("--setenv", key, value);
+    }
+    args.push("--chdir", cwd);
+    args.push("bash", "-c", command);
+    const commandString = ["bwrap", ...args.map(shellEscape)].join(" ");
+    return {
+      executable: "bwrap",
+      args,
+      env: env ?? {},
+      commandString
+    };
+  }
+};
+function shellEscape(str) {
+  if (/^[a-zA-Z0-9._/=:-]+$/.test(str)) return str;
+  return `'${str.replace(/'/g, "'\\''")}'`;
+}
+export {
+  BubblewrapRuntime
+};

package/dist/ProxyManager-4ZZEYTD6.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+
+// src/sandbox/proxy/HttpConnectProxy.ts
+import http from "http";
+import net from "net";
+import { EventEmitter } from "events";
+
+// src/sandbox/proxy/domainMatcher.ts
+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;
+}
+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;
+}
+function isDomainAllowed(domain, allowedDomains) {
+  if (!domain || allowedDomains.length === 0) return false;
+  return allowedDomains.some((pattern) => matchesDomain(domain, pattern));
+}
+
+// src/sandbox/proxy/HttpConnectProxy.ts
+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(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 {
+      const parsed2 = new URL(url);
+      host = parsed2.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);
+  }
+};
+
+// 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);
+  }
+};
+export {
+  ProxyManager
+};

package/dist/SandboxOrchestrator-MYBNKKWL.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_SANDBOX_CONFIG
+} from "./chunk-4BIBE3J7.js";
+
+// 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() ?? {};
+    const 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
+      }
+    });
+    return { type: "sandbox", wrappedCommand };
+  }
+  /** 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 }
+    };
+  }
+  // --- Stats tracking ---
+  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 };
+  }
+  // --- Violation store ---
+  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 trimmed = command.trim();
+    const withoutEnv = trimmed.replace(/^(\w+=\S+\s+)*/, "");
+    const parts = withoutEnv.split(/\s+/);
+    const first = parts[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);
+  }
+};
+export {
+  SandboxOrchestrator
+};

package/dist/SandboxRuntimeAdapter-JERGOSEV.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  createSandboxRuntime,
+  detectPlatform,
+  expandPath,
+  isBinaryAvailable
+} from "./chunk-QJCBARQN.js";
+export {
+  createSandboxRuntime,
+  detectPlatform,
+  expandPath,
+  isBinaryAvailable
+};

package/dist/SeatbeltRuntime-O7DSMFKS.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import {
+  expandPath,
+  isBinaryAvailable
+} from "./chunk-QJCBARQN.js";
+
+// src/sandbox/runtime/SeatbeltRuntime.ts
+import { writeFileSync, mkdtempSync } from "fs";
+import path from "path";
+import os from "os";
+function escapeSeatbeltPath(p) {
+  return p.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+var SeatbeltRuntime = class {
+  constructor() {
+    this.platform = "darwin";
+    this.name = "seatbelt";
+  }
+  isAvailable() {
+    return isBinaryAvailable("sandbox-exec");
+  }
+  /**
+   * Generate a Seatbelt profile string from the filesystem config.
+   *
+   * Strategy:
+   * - Start with (allow default) to permit most operations
+   * - Deny all file writes globally
+   * - Allow file writes only to the working directory
+   * - Deny all access to explicitly denied paths
+   * - Allow read access to explicitly allowed paths
+   */
+  generateProfile(options) {
+    const { cwd, filesystemConfig } = options;
+    const expandedDenied = filesystemConfig.deniedPaths.map(expandPath);
+    const expandedAllowed = filesystemConfig.allowedReadPaths.map(expandPath);
+    const lines = [
+      "(version 1)",
+      "",
+      "; Start with permissive defaults (process exec, network, sysctl, etc.)",
+      "(allow default)",
+      ""
+    ];
+    if (filesystemConfig.writeOnlyToWorkingDir) {
+      lines.push("; Deny all file writes globally");
+      lines.push("(deny file-write*)");
+      lines.push("");
+      lines.push("; Allow writes to working directory");
+      lines.push(`(allow file-write* (subpath "${escapeSeatbeltPath(cwd)}"))`);
+      lines.push("");
+      lines.push("; Allow writes to temp directories");
+      lines.push(`(allow file-write* (subpath "/tmp"))`);
+      lines.push(`(allow file-write* (subpath "/private/tmp"))`);
+      lines.push(`(allow file-write* (subpath "${escapeSeatbeltPath(os.tmpdir())}"))`);
+      lines.push("");
+    }
+    if (expandedDenied.length > 0) {
+      lines.push("; Deny access to sensitive paths");
+      for (const deniedPath of expandedDenied) {
+        lines.push(`(deny file-read* file-write* (subpath "${escapeSeatbeltPath(deniedPath)}"))`);
+      }
+      lines.push("");
+    }
+    if (expandedAllowed.length > 0) {
+      lines.push("; Explicitly allowed read paths");
+      for (const allowedPath of expandedAllowed) {
+        lines.push(`(allow file-read* (subpath "${escapeSeatbeltPath(allowedPath)}"))`);
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  wrapCommand(options) {
+    try {
+      const profile = this.generateProfile(options);
+      const tmpDir = mkdtempSync(path.join(os.tmpdir(), "b4m-sandbox-"));
+      const profilePath = path.join(tmpDir, "sandbox.sb");
+      writeFileSync(profilePath, profile, "utf-8");
+      const args = ["-f", profilePath, "bash", "-c", options.command];
+      const envEntries = Object.entries(options.env ?? {});
+      const envPrefix = envEntries.length > 0 ? envEntries.map(([k, v]) => `${k}=${shellEscape(v)}`).join(" ") + " " : "";
+      return {
+        executable: "sandbox-exec",
+        args,
+        env: options.env ?? {},
+        commandString: `${envPrefix}sandbox-exec -f ${profilePath} bash -c ${shellEscape(options.command)}`,
+        cleanupPaths: [profilePath, tmpDir]
+      };
+    } catch (err) {
+      throw new Error(`Failed to create sandbox profile: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+};
+function shellEscape(str) {
+  return `'${str.replace(/'/g, "'\\''")}'`;
+}
+export {
+  SeatbeltRuntime
+};

package/dist/StderrViolationParser-7OYPM2DJ.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+// src/sandbox/logging/StderrViolationParser.ts
+function parseSeatbeltStderr(stderr) {
+  const violations = [];
+  const regex = /sandbox-exec:\s*deny\(\d+\)\s+(\S+)\s+(.+)/g;
+  let match;
+  while ((match = regex.exec(stderr)) !== null) {
+    const operation = match[1];
+    const targetPath = match[2].trim();
+    const type = classifySeatbeltOperation(operation);
+    violations.push({
+      type,
+      operation,
+      path: type === "filesystem" ? targetPath : void 0,
+      detail: match[0]
+    });
+  }
+  return violations;
+}
+function parseBwrapStderr(stderr) {
+  const violations = [];
+  const regex = /bwrap:\s+(.+)/g;
+  let match;
+  while ((match = regex.exec(stderr)) !== null) {
+    const message = match[1].trim();
+    const pathMatch = message.match(/(?:Can't open file |Can't bind mount )(\S+)/);
+    const extractedPath = pathMatch?.[1]?.replace(/:$/, "");
+    violations.push({
+      type: "filesystem",
+      path: extractedPath,
+      detail: match[0]
+    });
+  }
+  return violations;
+}
+function parseSandboxStderr(stderr) {
+  return [...parseSeatbeltStderr(stderr), ...parseBwrapStderr(stderr)];
+}
+function toSandboxViolations(parsed, command) {
+  return parsed.map((p) => ({
+    type: p.type,
+    path: p.path,
+    command,
+    blockedBy: "sandbox",
+    timestamp: /* @__PURE__ */ new Date(),
+    detail: p.detail
+  }));
+}
+function classifySeatbeltOperation(operation) {
+  if (operation.startsWith("network")) return "network";
+  return "filesystem";
+}
+export {
+  parseBwrapStderr,
+  parseSandboxStderr,
+  parseSeatbeltStderr,
+  toSandboxViolations
+};