icoa-cli 1.0.0

package/dist/commands/connect.d.ts

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

package/dist/commands/connect.js

@@ -0,0 +1,66 @@
+import { execSync } from 'node:child_process';
+import chalk from 'chalk';
+import { CTFdClient } from '../lib/ctfd-client.js';
+import { getConfig, isConnected } from '../lib/config.js';
+import { logCommand } from '../lib/logger.js';
+import { printError, printInfo, printSuccess, createSpinner } from '../lib/ui.js';
+export function registerConnectCommand(program) {
+    program
+        .command('connect <id>')
+        .description('Connect to challenge remote target')
+        .action(async (id) => {
+        logCommand(`connect ${id}`);
+        const config = getConfig();
+        if (!isConnected()) {
+            printError('Not connected. Run: icoa ctf join <url>');
+            return;
+        }
+        const client = new CTFdClient(config.ctfdUrl, config.token);
+        const spinner = createSpinner('Fetching connection info...');
+        spinner.start();
+        try {
+            const challenge = await client.getChallenge(parseInt(id));
+            spinner.stop();
+            if (!challenge.connection_info) {
+                printInfo('This challenge has no connection information.');
+                return;
+            }
+            const connInfo = challenge.connection_info.trim();
+            printInfo(`Connection: ${chalk.white(connInfo)}`);
+            console.log();
+            // Parse connection info and execute
+            if (connInfo.match(/^nc\s+/i) || connInfo.match(/^ncat\s+/i)) {
+                // netcat connection
+                printSuccess('Connecting...');
+                execSync(connInfo, { stdio: 'inherit' });
+            }
+            else if (connInfo.match(/^ssh\s+/i)) {
+                // SSH connection
+                printSuccess('Connecting via SSH...');
+                execSync(connInfo, { stdio: 'inherit' });
+            }
+            else if (connInfo.includes(':')) {
+                // host:port format
+                const [host, port] = connInfo.split(':');
+                printSuccess(`Connecting to ${host}:${port}...`);
+                execSync(`nc ${host} ${port}`, { stdio: 'inherit' });
+            }
+            else {
+                printInfo('Could not auto-detect connection type.');
+                printInfo(`Connection info: ${connInfo}`);
+                printInfo('Connect manually using the information above.');
+            }
+        }
+        catch (err) {
+            if (err.status !== undefined) {
+                // Process exited (normal for nc/ssh)
+                console.log();
+                printInfo('Connection closed.');
+            }
+            else {
+                spinner.fail('Failed to connect');
+                printError(err.message);
+            }
+        }
+    });
+}

package/dist/commands/ctf.d.ts

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

package/dist/commands/ctf.js

@@ -0,0 +1,472 @@
+import chalk from 'chalk';
+import { input, select } from '@inquirer/prompts';
+import { CTFdClient } from '../lib/ctfd-client.js';
+import { getConfig, saveConfig, getBudget } from '../lib/config.js';
+import { logCommand, logSubmission } from '../lib/logger.js';
+import { getTranslation } from '../lib/translation.js';
+import { printSuccess, printError, printWarning, printInfo, printTable, printMarkdown, printHeader, printKeyValue, createSpinner, formatCountdown, } from '../lib/ui.js';
+function requireConnection() {
+    const config = getConfig();
+    if (!config.ctfdUrl || !config.token) {
+        printError('Not connected to CTFd. Run: icoa ctf join <url>');
+        process.exit(1);
+    }
+    return { config, client: new CTFdClient(config.ctfdUrl, config.token) };
+}
+export function registerCtfCommands(program) {
+    const ctf = program.command('ctf').description('Competition commands');
+    // ─── icoa ctf join <url> ───
+    ctf
+        .command('join <url>')
+        .description('Connect to a CTFd instance')
+        .action(async (url) => {
+        logCommand(`ctf join ${url}`);
+        console.log();
+        printInfo(`Connecting to ${chalk.bold(url)}`);
+        const authMethod = await select({
+            message: 'Authentication method:',
+            choices: [
+                { name: 'Access Token (from CTFd Settings)', value: 'token' },
+                { name: 'Username & Password', value: 'login' },
+            ],
+        });
+        let token;
+        if (authMethod === 'token') {
+            token = await input({ message: 'Enter your CTFd Access Token:' });
+        }
+        else {
+            const username = await input({ message: 'Username:' });
+            const password = await input({ message: 'Password:' });
+            const spinner = createSpinner('Logging in...');
+            spinner.start();
+            try {
+                const client = new CTFdClient(url, '');
+                token = await client.loginWithCredentials(username, password);
+                spinner.succeed('Login successful');
+            }
+            catch (err) {
+                spinner.fail('Login failed');
+                printError(err.message);
+                return;
+            }
+        }
+        // Test connection
+        const spinner = createSpinner('Testing connection...');
+        spinner.start();
+        try {
+            const client = new CTFdClient(url, token);
+            const user = await client.testConnection();
+            spinner.succeed('Connected successfully');
+            console.log();
+            printKeyValue('User', user.name);
+            printKeyValue('Score', String(user.score || 0));
+            if (user.team_id) {
+                printKeyValue('Team ID', String(user.team_id));
+            }
+            // Fetch competition metadata (times, mode)
+            try {
+                const meta = await client.getCompetitionMeta();
+                const configUpdate = {
+                    ctfdUrl: url,
+                    token: token,
+                    userId: user.id,
+                    userName: user.name,
+                    teamId: user.team_id,
+                };
+                if (meta.start) {
+                    configUpdate.competitionStartsAt = new Date(meta.start * 1000).toISOString();
+                    printKeyValue('Starts', new Date(meta.start * 1000).toLocaleString());
+                }
+                if (meta.end) {
+                    configUpdate.competitionEndsAt = new Date(meta.end * 1000).toISOString();
+                    printKeyValue('Ends', new Date(meta.end * 1000).toLocaleString());
+                }
+                // Determine competition state
+                const now = Date.now() / 1000;
+                if (meta.start && now < meta.start) {
+                    configUpdate.competitionState = 'pre_competition';
+                }
+                else if (meta.end && now > meta.end) {
+                    configUpdate.competitionState = 'finished';
+                }
+                else {
+                    configUpdate.competitionState = 'live';
+                }
+                printKeyValue('Status', configUpdate.competitionState);
+                saveConfig(configUpdate);
+            }
+            catch {
+                // Fallback: save without competition times
+                saveConfig({
+                    ctfdUrl: url,
+                    token: token,
+                    userId: user.id,
+                    userName: user.name,
+                    teamId: user.team_id,
+                });
+            }
+            console.log();
+            printSuccess('Connection saved. You are ready to compete!');
+        }
+        catch (err) {
+            spinner.fail('Connection failed');
+            printError(err.message);
+        }
+    });
+    // ─── icoa ctf activate <code> ───
+    ctf
+        .command('activate <code>')
+        .description('Validate competition code')
+        .action(async (code) => {
+        logCommand(`ctf activate ${code}`);
+        const { client } = requireConnection();
+        const spinner = createSpinner('Validating competition code...');
+        spinner.start();
+        try {
+            // Try custom ICOA endpoint first
+            const res = await fetch(getConfig().ctfdUrl + '/api/v1/icoa/activate', {
+                method: 'POST',
+                headers: {
+                    Authorization: `Token ${getConfig().token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ code }),
+            });
+            if (res.ok) {
+                const data = (await res.json());
+                spinner.succeed('Competition code validated');
+                saveConfig({
+                    competitionCode: code,
+                    teamId: data.data?.team_id || getConfig().teamId,
+                    competitionState: 'live',
+                });
+                printSuccess(`Activated: ${code}`);
+            }
+            else {
+                // Fallback: just store the code locally
+                spinner.succeed('Competition code saved');
+                saveConfig({ competitionCode: code });
+                printInfo('Code stored locally. Server validation will be attempted during competition.');
+            }
+        }
+        catch {
+            // Server doesn't have custom endpoint, store locally
+            spinner.succeed('Competition code saved');
+            saveConfig({ competitionCode: code });
+            printInfo('Code stored locally.');
+        }
+    });
+    // ─── icoa ctf challenges ───
+    ctf
+        .command('challenges')
+        .description('List all challenges')
+        .action(async () => {
+        logCommand('ctf challenges');
+        const { client } = requireConnection();
+        const spinner = createSpinner('Loading challenges...');
+        spinner.start();
+        try {
+            const challenges = await client.getChallenges();
+            spinner.stop();
+            if (!challenges || challenges.length === 0) {
+                printInfo('No challenges available yet.');
+                return;
+            }
+            // Group by category
+            const byCategory = new Map();
+            for (const c of challenges) {
+                const cat = c.category || 'Uncategorized';
+                if (!byCategory.has(cat))
+                    byCategory.set(cat, []);
+                byCategory.get(cat).push(c);
+            }
+            const solved = challenges.filter((c) => c.solved_by_me).length;
+            printHeader(`Challenges (${solved}/${challenges.length} solved)`);
+            // Sort categories and display
+            const rows = [...byCategory.entries()]
+                .sort(([a], [b]) => a.localeCompare(b))
+                .flatMap(([category, challs]) => {
+                const catRow = [chalk.cyan.bold(`── ${category} ──`), '', '', '', ''];
+                const challRows = challs
+                    .sort((a, b) => a.value - b.value)
+                    .map((c) => [
+                    String(c.id),
+                    c.solved_by_me ? chalk.gray.strikethrough(c.name) : c.name,
+                    chalk.gray(c.category),
+                    c.solved_by_me ? chalk.gray(String(c.value)) : chalk.yellow(String(c.value)),
+                    c.solved_by_me ? chalk.green('✓') : chalk.gray('○'),
+                ]);
+                return [catRow, ...challRows];
+            });
+            printTable(['#', 'Name', 'Category', 'Points', 'Solved'], rows);
+            console.log(chalk.gray(`  ${challenges.length} challenges, ${solved} solved`));
+        }
+        catch (err) {
+            spinner.fail('Failed to load challenges');
+            printError(err.message);
+        }
+    });
+    // ─── icoa ctf open <id> ───
+    ctf
+        .command('open <id>')
+        .description('View challenge details')
+        .action(async (id) => {
+        logCommand(`ctf open ${id}`);
+        const { config, client } = requireConnection();
+        const spinner = createSpinner('Loading challenge...');
+        spinner.start();
+        try {
+            const challenge = await client.getChallenge(parseInt(id));
+            spinner.stop();
+            // Save current challenge context for hints
+            saveConfig({
+                currentChallengeId: challenge.id,
+                currentChallengeName: challenge.name,
+                currentChallengeCategory: challenge.category,
+            });
+            printHeader(`${challenge.name} [${challenge.category}]`);
+            printKeyValue('Points', String(challenge.value));
+            printKeyValue('Solves', String(challenge.solves));
+            if (challenge.connection_info) {
+                printKeyValue('Connection', challenge.connection_info);
+            }
+            console.log();
+            // Display description (with optional translation)
+            let description = challenge.description;
+            if (config.language !== 'en') {
+                try {
+                    description = await getTranslation(description, challenge.id, config.language);
+                }
+                catch {
+                    // Translation failed, use English
+                }
+            }
+            printMarkdown(description);
+            // Show files
+            if (challenge.files && challenge.files.length > 0) {
+                console.log();
+                printInfo(`Files (${challenge.files.length}): use ${chalk.white(`icoa files ${id}`)} to download`);
+            }
+            // Show hints
+            if (challenge.hints && challenge.hints.length > 0) {
+                printInfo(`CTFd Hints available: ${challenge.hints.length}`);
+            }
+            // Show connection info
+            if (challenge.connection_info) {
+                console.log();
+                printInfo(`Quick connect: ${chalk.white(`icoa connect ${id}`)}`);
+            }
+            // Show helpful next actions
+            console.log();
+            console.log(chalk.gray(`  Next: icoa hint "how to approach this?" | icoa ctf submit ${id} "icoa{flag}"`));
+        }
+        catch (err) {
+            spinner.fail('Failed to load challenge');
+            printError(err.message);
+        }
+    });
+    // ─── icoa ctf submit <id> <flag> ───
+    ctf
+        .command('submit <id> <flag>')
+        .description('Submit a flag')
+        .action(async (id, flag) => {
+        logCommand(`ctf submit ${id}`);
+        logSubmission(parseInt(id), flag);
+        const { client } = requireConnection();
+        const spinner = createSpinner('Submitting flag...');
+        spinner.start();
+        try {
+            const result = await client.submitFlag(parseInt(id), flag);
+            spinner.stop();
+            switch (result.status) {
+                case 'correct':
+                    console.log();
+                    console.log(chalk.green.bold('  🎉 Correct! ') + chalk.white(result.message));
+                    console.log();
+                    break;
+                case 'incorrect':
+                    printError('Incorrect. ' + result.message);
+                    break;
+                case 'already_solved':
+                    printWarning('Already solved.');
+                    break;
+                case 'paused':
+                    printWarning('Competition is paused.');
+                    break;
+                case 'ratelimited':
+                    printWarning('Rate limited. Please wait before trying again.');
+                    break;
+                default:
+                    printInfo(result.message || 'Unknown response');
+            }
+        }
+        catch (err) {
+            spinner.fail('Submission failed');
+            printError(err.message);
+        }
+    });
+    // ─── icoa ctf scoreboard ───
+    ctf
+        .command('scoreboard [top]')
+        .description('View scoreboard (optional: top N)')
+        .action(async (top) => {
+        logCommand('ctf scoreboard');
+        const { config, client } = requireConnection();
+        const spinner = createSpinner('Loading scoreboard...');
+        spinner.start();
+        try {
+            const scoreboard = await client.getScoreboard();
+            spinner.stop();
+            if (!scoreboard || scoreboard.length === 0) {
+                printInfo('Scoreboard is empty.');
+                return;
+            }
+            printHeader('Scoreboard');
+            const rows = scoreboard.map((entry) => {
+                const isMyTeam = entry.account_id === config.teamId;
+                const row = [
+                    String(entry.pos),
+                    entry.name,
+                    String(entry.score),
+                ];
+                if (isMyTeam) {
+                    return row.map((cell) => chalk.yellow.bold(cell));
+                }
+                return row;
+            });
+            printTable(['Rank', 'Team', 'Score'], rows);
+        }
+        catch (err) {
+            spinner.fail('Failed to load scoreboard');
+            printError(err.message);
+        }
+    });
+    // ─── icoa ctf status ───
+    ctf
+        .command('status')
+        .description('Show competition status')
+        .action(async () => {
+        logCommand('ctf status');
+        const { config, client } = requireConnection();
+        printHeader('Competition Status');
+        // Competition state
+        const stateColors = {
+            pre_competition: chalk.yellow,
+            demo: chalk.blue,
+            live: chalk.green,
+            finished: chalk.red,
+            unknown: chalk.gray,
+        };
+        const stateLabels = {
+            pre_competition: 'PRE-COMPETITION',
+            demo: 'DEMO',
+            live: 'LIVE',
+            finished: 'FINISHED',
+            unknown: 'UNKNOWN',
+        };
+        const state = config.competitionState || 'unknown';
+        const colorFn = stateColors[state] || chalk.gray;
+        console.log(`  ${chalk.gray('State:')} ${chalk.bold(colorFn(stateLabels[state] || state))}`);
+        // User info
+        try {
+            const user = await client.testConnection();
+            printKeyValue('User', chalk.white.bold(user.name));
+            printKeyValue('Score', chalk.yellow.bold(String(user.score || 0)));
+            printKeyValue('Rank', chalk.cyan(user.place || 'N/A'));
+        }
+        catch {
+            printKeyValue('User', config.userName || 'Unknown');
+        }
+        // Hint budget with visual bars
+        console.log();
+        console.log(`  ${chalk.gray('Hint Budget:')}`);
+        const budget = getBudget();
+        const bar = (used, total, color) => {
+            const width = 20;
+            const filled = Math.round((used / total) * width);
+            const empty = width - filled;
+            return color('█'.repeat(filled)) + chalk.gray('░'.repeat(empty)) + ` ${used}/${total}`;
+        };
+        console.log(`    A ${bar(budget.a, 50, chalk.green)}`);
+        console.log(`    B ${bar(budget.b, 10, chalk.yellow)}`);
+        console.log(`    C ${bar(budget.c, 2, chalk.red)}`);
+        console.log(`    ${chalk.gray('Tokens')} ${bar(budget.tokenCap - budget.tokensUsed, budget.tokenCap, chalk.cyan)}`);
+        // Time
+        if (config.competitionEndsAt) {
+            console.log();
+            const endsAt = new Date(config.competitionEndsAt);
+            const now = new Date();
+            if (now < endsAt) {
+                printKeyValue('Time Remaining', chalk.yellow.bold(formatCountdown(endsAt)));
+            }
+            else {
+                printKeyValue('Time', chalk.red('Competition ended'));
+            }
+        }
+        console.log();
+    });
+    // ─── icoa ctf time ───
+    ctf
+        .command('time')
+        .description('Show competition countdown')
+        .action(() => {
+        logCommand('ctf time');
+        const config = getConfig();
+        if (!config.competitionStartsAt && !config.competitionEndsAt) {
+            printInfo('Competition times not configured.');
+            printInfo('They will be set when the competition server provides timing information.');
+            return;
+        }
+        const now = new Date();
+        const startsAt = config.competitionStartsAt ? new Date(config.competitionStartsAt) : null;
+        const endsAt = config.competitionEndsAt ? new Date(config.competitionEndsAt) : null;
+        printHeader('Competition Timer');
+        if (startsAt && now < startsAt) {
+            console.log(chalk.yellow('  Competition has not started yet.'));
+            console.log();
+            const update = () => {
+                process.stdout.write(`\r  ${chalk.bold('Starts in:')} ${formatCountdown(startsAt)}  `);
+            };
+            update();
+            const interval = setInterval(() => {
+                if (new Date() >= startsAt) {
+                    clearInterval(interval);
+                    console.log();
+                    printSuccess('Competition has started! Good luck!');
+                    return;
+                }
+                update();
+            }, 1000);
+            process.on('SIGINT', () => {
+                clearInterval(interval);
+                console.log();
+                process.exit(0);
+            });
+        }
+        else if (endsAt && now < endsAt) {
+            console.log(chalk.green('  Competition is LIVE'));
+            console.log();
+            const update = () => {
+                process.stdout.write(`\r  ${chalk.bold('Time remaining:')} ${formatCountdown(endsAt)}  `);
+            };
+            update();
+            const interval = setInterval(() => {
+                if (new Date() >= endsAt) {
+                    clearInterval(interval);
+                    console.log();
+                    printWarning('Competition has ended!');
+                    return;
+                }
+                update();
+            }, 1000);
+            process.on('SIGINT', () => {
+                clearInterval(interval);
+                console.log();
+                process.exit(0);
+            });
+        }
+        else {
+            console.log(chalk.red('  Competition has ended.'));
+        }
+    });
+}

package/dist/commands/files.d.ts

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

package/dist/commands/files.js

@@ -0,0 +1,52 @@
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import chalk from 'chalk';
+import { CTFdClient } from '../lib/ctfd-client.js';
+import { getConfig, isConnected } from '../lib/config.js';
+import { logCommand } from '../lib/logger.js';
+import { printError, createSpinner } from '../lib/ui.js';
+export function registerFilesCommand(program) {
+    program
+        .command('files <id>')
+        .description('Download challenge files')
+        .action(async (id) => {
+        logCommand(`files ${id}`);
+        const config = getConfig();
+        if (!isConnected()) {
+            printError('Not connected. Run: icoa ctf join <url>');
+            return;
+        }
+        const client = new CTFdClient(config.ctfdUrl, config.token);
+        const destDir = join(homedir(), 'icoa-challenges', id);
+        const spinner = createSpinner('Fetching challenge files...');
+        spinner.start();
+        try {
+            const files = await client.getChallengeFiles(parseInt(id));
+            if (!files || files.length === 0) {
+                spinner.info('No files attached to this challenge.');
+                return;
+            }
+            spinner.text = `Downloading ${files.length} file(s)...`;
+            const downloaded = [];
+            for (const filePath of files) {
+                try {
+                    const dest = await client.downloadFile(filePath, destDir);
+                    downloaded.push(dest);
+                }
+                catch (err) {
+                    spinner.warn(`Failed to download: ${filePath}`);
+                }
+            }
+            spinner.succeed(`Downloaded ${downloaded.length} file(s)`);
+            console.log(chalk.gray(`  Location: ${destDir}`));
+            for (const f of downloaded) {
+                console.log(chalk.gray(`    → ${f.split('/').pop()}`));
+            }
+            console.log();
+        }
+        catch (err) {
+            spinner.fail('Failed to download files');
+            printError(err.message);
+        }
+    });
+}

package/dist/commands/hint.d.ts

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