sandboxbox 1.2.1 → 2.0.0

package/lib/bubblewrap.js

@@ -1,203 +0,0 @@
-/**
- * Portable bubblewrap binary manager
- * Handles bundled, system, and downloaded bubblewrap binaries
- */
-
-import fs from 'fs';
-import path from 'path';
-import https from 'https';
-import { execSync } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-export class BubblewrapManager {
-  constructor() {
-    this.bwrapPath = null;
-    this.alpineRoot = path.join(
-      process.env.HOME || process.env.USERPROFILE,
-      '.cache',
-      'sandboxbox',
-      'alpine-root'
-    );
-  }
-
-  /**
-   * Find bubblewrap binary in this order:
-   * 1. Bundled binary (downloaded during npm install)
-   * 2. System binary
-   * 3. Throw error with helpful message
-   */
-  findBubblewrap() {
-    if (this.bwrapPath) {
-      return this.bwrapPath;
-    }
-
-    // Try bundled binary first
-    const bundledPath = path.join(__dirname, '..', 'bin', 'bwrap');
-    if (fs.existsSync(bundledPath)) {
-      try {
-        // Test if it works
-        execSync(`"${bundledPath}" --version`, { stdio: 'ignore' });
-        this.bwrapPath = bundledPath;
-        console.log('✅ Using bundled bubblewrap');
-        return this.bwrapPath;
-      } catch (e) {
-        console.log('⚠️  Bundled bubblewrap not working, falling back to system...');
-      }
-    }
-
-    // Try system binary
-    try {
-      const systemBwrap = execSync('which bwrap', { encoding: 'utf8' }).trim();
-      if (systemBwrap && fs.existsSync(systemBwrap)) {
-        execSync(`"${systemBwrap}" --version`, { stdio: 'ignore' });
-        this.bwrapPath = systemBwrap;
-        console.log('✅ Using system bubblewrap');
-        return this.bwrapPath;
-      }
-    } catch (e) {
-      // System bwrap not available
-    }
-
-    // No bubblewrap found
-    throw new Error(`
-❌ Bubblewrap not found!
-
-💡 Easy fixes:
-1. Reinstall SandboxBox: npm uninstall sandboxbox && npm install sandboxbox
-2. Install system-wide: sudo apt-get install bubblewrap
-3. Install manually: https://github.com/containers/bubblewrap
-
-📦 SandboxBox works on Linux only and requires bubblewrap for container isolation.
-`);
-  }
-
-  /**
-   * Check if bubblewrap is available
-   */
-  isAvailable() {
-    try {
-      this.findBubblewrap();
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-
-  /**
-   * Get bubblewrap version
-   */
-  getVersion() {
-    try {
-      const bwrapPath = this.findBubblewrap();
-      const version = execSync(`"${bwrapPath}" --version`, { encoding: 'utf8' });
-      return version.trim();
-    } catch (e) {
-      return 'Unknown';
-    }
-  }
-
-  /**
-   * Check if user namespaces are available
-   */
-  checkUserNamespaces() {
-    try {
-      // Try to create a user namespace
-      execSync('unshare -U true', { stdio: 'ignore' });
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-
-  /**
-   * Setup Alpine Linux rootfs if needed
-   */
-  async ensureAlpineRoot() {
-    if (fs.existsSync(path.join(this.alpineRoot, 'bin', 'sh'))) {
-      return; // Already set up
-    }
-
-    console.log('🏔️  Setting up Alpine Linux environment...');
-
-    fs.mkdirSync(this.alpineRoot, { recursive: true });
-
-    // Download Alpine minirootfs
-    const alpineVersion = '3.20.2';
-    const arch = process.arch === 'x64' ? 'x86_64' : process.arch;
-    const tarball = `alpine-minirootfs-${alpineVersion}-${arch}.tar.gz`;
-    const tarballPath = path.join(this.alpineRoot, tarball);
-
-    console.log('📥 Downloading Alpine Linux...');
-    const url = `https://dl-cdn.alpinelinux.org/alpine/v3.20/releases/${arch}/${tarball}`;
-
-    await new Promise((resolve, reject) => {
-      const file = fs.createWriteStream(tarballPath);
-
-      https.get(url, (response) => {
-        if (response.statusCode !== 200) {
-          reject(new Error(`HTTP ${response.statusCode}`));
-          return;
-        }
-
-        response.pipe(file);
-
-        file.on('finish', () => {
-          file.close();
-          resolve();
-        });
-      }).on('error', reject);
-    });
-
-    // Extract Alpine
-    console.log('📦 Extracting Alpine rootfs...');
-    execSync(`tar -xzf "${tarballPath}" -C "${this.alpineRoot}"`, { stdio: 'inherit' });
-    fs.unlinkSync(tarballPath);
-
-    // Install basic packages
-    console.log('🔧 Installing Node.js and Chromium...');
-    const bwrapPath = this.findBubblewrap();
-
-    execSync(`
-      "${bwrapPath}" \\
-        --ro-bind "${this.alpineRoot}" / \\
-        --proc /proc \\
-        --dev /dev \\
-        --tmpfs /tmp \\
-        --share-net \\
-        --die-with-parent \\
-        /bin/sh -c "
-          echo 'https://dl-cdn.alpinelinux.org/alpine/v3.20/main' > /etc/apk/repositories
-          echo 'https://dl-cdn.alpinelinux.org/alpine/v3.20/community' >> /etc/apk/repositories
-          apk update
-          apk add --no-cache nodejs npm chromium nss freetype harfbuzz ttf-freefont xvfb mesa-gl libx11 libxrandr libxss
-          echo '✅ Alpine setup complete'
-        "
-    `, { stdio: 'inherit' });
-
-    console.log('✅ Alpine Linux environment ready!');
-  }
-
-  /**
-   * Get Alpine root path
-   */
-  getAlpineRoot() {
-    return this.alpineRoot;
-  }
-
-  /**
-   * Cleanup cached files
-   */
-  cleanup() {
-    if (fs.existsSync(this.alpineRoot)) {
-      fs.rmSync(this.alpineRoot, { recursive: true, force: true });
-      console.log('🧹 Cleaned up Alpine cache');
-    }
-  }
-}
-
-// Export singleton instance
-export const bubblewrap = new BubblewrapManager();

package/playwright.sh

@@ -1,183 +0,0 @@
-#!/bin/bash
-
-# Playwright Bubblewrap Wrapper Script
-# Addresses all Alpine/Playwright compatibility issues
-
-set -e
-
-# Configuration
-PROJECT_DIR="${1:-$(pwd)}"
-ALPINE_ROOT="$HOME/.bubblewrap-sandbox/alpine-playwright"
-COMMAND="${2:-npx playwright test}"
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-echo -e "${BLUE}🎭 Playwright + Bubblewrap Container Runner${NC}"
-echo -e "${BLUE}═════════════════════════════════════════════════════${NC}\n"
-
-# Check if bubblewrap is available
-if ! command -v bwrap &> /dev/null; then
-    echo -e "${RED}❌ Bubblewrap (bwrap) not found!${NC}"
-    echo -e "${YELLOW}📦 Install bubblewrap:${NC}"
-    echo -e "   Ubuntu/Debian:  sudo apt-get install bubblewrap"
-    echo -e "   Alpine:         sudo apk add bubblewrap"
-    echo -e "   CentOS/RHEL:    sudo yum install bubblewrap"
-    echo -e "   Arch:           sudo pacman -S bubblewrap"
-    echo ""
-    echo -e "${GREEN}✅ After installation, no root privileges required!${NC}"
-    exit 1
-fi
-
-echo -e "${GREEN}✅ Bubblewrap found: $(which bwrap)${NC}"
-
-# First-time setup
-if [ ! -d "$ALPINE_ROOT" ]; then
-    echo -e "${YELLOW}🏔️  Setting up Alpine Linux rootfs for Playwright...${NC}"
-    mkdir -p "$ALPINE_ROOT"
-    cd "$ALPINE_ROOT"
-
-    # Download Alpine minirootfs
-    ALPINE_VERSION="3.20.2"
-    ARCH="x86_64"
-    TARBALL="alpine-minirootfs-${ALPINE_VERSION}-${ARCH}.tar.gz"
-
-    if [ ! -f "$TARBALL" ]; then
-        echo -e "${BLUE}📥 Downloading Alpine Linux...${NC}"
-        wget -q "https://dl-cdn.alpinelinux.org/alpine/v3.20/releases/${ARCH}/${TARBALL}"
-    fi
-
-    # Extract
-    echo -e "${BLUE}📦 Extracting Alpine rootfs...${NC}"
-    tar -xzf "$TARBALL"
-
-    # Setup Alpine with Playwright packages
-    echo -e "${BLUE}🔧 Installing Playwright dependencies in Alpine...${NC}"
-    bwrap \
-        --ro-bind "$ALPINE_ROOT" / \
-        --proc /proc \
-        --dev /dev \
-        --tmpfs /tmp \
-        --share-net \
-        --die-with-parent \
-        /bin/sh -c "
-            echo 'https://dl-cdn.alpinelinux.org/alpine/v3.20/main' > /etc/apk/repositories
-            echo 'https://dl-cdn.alpinelinux.org/alpine/v3.20/community' >> /etc/apk/repositories
-            apk update
-            apk add --no-cache \\
-                nodejs \\
-                npm \\
-                chromium \\
-                nss \\
-                freetype \\
-                harfbuzz \\
-                ttf-freefont \\
-                xvfb \\
-                mesa-gl \\
-                libx11 \\
-                libxrandr \\
-                libxss \\
-                bash \\
-                ca-certificates
-            npm install -g @anthropic-ai/claude-code
-            echo '✅ Alpine setup complete'
-        " || {
-            echo -e "${RED}❌ Alpine setup failed${NC}"
-            exit 1
-        }
-
-    # Create Playwright config
-    cat > "$ALPINE_ROOT/playwright.config.js" << 'EOF'
-export default defineConfig({
-  use: {
-    chromiumSandbox: false,
-    headless: true,
-    executablePath: '/usr/bin/chromium-browser',
-  },
-  projects: [
-    {
-      name: 'chromium',
-      use: {
-        executablePath: '/usr/bin/chromium-browser',
-      },
-    },
-  ],
-});
-EOF
-
-    echo -e "${GREEN}✅ Alpine setup complete!${NC}"
-fi
-
-# Verify project directory
-if [ ! -d "$PROJECT_DIR" ]; then
-    echo -e "${RED}❌ Project directory not found: $PROJECT_DIR${NC}"
-    exit 1
-fi
-
-echo -e "${BLUE}📁 Project directory: $PROJECT_DIR${NC}"
-echo -e "${BLUE}🎯 Command: $COMMAND${NC}"
-echo ""
-
-# Run Playwright in bubblewrap sandbox
-echo -e "${GREEN}🚀 Starting Playwright in bubblewrap sandbox...${NC}"
-
-bwrap \
-    --ro-bind "$ALPINE_ROOT" / \
-    --proc /proc \
-    --dev /dev \
-    --dev-bind /dev/dri /dev/dri \
-    --tmpfs /tmp \
-    --tmpfs /var/tmp \
-    --tmpfs /run \
-    --tmpfs /dev/shm \
-    --bind "$PROJECT_DIR" /workspace \
-    --chdir /workspace \
-    --bind /tmp/.X11-unix /tmp/.X11-unix \
-    --share-net \
-    --unshare-pid \
-    --unshare-ipc \
-    --unshare-uts \
-    --die-with-parent \
-    --new-session \
-    --as-pid-1 \
-    --hostname playwright-sandbox \
-    --setenv PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 \
-    --setenv PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH=/usr/bin/chromium-browser \
-    --setenv DISPLAY=:99 \
-    --setenv CI=true \
-    --setenv NODE_ENV=test \
-    --setenv CHROMIUM_FLAGS="--no-sandbox --disable-dev-shm-usage --disable-gpu" \
-    /bin/sh -c "
-        export PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1
-        export PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH=/usr/bin/chromium-browser
-        export DISPLAY=:99
-
-        # Start virtual display
-        Xvfb :99 -screen 0 1024x768x24 > /dev/null 2>&1 &
-        XVFB_PID=\$!
-
-        # Give Xvfb time to start
-        sleep 2
-
-        # Cleanup function
-        cleanup() {
-            if [ ! -z \"\$XVFB_PID\" ]; then
-                kill \$XVFB_PID 2>/dev/null || true
-            fi
-        }
-
-        # Trap cleanup
-        trap cleanup EXIT INT TERM
-
-        echo '🎭 Running Playwright tests...'
-        cd /workspace
-        $COMMAND
-    "
-
-echo ""
-echo -e "${GREEN}✅ Playwright tests completed!${NC}"
-echo -e "${BLUE}💡 Benefits: 8ms startup, true isolation, no Docker required${NC}"

package/run.sh

@@ -1,12 +0,0 @@
-#!/bin/bash
-
-# Claudtainer - Simple Wrapper Script
-# Usage: ./run.sh <command> [args]
-
-set -e
-
-# Get the directory where this script is located
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-# Run the CLI
-node "$SCRIPT_DIR/cli.js" "$@"

package/scripts/build.js

@@ -1,303 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * SQLite-style build script for SandboxBox
- * Downloads bubblewrap binary during npm install, with fallback to building from source
- */
-
-import fs from 'fs';
-import path from 'path';
-import https from 'https';
-import { execSync } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const BINARY_DIR = path.join(__dirname, '..', 'bin');
-const BWRAP_VERSION = '0.11.0';
-
-console.log('📦 Building SandboxBox with bubblewrap...');
-
-async function downloadAndBuild() {
-  // Create binary directory
-  if (!fs.existsSync(BINARY_DIR)) {
-    fs.mkdirSync(BINARY_DIR, { recursive: true });
-  }
-
-  const binaryPath = path.join(BINARY_DIR, 'bwrap');
-
-  // Skip on non-Linux platforms but still create stub
-  if (process.platform !== 'linux') {
-    console.log('ℹ️  Skipping bubblewrap build on non-Linux platform');
-    console.log('   SandboxBox works on Linux only');
-    return;
-  }
-
-  // Check if already built
-  if (fs.existsSync(binaryPath)) {
-    try {
-      execSync(`"${binaryPath}" --version`, { stdio: 'ignore' });
-      console.log('✅ Bubblewrap already built');
-      return;
-    } catch (e) {
-      console.log('⚠️  Existing binary broken, rebuilding...');
-    }
-  }
-
-  // SQLite-style approach: try binary downloads first, then build from source
-  if (await downloadPreBuiltBinary(binaryPath)) {
-    return; // Binary download succeeded
-  }
-
-  if (await buildFromSource(binaryPath)) {
-    return; // Build from source succeeded
-  }
-
-  // Everything failed - show clear error
-  console.error('❌ All bubblewrap installation methods failed!');
-  console.error('');
-  console.error('💡 Option 1 - Install system bubblewrap (recommended):');
-  console.error('   sudo apt-get install bubblewrap    # Ubuntu/Debian');
-  console.error('   sudo apk add bubblewrap            # Alpine');
-  console.error('   sudo yum install bubblewrap        # CentOS/RHEL');
-  console.error('');
-  console.error('💡 Option 2 - Install build tools for compilation:');
-  console.error('   sudo apt-get install build-essential git autoconf automake libtool xz-utils');
-  console.error('   sudo yum groupinstall "Development Tools" && sudo yum install git xz');
-  console.error('');
-  console.error('🚫 SandboxBox cannot function without bubblewrap.');
-  process.exit(1);
-}
-
-async function downloadPreBuiltBinary(binaryPath) {
-  console.log('📥 Trying pre-built bubblewrap binary...');
-
-  const arch = process.arch === 'x64' ? 'x86_64' : process.arch;
-  const possibleUrls = [
-    // Alpine packages (HTTPS) - use the actual available version
-    `https://dl-cdn.alpinelinux.org/alpine/v3.20/main/${arch}/bubblewrap-0.10.0-r0.apk`,
-    // Try GitHub releases with different architectures
-    `https://github.com/containers/bubblewrap/releases/download/v${BWRAP_VERSION}/bubblewrap-${BWRAP_VERSION}-${arch}.tar.xz`,
-    `https://github.com/containers/bubblewrap/releases/download/v${BWRAP_VERSION}/bubblewrap-${BWRAP_VERSION}.tar.gz`,
-  ];
-
-  for (const url of possibleUrls) {
-    try {
-      console.log(`📦 Trying: ${url.split('/').pop()}`);
-
-      const response = await new Promise((resolve, reject) => {
-        https.get(url, (res) => {
-          if (res.statusCode === 200) {
-            resolve(res);
-          } else {
-            reject(new Error(`HTTP ${res.statusCode}`));
-          }
-        }).on('error', reject);
-      });
-
-      if (url.endsWith('.apk')) {
-        // Handle Alpine package
-        console.log('📦 Alpine package found, extracting...');
-        return await extractAlpinePackage(url, binaryPath);
-      } else {
-        // Handle tarball
-        return await extractTarball(url, binaryPath);
-      }
-    } catch (error) {
-      console.log(`❌ Failed: ${error.message}`);
-      continue;
-    }
-  }
-
-  console.log('❌ No pre-built binaries available');
-  return false;
-}
-
-async function extractAlpinePackage(url, binaryPath) {
-  const tmpDir = fs.mkdtempSync(path.join(process.env.TMPDIR || '/tmp', 'apk-extract-'));
-
-  try {
-    const apkPath = path.join(tmpDir, 'bubblewrap.apk');
-
-    // Download APK
-    await new Promise((resolve, reject) => {
-      const file = fs.createWriteStream(apkPath);
-      https.get(url, (response) => {
-        response.pipe(file);
-        file.on('finish', resolve);
-      }).on('error', reject);
-    });
-
-    // Extract APK (tar.gz format)
-    execSync(`tar -xzf "${apkPath}" -C "${tmpDir}"`, { stdio: 'inherit' });
-
-    // Find the binary
-    const possiblePaths = [
-      path.join(tmpDir, 'usr', 'bin', 'bwrap'),
-      path.join(tmpDir, 'bin', 'bwrap'),
-    ];
-
-    for (const possiblePath of possiblePaths) {
-      if (fs.existsSync(possiblePath)) {
-        fs.copyFileSync(possiblePath, binaryPath);
-        fs.chmodSync(binaryPath, 0o755);
-        console.log('✅ Extracted pre-built binary from Alpine package');
-        return true;
-      }
-    }
-
-    throw new Error('Binary not found in package');
-  } finally {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  }
-}
-
-async function extractTarball(url, binaryPath) {
-  const tmpDir = fs.mkdtempSync(path.join(process.env.TMPDIR || '/tmp', 'tar-extract-'));
-
-  try {
-    const tarballPath = path.join(tmpDir, 'bubblewrap.tar');
-
-    // Download tarball
-    await new Promise((resolve, reject) => {
-      const file = fs.createWriteStream(tarballPath);
-      https.get(url, (response) => {
-        response.pipe(file);
-        file.on('finish', resolve);
-      }).on('error', reject);
-    });
-
-    // Extract with available tools
-    if (tarballPath.endsWith('.xz')) {
-      try {
-        execSync(`tar -xf "${tarballPath}" -C "${tmpDir}"`, { stdio: 'inherit' });
-      } catch (e) {
-        throw new Error('xz extraction failed - need xz-utils');
-      }
-    } else {
-      execSync(`tar -xzf "${tarballPath}" -C "${tmpDir}"`, { stdio: 'inherit' });
-    }
-
-    // Find the binary
-    const possiblePaths = [
-      path.join(tmpDir, `bubblewrap-${BWRAP_VERSION}`, 'bwrap'),
-      path.join(tmpDir, 'bwrap'),
-      path.join(tmpDir, 'bin', 'bwrap'),
-    ];
-
-    for (const possiblePath of possiblePaths) {
-      if (fs.existsSync(possiblePath)) {
-        fs.copyFileSync(possiblePath, binaryPath);
-        fs.chmodSync(binaryPath, 0o755);
-        console.log('✅ Extracted pre-built binary');
-        return true;
-      }
-    }
-
-    throw new Error('Binary not found in tarball');
-  } finally {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  }
-}
-
-async function buildFromSource(binaryPath) {
-  console.log('🔨 Building bubblewrap from source (SQLite-style)...');
-
-  const tmpDir = fs.mkdtempSync(path.join(process.env.TMPDIR || '/tmp', 'bwrap-build-'));
-
-  try {
-    // Try to use system bubblewrap as fallback if available
-    try {
-      const systemBwrap = execSync('which bwrap', { encoding: 'utf8' }).trim();
-      if (systemBwrap && fs.existsSync(systemBwrap)) {
-        fs.copyFileSync(systemBwrap, binaryPath);
-        fs.chmodSync(binaryPath, 0o755);
-        console.log('✅ Using system bubblewrap:', systemBwrap);
-        return true;
-      }
-    } catch (e) {
-      // System bwrap not found, continue with build
-    }
-
-    // Clone git repository for build files
-    console.log('📥 Downloading bubblewrap source from git...');
-    const sourceDir = path.join(tmpDir, 'bubblewrap');
-
-    execSync(`
-      cd "${tmpDir}" &&
-      timeout 120 git clone --depth 1 --branch v${BWRAP_VERSION} https://github.com/containers/bubblewrap.git
-    `, { stdio: 'inherit' });
-
-    // Check for required build tools
-    const missingTools = [];
-    try {
-      execSync('which gcc', { stdio: 'ignore' });
-    } catch (e) {
-      missingTools.push('gcc');
-    }
-
-    try {
-      execSync('which git', { stdio: 'ignore' });
-    } catch (e) {
-      missingTools.push('git');
-    }
-
-    if (missingTools.length > 0) {
-      console.error(`❌ Missing build tools: ${missingTools.join(', ')}`);
-      console.error('');
-      console.error('💡 Install build tools:');
-      console.error('   Ubuntu/Debian: sudo apt-get install build-essential git');
-      console.error('   CentOS/RHEL: sudo yum groupinstall "Development Tools" && sudo yum install git');
-      console.error('');
-      console.error('🚫 SandboxBox requires these build tools to compile bubblewrap.');
-      return false;
-    }
-
-    // Simple compilation without autotools
-    console.log('🏗️  Compiling bubblewrap directly...');
-    try {
-      execSync(`
-        cd "${sourceDir}" &&
-        timeout 120 gcc -std=c99 -O2 -DHAVE_CONFIG_H=1 -o bwrap bubblewrap.c || \
-        gcc -std=c99 -O2 -o bwrap bubblewrap.c
-      `, { stdio: 'inherit' });
-    } catch (e) {
-      console.error('❌ Direct compilation failed');
-      return false;
-    }
-
-    // Copy binary to final location
-    const builtBinary = path.join(sourceDir, 'bwrap');
-    if (fs.existsSync(builtBinary)) {
-      fs.copyFileSync(builtBinary, binaryPath);
-      fs.chmodSync(binaryPath, 0o755);
-      console.log('✅ Bubblewrap built successfully!');
-
-      // Test the binary
-      const version = execSync(`"${binaryPath}" --version`, { encoding: 'utf8' });
-      console.log(`🎯 Built: ${version.trim()}`);
-      return true;
-    } else {
-      console.log('❌ Built binary not found');
-      return false;
-    }
-
-  } catch (error) {
-    console.log(`❌ Build from source failed: ${error.message}`);
-    return false;
-  } finally {
-    // Cleanup
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  }
-}
-
-// Run the build
-downloadAndBuild().catch(error => {
-  console.error('❌ Bubblewrap build failed:', error.message);
-  console.error('');
-  console.error('🚫 SandboxBox cannot function without bubblewrap.');
-  console.error('   Please install build tools and try again.');
-  process.exit(1);
-});