icoa-cli 1.4.4 → 1.5.1

package/dist/commands/env.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerEnvCommand(program: Command): void;

package/dist/commands/env.js

@@ -0,0 +1,208 @@
+import chalk from 'chalk';
+import { execSync } from 'node:child_process';
+import { platform } from 'node:os';
+const PYTHON_LIBS = [
+    { name: 'pwntools', check: 'python3 -c "import pwn"', install: 'pwntools==4.12.0', category: 'Python Libraries' },
+    { name: 'pycryptodome', check: 'python3 -c "import Crypto"', install: 'pycryptodome==3.20.0', category: 'Python Libraries' },
+    { name: 'requests', check: 'python3 -c "import requests"', install: 'requests==2.31.0', category: 'Python Libraries' },
+    { name: 'beautifulsoup4', check: 'python3 -c "import bs4"', install: 'beautifulsoup4==4.12.3', category: 'Python Libraries' },
+    { name: 'z3-solver', check: 'python3 -c "import z3"', install: 'z3-solver==4.12.6', category: 'Python Libraries' },
+    { name: 'sympy', check: 'python3 -c "import sympy"', install: 'sympy==1.12', category: 'Python Libraries' },
+    { name: 'scapy', check: 'python3 -c "import scapy"', install: 'scapy==2.5.0', category: 'Python Libraries' },
+    { name: 'pillow', check: 'python3 -c "import PIL"', install: 'pillow==10.2.0', category: 'Python Libraries' },
+    { name: 'numpy', check: 'python3 -c "import numpy"', install: 'numpy==1.26.4', category: 'Python Libraries' },
+    { name: 'pefile', check: 'python3 -c "import pefile"', install: 'pefile==2023.2.7', category: 'Python Libraries' },
+    { name: 'capstone', check: 'python3 -c "import capstone"', install: 'capstone==5.0.1', category: 'Python Libraries' },
+    { name: 'ropper', check: 'python3 -c "import ropper"', install: 'ropper==1.13.8', category: 'Python Libraries' },
+    { name: 'ROPgadget', check: 'which ROPgadget', install: 'ROPgadget==7.4', category: 'Python Libraries' },
+    { name: 'flask', check: 'python3 -c "import flask"', install: 'flask==3.0.0', category: 'Python Libraries' },
+    { name: 'cryptography', check: 'python3 -c "import cryptography"', install: 'cryptography==42.0.0', category: 'Python Libraries' },
+    { name: 'paramiko', check: 'python3 -c "import paramiko"', install: 'paramiko==3.4.0', category: 'Python Libraries' },
+    { name: 'python-magic', check: 'python3 -c "import magic"', install: 'python-magic==0.4.27', category: 'Python Libraries' },
+    { name: 'ipython', check: 'which ipython3 || which ipython', install: 'ipython', category: 'Python Libraries' },
+    { name: 'angr', check: 'python3 -c "import angr"', install: 'angr', category: 'Python Libraries' },
+    { name: 'sqlmap', check: 'which sqlmap', install: 'sqlmap', category: 'Python Libraries' },
+];
+const SYSTEM_TOOLS = [
+    // Editors
+    { name: 'vim', check: 'which vim', category: 'Editors' },
+    { name: 'nano', check: 'which nano', category: 'Editors' },
+    { name: 'tmux', check: 'which tmux', category: 'Editors' },
+    // Compilers
+    { name: 'gcc', check: 'which gcc', category: 'Compilers' },
+    { name: 'g++', check: 'which g++', category: 'Compilers' },
+    { name: 'make', check: 'which make', category: 'Compilers' },
+    { name: 'nasm', check: 'which nasm', category: 'Compilers' },
+    // Python
+    { name: 'python3', check: 'python3 --version', category: 'Python' },
+    { name: 'pip3', check: 'pip3 --version', category: 'Python' },
+    // Network
+    { name: 'curl', check: 'which curl', category: 'Networking' },
+    { name: 'wget', check: 'which wget', category: 'Networking' },
+    { name: 'nc', check: 'which nc', category: 'Networking' },
+    { name: 'nmap', check: 'which nmap', category: 'Networking' },
+    { name: 'ssh', check: 'which ssh', category: 'Networking' },
+    { name: 'socat', check: 'which socat', category: 'Networking' },
+    // Debuggers
+    { name: 'gdb', check: 'which gdb', category: 'Debuggers' },
+    { name: 'ltrace', check: 'which ltrace', category: 'Debuggers' },
+    { name: 'strace', check: 'which strace', category: 'Debuggers' },
+    // RE
+    { name: 'radare2', check: 'which r2', category: 'Reverse Engineering' },
+    { name: 'objdump', check: 'which objdump', category: 'Reverse Engineering' },
+    // Forensics
+    { name: 'binwalk', check: 'which binwalk', category: 'Forensics' },
+    { name: 'exiftool', check: 'which exiftool', category: 'Forensics' },
+    { name: 'steghide', check: 'which steghide', category: 'Forensics' },
+    { name: 'strings', check: 'which strings', category: 'Forensics' },
+    { name: 'file', check: 'which file', category: 'Forensics' },
+    { name: 'xxd', check: 'which xxd', category: 'Forensics' },
+    // Crypto
+    { name: 'john', check: 'which john', category: 'Crypto' },
+    { name: 'hashcat', check: 'which hashcat', category: 'Crypto' },
+    { name: 'openssl', check: 'which openssl', category: 'Crypto' },
+    // Data
+    { name: 'jq', check: 'which jq', category: 'Data Processing' },
+    { name: 'sqlite3', check: 'which sqlite3', category: 'Data Processing' },
+    // Core
+    { name: 'git', check: 'which git', category: 'Version Control' },
+    { name: 'docker', check: 'which docker', category: 'Container' },
+];
+function isInstalled(check) {
+    try {
+        execSync(check, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getVersion(name) {
+    try {
+        if (name === 'python3') {
+            return execSync('python3 --version', { encoding: 'utf-8' }).trim().replace('Python ', '');
+        }
+        if (name === 'gcc') {
+            const out = execSync('gcc --version', { encoding: 'utf-8' });
+            const match = out.match(/(\d+\.\d+\.\d+)/);
+            return match ? match[1] : '';
+        }
+        if (name === 'docker') {
+            const out = execSync('docker --version', { encoding: 'utf-8' });
+            const match = out.match(/(\d+\.\d+\.\d+)/);
+            return match ? match[1] : '';
+        }
+    }
+    catch { /* ignore */ }
+    return '';
+}
+export function registerEnvCommand(program) {
+    const envCmd = program.command('env').description('Manage competition environment');
+    // icoa env — show status
+    envCmd
+        .command('status')
+        .alias('check')
+        .description('Check installed tools and libraries')
+        .action(() => {
+        showStatus();
+    });
+    // icoa env setup — install everything
+    envCmd
+        .command('setup')
+        .description('Install all Python libraries (locked versions)')
+        .action(async () => {
+        await installAll();
+    });
+    // Default action: show status
+    envCmd.action(() => {
+        showStatus();
+    });
+}
+function showStatus() {
+    console.log();
+    console.log(chalk.bold.white('  ICOA Competition Environment'));
+    console.log(chalk.gray('  ─────────────────────────────────'));
+    console.log();
+    let installed = 0;
+    let missing = 0;
+    let currentCategory = '';
+    // System tools
+    for (const tool of SYSTEM_TOOLS) {
+        if (tool.category !== currentCategory) {
+            currentCategory = tool.category;
+            console.log(chalk.bold.gray(`  ${currentCategory}`));
+        }
+        const ok = isInstalled(tool.check);
+        const ver = ok ? getVersion(tool.name) : '';
+        const verStr = ver ? chalk.gray(` (${ver})`) : '';
+        if (ok) {
+            console.log(chalk.green(`    ✓ ${tool.name}`) + verStr);
+            installed++;
+        }
+        else {
+            console.log(chalk.red(`    ✗ ${tool.name}`));
+            missing++;
+        }
+    }
+    // Python libraries
+    currentCategory = '';
+    for (const lib of PYTHON_LIBS) {
+        if (lib.category !== currentCategory) {
+            currentCategory = lib.category;
+            console.log(chalk.bold.gray(`  ${currentCategory}`));
+        }
+        const ok = isInstalled(lib.check);
+        const verStr = lib.install ? chalk.gray(` (${lib.install})`) : '';
+        if (ok) {
+            console.log(chalk.green(`    ✓ ${lib.name}`) + verStr);
+            installed++;
+        }
+        else {
+            console.log(chalk.red(`    ✗ ${lib.name}`) + (lib.install ? chalk.gray(` → ${lib.install}`) : ''));
+            missing++;
+        }
+    }
+    console.log();
+    console.log(chalk.gray('  ─────────────────────────────────'));
+    console.log(`  ${chalk.green(`✓ ${installed} installed`)}  ${missing > 0 ? chalk.red(`✗ ${missing} missing`) : chalk.green('All ready!')}`);
+    if (missing > 0) {
+        console.log();
+        console.log(chalk.gray('  Install missing Python libs: ') + chalk.white('env setup'));
+    }
+    console.log();
+}
+async function installAll() {
+    console.log();
+    console.log(chalk.bold.white('  Installing Python libraries (locked versions)...'));
+    console.log();
+    const os = platform();
+    const pipFlag = os === 'darwin' || os === 'linux' ? '--break-system-packages' : '';
+    let installed = 0;
+    let failed = 0;
+    for (const lib of PYTHON_LIBS) {
+        if (!lib.install)
+            continue;
+        const alreadyInstalled = isInstalled(lib.check);
+        if (alreadyInstalled) {
+            console.log(chalk.green(`  ✓ ${lib.name}`) + chalk.gray(` (already installed)`));
+            installed++;
+            continue;
+        }
+        process.stdout.write(chalk.gray(`  ⏳ Installing ${lib.name}...`));
+        try {
+            execSync(`pip3 install ${pipFlag} ${lib.install}`, { stdio: 'ignore' });
+            process.stdout.write('\r');
+            console.log(chalk.green(`  ✓ ${lib.name}`) + chalk.gray(` (${lib.install})`));
+            installed++;
+        }
+        catch {
+            process.stdout.write('\r');
+            console.log(chalk.red(`  ✗ ${lib.name}`) + chalk.gray(` (install failed)`));
+            failed++;
+        }
+    }
+    console.log();
+    console.log(chalk.gray('  ─────────────────────────────────'));
+    console.log(`  ${chalk.green(`✓ ${installed} installed`)}  ${failed > 0 ? chalk.red(`✗ ${failed} failed`) : chalk.green('All ready!')}`);
+    console.log();
+}

package/dist/index.js

@@ -11,6 +11,7 @@ import { registerNoteCommand } from './commands/note.js';
 import { registerLogCommand } from './commands/log.js';
 import { registerLangCommand } from './commands/lang.js';
 import { registerSetupCommand } from './commands/setup.js';
+import { registerEnvCommand } from './commands/env.js';
 import { getConfig, saveConfig } from './lib/config.js';
 import { startRepl } from './repl.js';
 import { checkTerminal } from './lib/terminal.js';
@@ -37,7 +38,7 @@ ${B}                                                          ${B}
 ${B}   ${chalk.white('Sydney, Australia')}  ${chalk.gray('Jun 27 - Jul 2, 2026')}                ${B}
 ${B}   ${chalk.cyan.underline('https://icoa2026.au')}                                    ${B}
 ${B}                                                          ${B}
-${B}   ${chalk.gray('CLI-Native Competition Terminal  v1.4.4')}                ${B}
+${B}   ${chalk.gray('CLI-Native Competition Terminal  v1.5.1')}                ${B}
 ${B}                                                          ${B}
 ${chalk.cyan('╚══════════════════════════════════════════════════════════╝')}
 `;
@@ -82,6 +83,7 @@ registerNoteCommand(program);
 registerLogCommand(program);
 registerLangCommand(program);
 registerSetupCommand(program);
+registerEnvCommand(program);
 // Hidden command: switch AI model
 program
     .command('model', { hidden: true })

package/dist/lib/sandbox.d.ts

@@ -0,0 +1,7 @@
+export declare function isDockerAvailable(): boolean;
+export declare function isSandboxRunning(): boolean;
+export declare function ensureSandbox(): Promise<boolean>;
+export declare function runInSandbox(command: string, rl: {
+    pause: () => void;
+    resume: () => void;
+}): Promise<void>;

package/dist/lib/sandbox.js

@@ -0,0 +1,93 @@
+import { execSync, spawn } from 'node:child_process';
+import chalk from 'chalk';
+const IMAGE = 'icoa/sandbox:2026';
+const CONTAINER = 'icoa-sandbox';
+export function isDockerAvailable() {
+    try {
+        execSync('docker info', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isSandboxRunning() {
+    try {
+        const out = execSync(`docker inspect -f '{{.State.Running}}' ${CONTAINER} 2>/dev/null`, {
+            encoding: 'utf-8',
+        });
+        return out.trim() === 'true';
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureSandbox() {
+    if (!isDockerAvailable()) {
+        console.log(chalk.yellow('  Docker not found. Install Docker Desktop to use sandbox tools.'));
+        console.log(chalk.gray('  https://www.docker.com/products/docker-desktop'));
+        return false;
+    }
+    if (isSandboxRunning())
+        return true;
+    // Check if container exists but stopped
+    try {
+        execSync(`docker start ${CONTAINER}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        // Container doesn't exist, create it
+    }
+    // Check if image exists
+    try {
+        execSync(`docker image inspect ${IMAGE}`, { stdio: 'ignore' });
+    }
+    catch {
+        console.log(chalk.gray('  Pulling sandbox image (first time only)...'));
+        try {
+            execSync(`docker pull ${IMAGE}`, { stdio: 'inherit' });
+        }
+        catch {
+            // Image not on registry yet, try building locally
+            console.log(chalk.gray('  Building sandbox from local Dockerfile...'));
+            try {
+                const dockerDir = new URL('../../docker', import.meta.url).pathname;
+                execSync(`docker build -t ${IMAGE} ${dockerDir}`, { stdio: 'inherit' });
+            }
+            catch {
+                console.log(chalk.red('  Failed to set up sandbox.'));
+                return false;
+            }
+        }
+    }
+    // Create and start container
+    try {
+        execSync(`docker run -d --name ${CONTAINER} ` +
+            `-v icoa-challenges:/home/competitor/challenges ` +
+            `--network host ` +
+            `${IMAGE} sleep infinity`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        console.log(chalk.red('  Failed to start sandbox container.'));
+        return false;
+    }
+}
+export function runInSandbox(command, rl) {
+    return new Promise((resolve) => {
+        rl.pause();
+        const opts = {
+            stdio: 'inherit',
+            shell: true,
+        };
+        const child = spawn('docker', ['exec', '-it', CONTAINER, 'bash', '-c', command], opts);
+        child.on('close', () => {
+            rl.resume();
+            resolve();
+        });
+        child.on('error', () => {
+            rl.resume();
+            resolve();
+        });
+    });
+}

package/dist/repl.js

@@ -4,6 +4,7 @@ import chalk from 'chalk';
 import { isConnected, getConfig } from './lib/config.js';
 import { isActivated, activateToken, isFreeCommand, isDeviceMatch, recordExit, recordResume } from './lib/access.js';
 import { resetTerminalTheme } from './lib/theme.js';
+import { ensureSandbox, runInSandbox, isDockerAvailable } from './lib/sandbox.js';
 const INTERCEPT = '__REPL_NO_EXIT__';
 export function startRepl(program, resumeMode) {
     const config = getConfig();
@@ -124,13 +125,24 @@ export function startRepl(program, resumeMode) {
             'join', 'activate', 'challenges', 'ch', 'open', 'submit', 'flag',
             'scoreboard', 'sb', 'status', 'time', 'hint', 'hint-b', 'hint-c',
             'hint-budget', 'ref', 'shell', 'files', 'connect', 'note', 'log',
-            'lang', 'setup', 'model', 'ctf',
+            'lang', 'setup', 'env', 'model', 'ctf',
         ];
         if (!knownCommands.includes(cmd)) {
-            // Pass through to system shell
+            // Route to Docker sandbox if available, otherwise system shell
             processing = true;
             try {
-                await runSystemCommand(input, rl);
+                if (isDockerAvailable()) {
+                    const ready = await ensureSandbox();
+                    if (ready) {
+                        await runInSandbox(input, rl);
+                    }
+                    else {
+                        await runSystemCommand(input, rl);
+                    }
+                }
+                else {
+                    await runSystemCommand(input, rl);
+                }
             }
             catch {
                 console.log(chalk.yellow(`  Command failed: ${cmd}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "icoa-cli",
-  "version": "1.4.4",
+  "version": "1.5.1",
   "description": "ICOA CLI — The world's first CLI-native CTF competition terminal",
   "type": "module",
   "bin": {