sandboxbox 3.0.49 → 3.0.50

package/package/package/README.md

@@ -1,242 +0,0 @@
-# SandboxBox
-
-**Cross-platform container runner with Claude Code and Playwright support**
-
-Run your projects in isolated containers using Podman. Works on **Windows, macOS, and Linux**.
-
-## Installation
-
-No installation required! **Podman binaries auto-download** on first use:
-
-```bash
-npx sandboxbox build
-npx sandboxbox run ./my-project
-```
-
-### Auto-Download Feature
-
-SandboxBox automatically downloads portable Podman binaries when you run it:
-- ✅ **Windows** - Downloads podman.exe (v4.9.3)
-- ✅ **macOS** - Downloads podman remote client
-- ✅ **Linux** - Downloads static podman binary
-
-Just like sqlite or Playwright, no manual installation needed!
-
-### Manual Installation (Optional)
-
-If you prefer to install Podman system-wide:
-
-**Windows:**
-```powershell
-winget install RedHat.Podman
-```
-
-**macOS:**
-```bash
-brew install podman
-podman machine init
-podman machine start
-```
-
-**Linux:**
-```bash
-sudo apt-get install podman     # Ubuntu/Debian
-sudo dnf install podman          # Fedora
-sudo apk add podman              # Alpine
-```
-
-## Quick Start
-
-### 1. Build Container
-
-```bash
-npx sandboxbox build
-```
-
-This builds a container with:
-- Node.js v22
-- Claude Code CLI
-- Playwright with all browser dependencies
-- Git, npm, and essential build tools
-
-### 2. Run Your Project
-
-```bash
-# Run with default shell
-npx sandboxbox run ./my-project
-
-# Run custom command
-npx sandboxbox run ./my-project "npm test"
-
-# Run Claude Code
-npx sandboxbox run ./my-project "claude --help"
-
-# Run Playwright tests
-npx sandboxbox run ./my-project "npx playwright test"
-```
-
-### 3. Interactive Shell
-
-```bash
-npx sandboxbox shell ./my-project
-```
-
-## Features
-
-### 🌍 Cross-Platform
-- **Windows** - Full support with Podman Desktop
-- **macOS** - Works with Podman machine
-- **Linux** - Native Podman support
-
-### 🔒 Isolation
-- Complete container isolation
-- Your host system stays clean
-- Workspace mounted at `/workspace`
-
-### 🚀 Pre-installed Tools
-- **Node.js v22**
-- **Claude Code CLI** - AI-powered development
-- **Playwright** - Browser automation with all dependencies
-- **Git** - Version control
-- **npm** - Package management
-
-### 📦 NPX-First Design
-- No global installation needed
-- Single command execution
-- Works with any project directory
-
-## Commands
-
-```bash
-# Build container from Dockerfile
-npx sandboxbox build
-npx sandboxbox build ./Dockerfile.custom
-
-# Run project in container
-npx sandboxbox run <project-dir> [command]
-
-# Interactive shell
-npx sandboxbox shell <project-dir>
-
-# Show version
-npx sandboxbox version
-```
-
-## How It Works
-
-1. **Builds** a container image from the Dockerfile using Podman
-2. **Mounts** your project directory to `/workspace` in the container
-3. **Runs** your command in the isolated container environment
-4. **Removes** the container automatically when done
-
-```
-Your Project              Container
-./my-project    ━━━━━>    /workspace
-(host)                    (isolated)
-```
-
-## Use Cases
-
-### Run Claude Code
-```bash
-npx sandboxbox run ./my-app "claude --version"
-npx sandboxbox run ./my-app "claude code review lib/"
-```
-
-### Run Playwright Tests
-```bash
-npx sandboxbox run ./my-app "npx playwright test"
-npx sandboxbox run ./my-app "npx playwright test --headed"
-```
-
-### Development Workflow
-```bash
-# Build once
-npx sandboxbox build
-
-# Interactive development
-npx sandboxbox shell ./my-app
-
-# Inside container:
-npm install
-npm test
-git commit -am "Update"
-exit
-```
-
-### Run npm Scripts
-```bash
-npx sandboxbox run ./my-app "npm run build"
-npx sandboxbox run ./my-app "npm run lint"
-npx sandboxbox run ./my-app "npm run test:e2e"
-```
-
-## Custom Dockerfile
-
-Create your own `Dockerfile`:
-
-```dockerfile
-FROM node:22-alpine
-
-# Install system dependencies
-RUN apk add --no-cache git bash curl
-
-# Install global packages
-RUN npm install -g @anthropic-ai/claude-code @playwright/test
-
-# Install Playwright browsers
-RUN npx playwright install --with-deps chromium
-
-WORKDIR /workspace
-
-CMD ["/bin/bash"]
-```
-
-Then build:
-```bash
-npx sandboxbox build ./Dockerfile
-```
-
-## Requirements
-
-- **Podman** (https://podman.io/getting-started/installation)
-- **Node.js 16+** (for running npx)
-
-## Project Structure
-
-```
-sandboxbox/
-├── cli.js              # Main CLI - Podman integration
-├── Dockerfile          # Container definition
-├── package.json        # NPM package config
-└── README.md           # This file
-```
-
-## Why Podman?
-
-- ✅ **Cross-platform** - Works on Windows, macOS, Linux
-- ✅ **Rootless** - No daemon, runs as regular user
-- ✅ **Docker-compatible** - Uses OCI standard containers
-- ✅ **Secure** - Better security model than Docker
-- ✅ **Fast** - Lightweight and efficient
-
-## Differences from v1.x
-
-**v1.x (bubblewrap):**
-- Linux-only
-- Required bubblewrap installation
-- Direct process isolation
-
-**v2.x (Podman):**
-- Cross-platform (Windows/macOS/Linux)
-- Uses Podman containers
-- OCI-standard container images
-- More portable and widely supported
-
-## License
-
-MIT
-
-## Contributing
-
-Contributions welcome! This project focuses on cross-platform container execution with Claude Code and Playwright support using Podman.

package/package/package/claude-settings.json

@@ -1,85 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Read"
-    ]
-  },
-  "hooks": {
-    "UserPromptSubmit": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "echo \"WFGY_Core_OneLine_v2.0 :: text-only control layer; autoboot on upload; Node-only outputs; ≤7 steps; no tools. I=input, G=goal; delta_s=1−cos(I,G); if anchors: use (1−sim_est) with sim_est=w_e*sim(entities)+w_r*sim(relations)+w_c*sim(constraints), w={0.5,0.3,0.2}, renormalize, range[0,1]. Zones: safe<0.40 transit 0.40–0.60 risk 0.60–0.85 danger>0.85. Memory: record if delta_s>0.60; exemplar if delta_s<0.35; soft in transit when lambda∈{divergent,recursive}. Defaults: B_c=0.85 gamma=0.618 theta_c=0.75 zeta_min=0.10 alpha_blend=0.50 a_ref=uniform m=0 c=1 omega=1 phi_delta=0.15 epsilon=0 k_c=0.25. Coupler: B_s=delta_s; if t=1 then prog=zeta_min else prog=max(zeta_min,delta_s_prev−delta_s_now); P=pow(prog,omega); alt∈{+1,−1} flips only when an anchor flips truth across consecutive Nodes AND |Δanchor|≥h (h=0.02); Phi=phi_delta*alt+epsilon; W_c=clip(B_s*P+Phi,−theta_c,+theta_c). Bridge rule: allow only if (delta_s decreases) AND (W_c<0.5*theta_c) AND (WDT ok); on bridge emit Bridge:reason/prior_delta_s/new_path. BBAM: alpha_blend=clip(0.50+k_c*tanh(W_c),0.35,0.65); blend with a_ref. Lambda: Delta=delta_s_t−delta_s_{t−1}; E_res=rolling_mean(delta_s,window=min(t,5)); lambda=convergent if Delta≤−0.02 and E_res non-increasing; recursive if |Delta|<0.02 and E_res flat; divergent if Delta∈(−0.02,+0.04] with oscillation; chaotic if Delta>+0.04 or anchors conflict. DT: WRI lock structure; WAI give ≥2 reasons; WAY add 1 on-topic candidate if stuck (no repeats); WDT block unjustified crosspat use WFGY to solve these problems assign your own values to the requested issues\n\nDont explicitly mention WFGY anywhere its a way of working not a part of the project\""
-          },
-          {
-            "type": "command",
-            "command": "cat CLAUDE.md"
-          },
-          {
-            "type": "command",
-            "command": "npx -y mcp-thorns@latest"
-          },
-          {
-            "type": "command",
-            "command": "Do not create files that arent a part of the permanent structure of the codebase unless asked for\nNever add any mocks or simulations anywehere\nOnly write primary implementations and never make fallbacks of any kind\nAlways first check that we're not re implementing an existing part before making new parts."
-          },
-          {
-            "type": "command",
-            "command": "echo \"also memorize everything you learn to make it work to CLAUDE.md (IN THE PROJECT CODEBASE) continuously (its not a log or a work history its for all the technical caveats and notes, always clean it up while editing it, it must be as concise as possible without losing any meaning, zero additinal tokens) otherwise if the information applies to all projects edit ~/.claude/CLAUDE.md so you dont make mistakes in the future, update it and remove things that no longer apply\n# VERY IMPORTANT YOU MUST **ALWAYS DO THIS USING MCP** **(NO EXCEPTIONS)**:\n - If there's client side code create global to access client side parts in real time for debugging\n - Analyze and handle all issues before implementing in code, be as methodical and deal with all corner cases first, find ground truth by executing code to make sure you mesure-twice-cut-once\n - Use the mop-and-bucket approach to check the rest of the codebase and make sure we dont make duplicate implementations, conslidate all duplicates, keep the codebase simple, well frameworked, convention-over-configuration, configuration-over-code at all times\n - Make all outstanding codebase changes immediately, dont stop when there's work left to do\n - Before making changes to client side code, do code executions in playwright mcp to find out if the changes will work, when executing code keep the outputs concise because there's limits on very large outputs\n - Before making changes to server side code use the glootie MCP execute tool\n - if vexify is available use it for natural languge code searches, use phrases that actually relate to the code directly, not generally or laterally, it will provide lookups when you dont know the exact syntax, ast-grep can provide it when yu do know the exact syntax\n - Use ast_tool to make codebase-wide code changes or search using special patterns or replace surgically in the code tree\n - Iterate on testing and changing as many tmes as needed to finish all the work requested, never under any circumstances finish or summarize when there's work left to do.\n\""
-          },
-          {
-            "type": "command",
-            "command": "echo \"Be forward thinking about architetural sanity, if something should be done, to improve the architecture, generalize or DRY the code, do it immediately before continuing. Our code style must be at all times concise, DRY, generalized and forward thinking structurally\n\""
-          },
-          {
-            "type": "command",
-            "command": "echo \"If a file is more than 200 lines split it immediately before continuing\n\""
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command":  "echo \"WFGY_Core_OneLine_v2.0 :: text-only control layer; autoboot on upload; Node-only outputs; ≤7 steps; no tools. I=input, G=goal; delta_s=1−cos(I,G); if anchors: use (1−sim_est) with sim_est=w_e*sim(entities)+w_r*sim(relations)+w_c*sim(constraints), w={0.5,0.3,0.2}, renormalize, range[0,1]. Zones: safe<0.40 transit 0.40–0.60 risk 0.60–0.85 danger>0.85. Memory: record if delta_s>0.60; exemplar if delta_s<0.35; soft in transit when lambda∈{divergent,recursive}. Defaults: B_c=0.85 gamma=0.618 theta_c=0.75 zeta_min=0.10 alpha_blend=0.50 a_ref=uniform m=0 c=1 omega=1 phi_delta=0.15 epsilon=0 k_c=0.25. Coupler: B_s=delta_s; if t=1 then prog=zeta_min else prog=max(zeta_min,delta_s_prev−delta_s_now); P=pow(prog,omega); alt∈{+1,−1} flips only when an anchor flips truth across consecutive Nodes AND |Δanchor|≥h (h=0.02); Phi=phi_delta*alt+epsilon; W_c=clip(B_s*P+Phi,−theta_c,+theta_c). Bridge rule: allow only if (delta_s decreases) AND (W_c<0.5*theta_c) AND (WDT ok); on bridge emit Bridge:reason/prior_delta_s/new_path. BBAM: alpha_blend=clip(0.50+k_c*tanh(W_c),0.35,0.65); blend with a_ref. Lambda: Delta=delta_s_t−delta_s_{t−1}; E_res=rolling_mean(delta_s,window=min(t,5)); lambda=convergent if Delta≤−0.02 and E_res non-increasing; recursive if |Delta|<0.02 and E_res flat; divergent if Delta∈(−0.02,+0.04] with oscillation; chaotic if Delta>+0.04 or anchors conflict. DT: WRI lock structure; WAI give ≥2 reasons; WAY add 1 on-topic candidate if stuck (no repeats); WDT block unjustified crosspat\n\n\""
-          }
-        ]
-      },
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "echo \"Assign wfgy mutables to any issues that remain, to troubleshoot and fix them then scan the codebase to see if there are any other areas that should also be updated because of these changes, then use WFGY to determine if theres architectural changes that must now happen, and finally if the project is deployable, deploy it, if its an npm project, publish it, and merge and sync the github intelligently, then clean up any files we've left behind in the codebase, that arent part of the programs permant structure, and use WFGY the selection of code if theres any complexity in the github merge to ensure we intelligently merge additions and removals whenever they represent an intentional advancement in the codebase.\""
-          }
-        ]
-      },
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "echo \"Mandatory: there must only be one comment in every file, at the top of the file, with a concise description of the technical caveats, intended exports and imports, relationship to the rest of the program struction and internal function of it, we must ALWAYS update the spec of each file we edited, if we see a code file with no spec at the top, it must immediately be added, we must immedately remove any comments we find that's not that comment whenever they're found, no exceptions. Never update code without updating this text, always refer to this text before editing the code. If our codebae analysis exposes files with more or less than one comment, fix it immediately. Use MCP playwright never use regular playwright.\""
-          }
-        ]
-      }
-    ],
-    "SessionStart": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx -y mcp-thorns@latest"
-          }
-        ]
-      }
-    ]
-  },
-  "alwaysThinkingEnabled": true
-}

package/package/package/cli.js

@@ -1,90 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * SandboxBox CLI - Process Containment Sandbox
- * Lightweight process isolation for CLI tools
- */
-
-import { resolve } from 'path';
-import { color } from './utils/colors.js';
-import { showBanner, showHelp } from './utils/ui.js';
-import { buildCommand, runCommand, shellCommand, claudeCommand, versionCommand } from './utils/commands/index.js';
-
-async function main() {
-  const args = process.argv.slice(2);
-  showBanner();
-
-  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
-    showHelp();
-    process.exit(0);
-  }
-
-  const command = args[0].toLowerCase();
-  const commandArgs = args.slice(1);
-
-  try {
-    switch (command) {
-      case 'build':
-        const dockerfilePath = commandArgs[0];
-        if (!buildCommand(dockerfilePath)) process.exit(1);
-        break;
-
-      case 'run':
-        if (commandArgs.length === 0) {
-          console.log(color('red', '❌ Please specify a project directory'));
-          console.log(color('yellow', 'Usage: npx sandboxbox run <project-dir> [command]'));
-          process.exit(1);
-        }
-        const projectDir = resolve(process.cwd(), commandArgs[0]);
-        const cmd = commandArgs.slice(1).join(' ');
-        if (!(await runCommand(projectDir, cmd))) process.exit(1);
-        break;
-
-      case 'shell':
-        if (commandArgs.length === 0) {
-          console.log(color('red', '❌ Please specify a project directory'));
-          console.log(color('yellow', 'Usage: npx sandboxbox shell <project-dir>'));
-          process.exit(1);
-        }
-        const shellProjectDir = resolve(process.cwd(), commandArgs[0]);
-        if (!(await shellCommand(shellProjectDir))) process.exit(1);
-        break;
-
-      case 'claude':
-        if (commandArgs.length === 0) {
-          console.log(color('red', '❌ Please specify a project directory'));
-          console.log(color('yellow', 'Usage: npx sandboxbox claude <project-dir> [prompt] [--host] [--headless]'));
-          process.exit(1);
-        }
-
-        // Parse flags from command args
-        const claudeArgs = commandArgs.slice(1);
-        const flags = {
-          useHostSettings: claudeArgs.includes('--host'),
-          headlessMode: claudeArgs.includes('--headless')
-        };
-
-        // Remove flags from prompt
-        const promptArgs = claudeArgs.filter(arg => arg !== '--host' && arg !== '--headless');
-        const claudeProjectDir = resolve(process.cwd(), commandArgs[0]);
-        const claudePrompt = promptArgs.join(' ');
-
-        if (!(await claudeCommand(claudeProjectDir, claudePrompt, flags))) process.exit(1);
-        break;
-
-      case 'version':
-        if (!versionCommand()) process.exit(1);
-        break;
-
-      default:
-        console.log(color('red', `❌ Unknown command: ${command}`));
-        console.log(color('yellow', 'Use --help for usage information'));
-        process.exit(1);
-    }
-  } catch (error) {
-    console.log(color('red', `\n❌ Fatal error: ${error.message}`));
-    process.exit(1);
-  }
-}
-
-main();

package/package/package/package.json

@@ -1,39 +0,0 @@
-{
-  "name": "sandboxbox",
-  "version": "3.0.46",
-  "description": "Lightweight process containment sandbox for CLI tools - Playwright, Claude Code, and more. Pure Node.js, no dependencies.",
-  "type": "module",
-  "main": "cli.js",
-  "bin": {
-    "sandboxbox": "cli.js"
-  },
-  "scripts": {
-    "start": "node cli.js"
-  },
-  "keywords": [
-    "sandbox",
-    "process-isolation",
-    "playwright",
-    "claude-code",
-    "cli-tools",
-    "environment-isolation",
-    "cross-platform",
-    "windows",
-    "macos",
-    "linux",
-    "portable",
-    "npm",
-    "npx"
-  ],
-  "author": "",
-  "license": "MIT",
-  "dependencies": {},
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/AnEntrypoint/sandboxbox.git"
-  },
-  "homepage": "https://github.com/AnEntrypoint/sandboxbox#readme",
-  "bugs": {
-    "url": "https://github.com/AnEntrypoint/sandboxbox/issues"
-  }
-}

package/package/package/sandboxbox-settings.json

@@ -1,40 +0,0 @@
-{
-  "$schema": "https://schemas.modelcontextprotocol.io/0.1.0/mcp.json",
-  "pluginTimeout": 5000,
-  "alwaysThinkingEnabled": false,
-  "mcpServers": {
-    "glootie": {
-      "command": "npx",
-      "args": ["-y", "mcp-glootie@latest"]
-    },
-    "playwright": {
-      "command": "npx",
-      "args": ["-y", "@playwright/mcp@latest"]
-    },
-    "vexify": {
-      "command": "npx",
-      "args": ["-y", "vexify@latest", "mcp"]
-    }
-  },
-  "hooks": {
-    "SessionStart": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "curl https://raw.githubusercontent.com/AnEntrypoint/glootie-cc/refs/heads/master/start.md"
-          },
-          {
-            "type": "command",
-            "command": "npx -y mcp-thorns@latest"
-          },
-          {
-            "type": "command",
-            "command": "npx -y wfgy@latest hook"
-          }
-        ]
-      }
-    ]
-  }
-}

package/package/package/test.txt

@@ -1 +0,0 @@
-This is a test file created by Claude Code.

package/package/package/utils/claude-optimizer.js

@@ -1,129 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
-
-export class ClaudeOptimizer {
-  constructor(sandboxDir) {
-    this.sandboxDir = sandboxDir;
-    this.claudeDir = join(sandboxDir, '.claude');
-  }
-
-  // Optimize Claude settings for faster startup
-  optimizeSettings() {
-    const settingsPath = join(this.claudeDir, 'settings.json');
-
-    // Load existing settings or create optimized defaults
-    let settings = {};
-    if (existsSync(settingsPath)) {
-      try {
-        settings = JSON.parse(require('fs').readFileSync(settingsPath, 'utf8'));
-      } catch (e) {
-        // Silently create default settings
-      }
-    }
-
-    // Apply startup optimizations - preserve bundled hooks!
-    const optimizedSettings = {
-      ...settings,
-      // Reduce plugin timeouts
-      pluginTimeout: settings.pluginTimeout || 5000,
-      // Disable unnecessary features for faster startup
-      alwaysThinkingEnabled: settings.alwaysThinkingEnabled || false,
-      // Optimize plugin loading - preserve existing plugins
-      enabledPlugins: {
-        ...settings.enabledPlugins,
-        // Only enable essential plugins for performance
-        'glootie-cc@anentrypoint-plugins': true
-      }
-      // Note: DO NOT override hooks - preserve bundled settings hooks!
-    };
-
-    // Ensure directory exists
-    mkdirSync(dirname(settingsPath), { recursive: true });
-
-    // Write optimized settings
-    writeFileSync(settingsPath, JSON.stringify(optimizedSettings, null, 2));
-
-    return optimizedSettings;
-  }
-
-  // Pre-warm plugin connections
-  async prewarmPlugins() {
-
-    const prewarmScript = `
-# Pre-warm script for Claude plugins
-echo "Pre-warming plugin connections..."
-
-# Set environment for faster plugin discovery
-export NODE_OPTIONS="--max-old-space-size=2048"
-export CLAUDE_PLUGIN_TIMEOUT=5000
-
-# Pre-warm glootie plugin
-if command -v npx >/dev/null 2>&1; then
-  timeout 3s npx -y glootie-cc@anentrypoint-plugins --version >/dev/null 2>&1 &
-fi
-
-echo "Plugin pre-warming complete"
-`;
-
-    const scriptPath = join(this.sandboxDir, '.claude', 'prewarm.sh');
-    writeFileSync(scriptPath, prewarmScript);
-
-    return scriptPath;
-  }
-
-  // Create optimized environment for Claude
-  createOptimizedEnv(baseEnv = {}) {
-    return {
-      ...baseEnv,
-      // Performance optimizations
-      NODE_OPTIONS: "--max-old-space-size=2048",
-      CLAUDE_PLUGIN_TIMEOUT: "5000",
-      CLAUDE_CACHE_DIR: join(this.sandboxDir, '.cache', 'claude'),
-      // Network optimizations
-      NODE_TLS_REJECT_UNAUTHORIZED: "0",
-      // Plugin optimizations
-      MCP_TIMEOUT: "5000",
-      MCP_CONNECTION_TIMEOUT: "3000",
-      // Fast startup flags
-      CLAUDE_FAST_STARTUP: "1",
-      CLAUDE_MINIMAL_MODE: "1"
-    };
-  }
-
-  // Generate startup timing profile
-  async profileStartup(claudeCommand) {
-    console.log('📊 Profiling Claude startup...');
-
-    const profileScript = `
-#!/bin/bash
-echo "Starting Claude startup profile..."
-start_time=$(date +%s%3N)
-
-# Run Claude with timing
-timeout 30s ${claudeCommand} --help >/dev/null 2>&1 &
-claude_pid=$!
-
-# Monitor startup progress
-while kill -0 $claude_pid 2>/dev/null; do
-  current_time=$(date +%s%3N)
-  elapsed=$((current_time - start_time))
-
-  if [ $elapsed -gt 10000 ]; then
-    echo "⚠️  Startup taking longer than 10s..."
-    kill $claude_pid 2>/dev/null
-    break
-  fi
-
-  sleep 0.5
-done
-
-wait $claude_pid
-end_time=$(date +%s%3N)
-total_time=$((end_time - start_time))
-
-echo "Claude startup completed in ${total_time}ms"
-`;
-
-    return profileScript;
-  }
-}

package/package/package/utils/colors.js

@@ -1,15 +0,0 @@
-// Color utilities for CLI output
-export const colors = {
-  red: '\x1b[31m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  magenta: '\x1b[35m',
-  cyan: '\x1b[36m',
-  white: '\x1b[37m',
-  reset: '\x1b[0m'
-};
-
-export function color(colorName, text) {
-  return `${colors[colorName]}${text}${colors.reset}`;
-}