icoa-cli 2.3.2 → 2.5.2

package/dist/commands/ai4ctf.d.ts

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+export declare function isChatActive(): boolean;
+export declare function handleChatMessage(input: string): Promise<'continue' | 'exit'>;
 export declare function registerAi4ctfCommand(program: Command): void;

package/dist/commands/ai4ctf.js

@@ -1,4 +1,3 @@
-import { createInterface } from 'node:readline';
 import chalk from 'chalk';
 import { createChatSession } from '../lib/gemini.js';
 import { isTokenCapReached, addTokenUsage, getTokenUsage } from '../lib/budget.js';
@@ -12,28 +11,68 @@ function getChallengeContext() {
     }
     return undefined;
 }
+// Chat state — shared with REPL
+let chatActive = false;
+let chatSession = null;
+export function isChatActive() {
+    return chatActive;
+}
+export async function handleChatMessage(input) {
+    if (!chatSession)
+        return 'exit';
+    if (input === 'exit' || input === 'back' || input === 'quit') {
+        chatActive = false;
+        chatSession = null;
+        console.log();
+        printInfo('Returning to ICOA terminal.');
+        console.log();
+        return 'exit';
+    }
+    if (isTokenCapReached()) {
+        chatActive = false;
+        chatSession = null;
+        printError('Token budget exhausted. Exiting chat mode.');
+        return 'exit';
+    }
+    logCommand(`ai4ctf: ${input}`);
+    console.log(chalk.gray('  Thinking...'));
+    try {
+        const response = await chatSession.sendMessage(input);
+        process.stdout.write('\x1b[1A\x1b[2K');
+        addTokenUsage(response.tokensUsed);
+        const updated = getTokenUsage();
+        console.log();
+        printMarkdown(response.text);
+        console.log(chalk.gray(`  [${response.tokensUsed.toLocaleString()} tokens | ${updated.used.toLocaleString()}/${updated.cap.toLocaleString()} total]`));
+        console.log();
+    }
+    catch (err) {
+        process.stdout.write('\x1b[1A\x1b[2K');
+        printError(`AI error: ${err.message}`);
+        console.log();
+    }
+    return 'continue';
+}
 export function registerAi4ctfCommand(program) {
     program
         .command('ai4ctf')
         .description('Chat with your AI teammate')
         .action(async () => {
         logCommand('ai4ctf');
-        // Check token cap
         if (isTokenCapReached()) {
             printError('Token budget exhausted. No more AI interactions available.');
             return;
         }
         const context = getChallengeContext();
         const tokenState = getTokenUsage();
-        // Create chat session
-        let chat;
         try {
-            chat = await createChatSession(context);
+            chatSession = await createChatSession(context);
         }
         catch (err) {
             printError(err.message);
             return;
         }
+        chatActive = true;
         // Welcome banner
         console.log();
         console.log(chalk.magenta('  ┌─────────────────────────────────────────┐'));
@@ -47,64 +86,5 @@ export function registerAi4ctfCommand(program) {
         console.log(chalk.magenta('  │') + chalk.gray("  Type 'exit' to return".padEnd(41)) + chalk.magenta('│'));
         console.log(chalk.magenta('  └─────────────────────────────────────────┘'));
         console.log();
-        // Inner chat REPL
-        return new Promise((resolve) => {
-            const chatRl = createInterface({
-                input: process.stdin,
-                output: process.stdout,
-                prompt: chalk.magenta('ai4ctf> '),
-                terminal: true,
-            });
-            chatRl.prompt();
-            chatRl.on('line', async (line) => {
-                const input = line.trim();
-                if (!input) {
-                    chatRl.prompt();
-                    return;
-                }
-                // Exit commands
-                if (input === 'exit' || input === 'back' || input === 'quit') {
-                    chatRl.close();
-                    return;
-                }
-                // Token cap check
-                if (isTokenCapReached()) {
-                    console.log();
-                    printError('Token budget exhausted. Exiting chat mode.');
-                    chatRl.close();
-                    return;
-                }
-                // Log the chat message
-                logCommand(`ai4ctf: ${input}`);
-                // Send message
-                console.log(chalk.gray('  Thinking...'));
-                try {
-                    const response = await chat.sendMessage(input);
-                    // Clear "Thinking..." line
-                    process.stdout.write('\x1b[1A\x1b[2K');
-                    // Track tokens
-                    addTokenUsage(response.tokensUsed);
-                    const updated = getTokenUsage();
-                    // Display response
-                    console.log();
-                    printMarkdown(response.text);
-                    console.log(chalk.gray(`  [${response.tokensUsed.toLocaleString()} tokens | ${updated.used.toLocaleString()}/${updated.cap.toLocaleString()} total]`));
-                    console.log();
-                }
-                catch (err) {
-                    // Clear "Thinking..." line
-                    process.stdout.write('\x1b[1A\x1b[2K');
-                    printError(`AI error: ${err.message}`);
-                    console.log();
-                }
-                chatRl.prompt();
-            });
-            chatRl.on('close', () => {
-                console.log();
-                printInfo('Returning to ICOA terminal.');
-                console.log();
-                resolve();
-            });
-        });
     });
 }

package/dist/commands/connect.js

@@ -12,7 +12,7 @@ export function registerConnectCommand(program) {
         logCommand(`connect ${id}`);
         const config = getConfig();
         if (!isConnected()) {
-            printError('Not connected. Run: icoa ctf join <url>');
+            printError('Not connected. Run: join <url>');
             return;
         }
         const client = new CTFdClient(config.ctfdUrl, config.token);

package/dist/commands/ctf.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { input, select } from '@inquirer/prompts';
+import { input } 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';
@@ -30,45 +30,38 @@ export function registerCtfCommands(program) {
         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' },
-            ],
-        });
+        const username = await input({ message: 'Username:' });
+        const password = await input({ message: 'Password:' });
         let token = '';
         let sessionCookie = '';
         let csrfNonce = '';
-        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, '');
-                const result = await client.loginWithCredentials(username, password);
-                token = result.token;
-                sessionCookie = result.session;
-                csrfNonce = result.csrf;
-                spinner.succeed('Login successful');
+        const spinner = createSpinner('Logging in...');
+        spinner.start();
+        try {
+            const client = new CTFdClient(url, '');
+            const result = await client.loginWithCredentials(username, password);
+            token = result.token;
+            sessionCookie = result.session;
+            csrfNonce = result.csrf;
+            if (token) {
+                spinner.succeed('Login successful — API token auto-generated');
             }
-            catch (err) {
-                spinner.fail('Login failed');
-                printError(err.message);
-                return;
+            else {
+                spinner.succeed('Login successful (session mode)');
             }
         }
+        catch (err) {
+            spinner.fail('Login failed');
+            printError(err.message);
+            return;
+        }
         // Test connection
-        const spinner = createSpinner('Testing connection...');
-        spinner.start();
+        const spinner2 = createSpinner('Testing connection...');
+        spinner2.start();
         try {
             const client = new CTFdClient(url, token, sessionCookie, csrfNonce);
             const user = await client.testConnection();
-            spinner.succeed('Connected successfully');
+            spinner2.succeed('Connected successfully');
             console.log();
             printKeyValue('User', user.name);
             printKeyValue('Score', String(user.score || 0));
@@ -85,6 +78,7 @@ export function registerCtfCommands(program) {
                     userName: user.name,
                     teamId: user.team_id,
                     sessionCookie: sessionCookie,
+                    country: user.country || '',
                 };
                 if (meta.start) {
                     configUpdate.competitionStartsAt = new Date(meta.start * 1000).toISOString();
@@ -119,10 +113,15 @@ export function registerCtfCommands(program) {
                 });
             }
             console.log();
-            printSuccess('Connection saved. You are ready to compete!');
+            printSuccess('Connection saved. You are ready!');
+            console.log();
+            console.log(chalk.gray('  Next:'));
+            console.log(chalk.white('    exam list      ') + chalk.gray('View available exams'));
+            console.log(chalk.white('    challenges     ') + chalk.gray('View CTF challenges'));
+            console.log(chalk.white('    status         ') + chalk.gray('Check score & budget'));
         }
         catch (err) {
-            spinner.fail('Connection failed');
+            spinner2.fail('Connection failed');
             printError(err.message);
         }
     });
@@ -258,7 +257,7 @@ export function registerCtfCommands(program) {
             // Show files
             if (challenge.files && challenge.files.length > 0) {
                 console.log();
-                printInfo(`Files (${challenge.files.length}): use ${chalk.white(`icoa files ${id}`)} to download`);
+                printInfo(`Files (${challenge.files.length}): use ${chalk.white(`files ${id}`)} to download`);
             }
             // Show hints
             if (challenge.hints && challenge.hints.length > 0) {
@@ -267,11 +266,11 @@ export function registerCtfCommands(program) {
             // Show connection info
             if (challenge.connection_info) {
                 console.log();
-                printInfo(`Quick connect: ${chalk.white(`icoa connect ${id}`)}`);
+                printInfo(`Quick connect: ${chalk.white(`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}"`));
+            console.log(chalk.gray(`  Next: hint "how to approach this?" | submit ${id} "icoa{flag}"`));
         }
         catch (err) {
             spinner.fail('Failed to load challenge');

package/dist/commands/exam.d.ts

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

package/dist/commands/exam.js

@@ -0,0 +1,376 @@
+import chalk from 'chalk';
+import { confirm } from '@inquirer/prompts';
+import { ExamClient } from '../lib/exam-client.js';
+import { getConfig } from '../lib/config.js';
+import { getExamState, saveExamState, clearExamState, getExamDeadline } from '../lib/exam-state.js';
+import { logCommand } from '../lib/logger.js';
+import { printSuccess, printError, printWarning, printInfo, printTable, printHeader, printKeyValue, createSpinner, formatCountdown, } from '../lib/ui.js';
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function drawProgress(percent, label) {
+    const width = 30;
+    const filled = Math.round((percent / 100) * width);
+    const empty = width - filled;
+    const bar = chalk.green('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+    const pct = String(percent).padStart(3) + '%';
+    process.stdout.write(`\r  ${bar} ${pct}  ${chalk.gray(label)}`);
+}
+function requireExamConnection() {
+    const config = getConfig();
+    if (!config.ctfdUrl || !config.token) {
+        printError('Not connected. Run: join <url>');
+        return null;
+    }
+    return new ExamClient(config.ctfdUrl, config.token);
+}
+function checkTimeRemaining() {
+    const deadline = getExamDeadline();
+    if (!deadline)
+        return true;
+    if (new Date() >= deadline) {
+        printError('Time expired! Use "exam submit" to submit your answers.');
+        return false;
+    }
+    return true;
+}
+function printTimeRemaining() {
+    const deadline = getExamDeadline();
+    if (deadline) {
+        const now = new Date();
+        if (now < deadline) {
+            printKeyValue('Time Remaining', chalk.yellow.bold(formatCountdown(deadline)));
+        }
+        else {
+            printKeyValue('Time', chalk.red.bold('EXPIRED'));
+        }
+    }
+}
+function printQuestion(q, answer) {
+    const state = getExamState();
+    const total = state?.session.questionCount || '?';
+    console.log();
+    console.log(chalk.bold.white(`  Q${q.number}/${total}`) + (q.category ? chalk.gray(` [${q.category}]`) : ''));
+    console.log(`  ${q.text}`);
+    console.log();
+    for (const key of ['A', 'B', 'C', 'D']) {
+        const selected = answer === key;
+        const prefix = selected ? chalk.green.bold(`  ▸ ${key}.`) : chalk.gray(`    ${key}.`);
+        const text = selected ? chalk.green.bold(q.options[key]) : chalk.white(q.options[key]);
+        console.log(`${prefix} ${text}`);
+    }
+    console.log();
+}
+export function registerExamCommand(program) {
+    const exam = program.command('exam').description('National selection exam');
+    // ─── exam list ───
+    exam
+        .command('list')
+        .description('List available exams')
+        .action(async () => {
+        logCommand('exam list');
+        const client = requireExamConnection();
+        if (!client)
+            return;
+        const spinner = createSpinner('Loading exams...');
+        spinner.start();
+        try {
+            const exams = await client.getExams();
+            spinner.stop();
+            if (!exams || exams.length === 0) {
+                printInfo('No exams available.');
+                return;
+            }
+            printHeader('Available Exams');
+            const rows = exams.map((e) => {
+                const statusColor = e.status === 'submitted' ? chalk.green
+                    : e.status === 'in_progress' ? chalk.yellow
+                        : chalk.white;
+                return [
+                    chalk.white(e.id),
+                    e.name,
+                    chalk.cyan(e.country),
+                    String(e.questionCount),
+                    `${e.durationMinutes} min`,
+                    statusColor(e.status),
+                ];
+            });
+            printTable(['ID', 'Name', 'Country', 'Questions', 'Duration', 'Status'], rows);
+            console.log();
+            console.log(chalk.gray('  Start an exam: exam start <id>'));
+        }
+        catch (err) {
+            spinner.fail('Failed to load exams');
+            printError(err.message);
+        }
+    });
+    // ─── exam start <id> ───
+    exam
+        .command('start <id>')
+        .description('Start an exam (begins timer)')
+        .action(async (examId) => {
+        logCommand(`exam start ${examId}`);
+        // Check if already in an exam
+        const existing = getExamState();
+        if (existing) {
+            printWarning(`Exam "${existing.session.examName}" is already in progress.`);
+            printInfo('Use "exam review" to check progress or "exam submit" to submit.');
+            return;
+        }
+        const client = requireExamConnection();
+        if (!client)
+            return;
+        const proceed = await confirm({
+            message: 'Start the exam? The timer will begin immediately.',
+            default: true,
+        });
+        if (!proceed)
+            return;
+        console.log();
+        try {
+            // Step 1: Connect
+            drawProgress(0, 'Connecting to exam server...');
+            const { session, questions } = await client.startExam(examId);
+            // Step 2-4: Visual loading steps
+            drawProgress(30, 'Loading questions...');
+            await sleep(200);
+            drawProgress(60, 'Preparing exam environment...');
+            await sleep(200);
+            drawProgress(90, 'Starting timer...');
+            await sleep(150);
+            saveExamState({ session, questions, answers: {} });
+            drawProgress(100, 'Ready!');
+            console.log();
+            console.log();
+            printHeader(session.examName);
+            printKeyValue('Questions', String(session.questionCount));
+            printKeyValue('Duration', `${session.durationMinutes} minutes`);
+            printKeyValue('Country', session.country);
+            printTimeRemaining();
+            // Show first question
+            if (questions.length > 0) {
+                printQuestion(questions[0]);
+            }
+            console.log(chalk.gray('  Commands: exam q <n> | exam answer <n> <A-D> | exam review | exam submit'));
+        }
+        catch (err) {
+            console.log();
+            printError(err.message);
+        }
+    });
+    // ─── exam q [n] ───
+    exam
+        .command('q [n]')
+        .description('View question (or all questions)')
+        .action((n) => {
+        logCommand(`exam q ${n || 'all'}`);
+        const state = getExamState();
+        if (!state) {
+            printError('No exam in progress. Use "exam start <id>" to begin.');
+            return;
+        }
+        printTimeRemaining();
+        if (n) {
+            const num = parseInt(n);
+            const q = state.questions.find((q) => q.number === num);
+            if (!q) {
+                printError(`Question ${n} not found (1-${state.questions.length}).`);
+                return;
+            }
+            printQuestion(q, state.answers[num]);
+        }
+        else {
+            // Show all questions summary
+            printHeader(`${state.session.examName}`);
+            const answered = Object.keys(state.answers).length;
+            printKeyValue('Progress', `${answered}/${state.session.questionCount} answered`);
+            console.log();
+            for (const q of state.questions) {
+                const ans = state.answers[q.number];
+                const status = ans ? chalk.green(`[${ans}]`) : chalk.gray('[ ]');
+                const cat = q.category ? chalk.gray(` [${q.category}]`) : '';
+                console.log(`  ${status} ${chalk.white(`Q${q.number}`)}${cat} ${chalk.gray(q.text.substring(0, 60))}${q.text.length > 60 ? '...' : ''}`);
+            }
+            console.log();
+        }
+    });
+    // ─── exam answer <n> <choice> ───
+    exam
+        .command('answer <n> <choice>')
+        .description('Answer question N with choice A/B/C/D')
+        .action((n, choice) => {
+        logCommand(`exam answer ${n} ${choice}`);
+        const state = getExamState();
+        if (!state) {
+            printError('No exam in progress. Use "exam start <id>" to begin.');
+            return;
+        }
+        if (!checkTimeRemaining())
+            return;
+        const num = parseInt(n);
+        const q = state.questions.find((q) => q.number === num);
+        if (!q) {
+            printError(`Question ${n} not found (1-${state.questions.length}).`);
+            return;
+        }
+        const c = choice.toUpperCase();
+        if (!['A', 'B', 'C', 'D'].includes(c)) {
+            printError('Choice must be A, B, C, or D.');
+            return;
+        }
+        state.answers[num] = c;
+        saveExamState(state);
+        const answered = Object.keys(state.answers).length;
+        const total = state.session.questionCount;
+        printSuccess(`Q${num}: ${c} saved (${answered}/${total} answered)`);
+        if (num < state.questions.length) {
+            console.log(chalk.gray(`  Next: exam q ${num + 1}`));
+        }
+        else if (answered === total) {
+            console.log(chalk.gray('  All answered! Use: exam review'));
+        }
+    });
+    // ─── exam review ───
+    exam
+        .command('review')
+        .description('Review all answers before submitting')
+        .action(() => {
+        logCommand('exam review');
+        const state = getExamState();
+        if (!state) {
+            printError('No exam in progress.');
+            return;
+        }
+        printHeader(`Review: ${state.session.examName}`);
+        printTimeRemaining();
+        console.log();
+        const cols = 6;
+        let line = '  ';
+        for (const q of state.questions) {
+            const ans = state.answers[q.number];
+            if (ans) {
+                line += chalk.green(`Q${String(q.number).padStart(2)} [${ans}]  `);
+            }
+            else {
+                line += chalk.yellow(`Q${String(q.number).padStart(2)} [ ]  `);
+            }
+            if (q.number % cols === 0) {
+                console.log(line);
+                line = '  ';
+            }
+        }
+        if (line.trim())
+            console.log(line);
+        const answered = Object.keys(state.answers).length;
+        const total = state.session.questionCount;
+        const unanswered = total - answered;
+        console.log();
+        printKeyValue('Answered', chalk.green.bold(`${answered}/${total}`));
+        if (unanswered > 0) {
+            const missing = state.questions
+                .filter((q) => !state.answers[q.number])
+                .map((q) => q.number)
+                .join(', ');
+            printKeyValue('Unanswered', chalk.yellow(`${unanswered} (Q${missing})`));
+        }
+        console.log();
+        console.log(chalk.gray('  Ready? Use "exam submit" to submit for grading.'));
+    });
+    // ─── exam submit ───
+    exam
+        .command('submit')
+        .description('Submit exam for grading')
+        .action(async () => {
+        logCommand('exam submit');
+        const state = getExamState();
+        if (!state) {
+            printError('No exam in progress.');
+            return;
+        }
+        const answered = Object.keys(state.answers).length;
+        const total = state.session.questionCount;
+        const unanswered = total - answered;
+        let msg = `Submit ${answered}/${total} answers?`;
+        if (unanswered > 0) {
+            msg += chalk.yellow(` ${unanswered} unanswered.`);
+        }
+        msg += ' This cannot be undone.';
+        const proceed = await confirm({ message: msg, default: false });
+        if (!proceed)
+            return;
+        const client = requireExamConnection();
+        if (!client)
+            return;
+        console.log();
+        try {
+            drawProgress(0, 'Uploading answers...');
+            const result = await client.submitExam(state.session.examId, state.answers);
+            drawProgress(50, 'Grading...');
+            await sleep(300);
+            drawProgress(100, 'Complete!');
+            console.log();
+            clearExamState();
+            console.log();
+            printHeader('Exam Result');
+            printKeyValue('Score', chalk.bold(`${result.score}/${result.total}`));
+            printKeyValue('Percentage', chalk.bold(`${result.percentage}%`));
+            printKeyValue('Status', result.passed ? chalk.green.bold('PASSED') : chalk.red.bold('NOT PASSED'));
+            console.log();
+        }
+        catch (err) {
+            console.log();
+            printError(err.message);
+        }
+    });
+    // ─── exam result ───
+    exam
+        .command('result [id]')
+        .description('View exam result')
+        .action(async (examId) => {
+        logCommand(`exam result ${examId || ''}`);
+        const client = requireExamConnection();
+        if (!client)
+            return;
+        if (!examId) {
+            const state = getExamState();
+            if (state) {
+                examId = state.session.examId;
+            }
+            else {
+                printError('Specify exam ID: exam result <id>');
+                return;
+            }
+        }
+        const spinner = createSpinner('Loading result...');
+        spinner.start();
+        try {
+            const result = await client.getResult(examId);
+            spinner.succeed('Result loaded');
+            console.log();
+            printHeader(result.examName);
+            printKeyValue('Score', chalk.bold(`${result.score}/${result.total}`));
+            printKeyValue('Percentage', chalk.bold(`${result.percentage}%`));
+            printKeyValue('Status', result.passed ? chalk.green.bold('PASSED') : chalk.red.bold('NOT PASSED'));
+            printKeyValue('Submitted', result.submittedAt);
+            console.log();
+        }
+        catch (err) {
+            spinner.fail('Failed to load result');
+            printError(err.message);
+        }
+    });
+    // Default action: show status or help
+    exam.action(() => {
+        logCommand('exam');
+        const state = getExamState();
+        if (state) {
+            printHeader(`In Progress: ${state.session.examName}`);
+            printTimeRemaining();
+            const answered = Object.keys(state.answers).length;
+            printKeyValue('Progress', `${answered}/${state.session.questionCount} answered`);
+            console.log();
+            console.log(chalk.gray('  exam q [n]  | exam answer <n> <A-D> | exam review | exam submit'));
+        }
+        else {
+            printInfo('No exam in progress. Use "exam list" to see available exams.');
+        }
+    });
+}

package/dist/commands/files.js

@@ -13,7 +13,7 @@ export function registerFilesCommand(program) {
         logCommand(`files ${id}`);
         const config = getConfig();
         if (!isConnected()) {
-            printError('Not connected. Run: icoa ctf join <url>');
+            printError('Not connected. Run: join <url>');
             return;
         }
         const client = new CTFdClient(config.ctfdUrl, config.token);