icoa-cli 1.7.2 → 1.8.0

package/dist/commands/log.js

@@ -1,36 +1,163 @@
 import chalk from 'chalk';
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { getSessionLog } from '../lib/logger.js';
+import { getIcoaDir, getConfig } from '../lib/config.js';
 import { printHeader, printInfo, printTable } from '../lib/ui.js';
 export function registerLogCommand(program) {
-    program
+    const logCmd = program
         .command('log')
         .description('Display session history')
         .action(() => {
-        const entries = getSessionLog();
-        if (entries.length === 0) {
-            printInfo('No session log entries yet.');
-            return;
-        }
-        printHeader('Session Log');
-        const rows = entries.map((entry) => {
-            const time = entry.timestamp.replace('T', ' ').substring(0, 19);
-            const levelColor = {
-                A: chalk.green,
-                B: chalk.yellow,
-                C: chalk.red,
-                command: chalk.blue,
-                submit: chalk.magenta,
-            };
-            const colorFn = levelColor[entry.level] || chalk.gray;
-            const input = entry.input.length > 60 ? entry.input.substring(0, 57) + '...' : entry.input;
-            return [
-                chalk.gray(time),
-                colorFn(entry.level.padEnd(7)),
-                input,
-            ];
-        });
-        printTable(['Time', 'Type', 'Content'], rows);
-        console.log(chalk.gray(`  ${entries.length} entries total`));
-        console.log();
+        showLog();
+    });
+    // icoa log export — export full audit log for post-competition review
+    logCmd
+        .command('export')
+        .description('Export full audit log for review')
+        .action(async () => {
+        await exportLog();
+    });
+    // icoa log stats — show summary statistics
+    logCmd
+        .command('stats')
+        .description('Show session statistics')
+        .action(() => {
+        showStats();
+    });
+}
+function showLog() {
+    const entries = getSessionLog();
+    if (entries.length === 0) {
+        printInfo('No session log entries yet.');
+        return;
+    }
+    printHeader('Session Log');
+    const rows = entries.map((entry) => {
+        const time = entry.timestamp.replace('T', ' ').substring(0, 19);
+        const levelColor = {
+            A: chalk.green,
+            B: chalk.yellow,
+            C: chalk.red,
+            command: chalk.blue,
+            submit: chalk.magenta,
+        };
+        const colorFn = levelColor[entry.level] || chalk.gray;
+        const input = entry.input.length > 60 ? entry.input.substring(0, 57) + '...' : entry.input;
+        return [
+            chalk.gray(time),
+            colorFn(entry.level.padEnd(7)),
+            input,
+        ];
+    });
+    printTable(['Time', 'Type', 'Content'], rows);
+    console.log(chalk.gray(`  ${entries.length} entries total`));
+    console.log();
+}
+async function exportLog() {
+    const config = getConfig();
+    const icoaDir = getIcoaDir();
+    const logFile = join(icoaDir, 'session.log');
+    const sessionFile = join(icoaDir, 'session-state.json');
+    const configFile = join(icoaDir, 'config.json');
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
+    const userName = config.userName || 'unknown';
+    const exportName = `icoa-audit-${userName}-${timestamp}.json`;
+    const exportPath = join(process.cwd(), exportName);
+    // Gather all audit data
+    const audit = {
+        exportedAt: new Date().toISOString(),
+        version: '1.7.2',
+        competitor: {
+            userName: config.userName,
+            userId: config.userId,
+            teamName: config.teamName,
+            teamId: config.teamId,
+            sessionId: config.sessionId,
+        },
+        connection: {
+            ctfdUrl: config.ctfdUrl,
+        },
+        session: existsSync(sessionFile) ? JSON.parse(readFileSync(sessionFile, 'utf-8')) : null,
+        commands: getSessionLog(),
+    };
+    // Count by type
+    const entries = getSessionLog();
+    const counts = {};
+    for (const e of entries) {
+        counts[e.level] = (counts[e.level] || 0) + 1;
+    }
+    audit.summary = {
+        totalCommands: entries.length,
+        byType: counts,
+        firstEntry: entries[0]?.timestamp || null,
+        lastEntry: entries[entries.length - 1]?.timestamp || null,
+    };
+    // Write export
+    const { writeFileSync } = await import('node:fs');
+    writeFileSync(exportPath, JSON.stringify(audit, null, 2));
+    console.log();
+    console.log(chalk.green(`  ✓ Audit log exported`));
+    console.log(chalk.white(`  ${exportPath}`));
+    console.log();
+    console.log(chalk.gray('  Contents:'));
+    console.log(chalk.gray(`    Commands: ${entries.length}`));
+    Object.entries(counts).forEach(([type, count]) => {
+        console.log(chalk.gray(`    ${type}: ${count}`));
     });
+    console.log();
+    console.log(chalk.gray('  This file contains the complete session audit trail.'));
+    console.log(chalk.gray('  Submit to organizers for post-competition verification.'));
+    console.log();
+}
+function showStats() {
+    const entries = getSessionLog();
+    const icoaDir = getIcoaDir();
+    const sessionFile = join(icoaDir, 'session-state.json');
+    console.log();
+    console.log(chalk.bold.white('  Session Statistics'));
+    console.log(chalk.gray('  ─────────────────────────────────────────────'));
+    if (entries.length === 0) {
+        console.log(chalk.gray('  No activity recorded yet.'));
+        console.log();
+        return;
+    }
+    // Time range
+    const first = new Date(entries[0].timestamp);
+    const last = new Date(entries[entries.length - 1].timestamp);
+    const durationMin = Math.round((last.getTime() - first.getTime()) / 60000);
+    console.log(chalk.gray('  First activity:  ') + chalk.white(first.toLocaleString()));
+    console.log(chalk.gray('  Last activity:   ') + chalk.white(last.toLocaleString()));
+    console.log(chalk.gray('  Duration:        ') + chalk.white(`${durationMin} min`));
+    console.log();
+    // Count by type
+    const counts = {};
+    for (const e of entries) {
+        counts[e.level] = (counts[e.level] || 0) + 1;
+    }
+    console.log(chalk.gray('  Total commands:  ') + chalk.white(String(entries.length)));
+    if (counts['command'])
+        console.log(chalk.blue('    commands:      ') + chalk.white(String(counts['command'])));
+    if (counts['A'])
+        console.log(chalk.green('    hint A:        ') + chalk.white(String(counts['A'])));
+    if (counts['B'])
+        console.log(chalk.yellow('    hint B:        ') + chalk.white(String(counts['B'])));
+    if (counts['C'])
+        console.log(chalk.red('    hint C:        ') + chalk.white(String(counts['C'])));
+    if (counts['submit'])
+        console.log(chalk.magenta('    submissions:   ') + chalk.white(String(counts['submit'])));
+    // Exit info
+    if (existsSync(sessionFile)) {
+        try {
+            const session = JSON.parse(readFileSync(sessionFile, 'utf-8'));
+            console.log();
+            console.log(chalk.gray('  Exit count:      ') + chalk.white(String(session.exitCount || 0)));
+            if (session.totalAwaySeconds) {
+                const awayMin = Math.round(session.totalAwaySeconds / 60);
+                console.log(chalk.gray('  Total away:      ') + chalk.white(`${awayMin} min`));
+            }
+        }
+        catch { /* ignore */ }
+    }
+    console.log();
 }

package/dist/index.js

@@ -36,7 +36,7 @@ ${LINE}
    ${chalk.white('Sydney, Australia')}  ${chalk.gray('Jun 27 - Jul 2, 2026')}
    ${chalk.cyan.underline('https://icoa2026.au')}
 
-   ${chalk.gray('CLI-Native Competition Terminal  v1.7.2')}
+   ${chalk.gray('CLI-Native Competition Terminal  v1.8.0')}
 
 ${LINE}
 `;

package/dist/lib/log-sync.d.ts

@@ -0,0 +1,2 @@
+export declare function startLogSync(): void;
+export declare function stopLogSync(): void;

package/dist/lib/log-sync.js

@@ -0,0 +1,92 @@
+import { readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getIcoaDir, getConfig } from './config.js';
+const SYNC_INTERVAL = 30_000; // 30 seconds
+const SYNC_STATE_FILE = () => join(getIcoaDir(), 'sync-state.json');
+let syncTimer = null;
+function getSyncState() {
+    const file = SYNC_STATE_FILE();
+    if (!existsSync(file))
+        return { lastSyncedLine: 0, lastSyncAt: null, syncCount: 0, failCount: 0 };
+    try {
+        return JSON.parse(readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return { lastSyncedLine: 0, lastSyncAt: null, syncCount: 0, failCount: 0 };
+    }
+}
+function saveSyncState(state) {
+    writeFileSync(SYNC_STATE_FILE(), JSON.stringify(state, null, 2));
+}
+async function syncLogs() {
+    const config = getConfig();
+    if (!config.ctfdUrl)
+        return; // Not connected, skip
+    const logPath = join(getIcoaDir(), 'session.log');
+    if (!existsSync(logPath))
+        return;
+    const state = getSyncState();
+    const allLines = readFileSync(logPath, 'utf-8').trim().split('\n').filter(Boolean);
+    // Only send new lines since last sync
+    const newLines = allLines.slice(state.lastSyncedLine);
+    if (newLines.length === 0)
+        return;
+    const payload = {
+        userId: config.userId,
+        userName: config.userName,
+        teamId: config.teamId,
+        sessionId: config.sessionId,
+        deviceFingerprint: config.deviceFingerprint,
+        timestamp: new Date().toISOString(),
+        entries: newLines.map(line => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return { raw: line };
+            }
+        }),
+    };
+    try {
+        // POST to CTFd server audit endpoint
+        const url = new URL('/api/v1/audit/logs', config.ctfdUrl).href;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Token ${config.token}`,
+            },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(10_000), // 10s timeout
+        });
+        if (res.ok) {
+            state.lastSyncedLine = allLines.length;
+            state.lastSyncAt = new Date().toISOString();
+            state.syncCount++;
+            saveSyncState(state);
+        }
+        else {
+            state.failCount++;
+            saveSyncState(state);
+        }
+    }
+    catch {
+        // Silent fail — network issues shouldn't break the CLI
+        state.failCount++;
+        saveSyncState(state);
+    }
+}
+export function startLogSync() {
+    // Initial sync after 5 seconds
+    setTimeout(() => syncLogs(), 5_000);
+    // Then every 30 seconds
+    syncTimer = setInterval(() => syncLogs(), SYNC_INTERVAL);
+}
+export function stopLogSync() {
+    if (syncTimer) {
+        clearInterval(syncTimer);
+        syncTimer = null;
+    }
+    // Final sync before exit
+    syncLogs();
+}

package/dist/repl.js

@@ -5,8 +5,10 @@ import { isConnected, getConfig } from './lib/config.js';
 import { isActivated, activateToken, isFreeCommand, isDeviceMatch, recordExit, recordResume, isFirstRunOrUpgrade, markVersionSeen } from './lib/access.js';
 import { resetTerminalTheme } from './lib/theme.js';
 import { ensureSandbox, runInSandbox, isDockerAvailable } from './lib/sandbox.js';
+import { logCommand } from './lib/logger.js';
+import { startLogSync, stopLogSync } from './lib/log-sync.js';
 const INTERCEPT = '__REPL_NO_EXIT__';
-const VERSION = '1.7.2';
+const VERSION = '1.8.0';
 export async function startRepl(program, resumeMode) {
     const config = getConfig();
     const connected = isConnected();
@@ -115,6 +117,8 @@ export async function startRepl(program, resumeMode) {
         terminal: true,
     });
     let processing = false;
+    // Start background log sync (every 30s to server)
+    startLogSync();
     rl.prompt();
     rl.on('line', async (line) => {
         if (processing)
@@ -124,8 +128,11 @@ export async function startRepl(program, resumeMode) {
             rl.prompt();
             return;
         }
+        // Log ALL commands for audit trail
+        logCommand(input);
         // Exit — record, reset terminal colors, and quit
         if (input === 'exit' || input === 'quit' || input === 'q') {
+            stopLogSync();
             recordExit();
             console.log(chalk.gray('  Session saved. Use ') + chalk.white('icoa --resume') + chalk.gray(' to continue.'));
             resetTerminalTheme();
@@ -182,8 +189,8 @@ export async function startRepl(program, resumeMode) {
         const knownCommands = [
             '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', 'env', 'model', 'ctf',
+            'hint-budget', 'ref', 'shell', 'files', 'connect', 'note',
+            'log', 'lang', 'setup', 'env', 'model', 'ctf',
         ];
         if (!knownCommands.includes(cmd)) {
             // Route to Docker sandbox if available, otherwise system shell
@@ -238,6 +245,7 @@ export async function startRepl(program, resumeMode) {
         rl.prompt();
     });
     rl.on('close', () => {
+        stopLogSync();
         recordExit();
         resetTerminalTheme();
         realExit(0);

package/package.json

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