icoa-cli 2.19.355 → 2.19.357

package/dist/lib/aienv.js

@@ -1 +1,205 @@
-import{posix as o,win32 as t}from"node:path";export const REQUIRED_PY={major:3,minor:12};export const AIENV_MARKER_VERSION=2;export const AIENV_PACKAGES=[{name:"jupyter_client",import:"jupyter_client",spec:"jupyter_client>=8.6",group:"core"},{name:"ipykernel",import:"ipykernel",spec:"ipykernel>=6.29",group:"core"},{name:"numpy",import:"numpy",spec:"numpy>=1.26",group:"data"},{name:"scipy",import:"scipy",spec:"scipy>=1.13",group:"data"},{name:"pandas",import:"pandas",spec:"pandas>=2.2",group:"data"},{name:"scikit-learn",import:"sklearn",spec:"scikit-learn>=1.4",group:"data"},{name:"matplotlib",import:"matplotlib",spec:"matplotlib>=3.8",group:"data"},{name:"scikit-image",import:"skimage",spec:"scikit-image>=0.23",group:"data"},{name:"Pillow",import:"PIL",spec:"Pillow>=10.2",group:"data",probe:"from PIL import Image"},{name:"imageio",import:"imageio",spec:"imageio>=2.34",group:"data"},{name:"requests",import:"requests",spec:"requests>=2.31",group:"data"},{name:"pyyaml",import:"yaml",spec:"pyyaml>=6.0",group:"data"},{name:"tqdm",import:"tqdm",spec:"tqdm>=4.66",group:"data"},{name:"torch",import:"torch",spec:"torch>=2.2",group:"deep",note:"large download (~2 GB)"},{name:"transformers",import:"transformers",spec:"transformers>=4.40",group:"deep"},{name:"datasets",import:"datasets",spec:"datasets>=2.19",group:"deep"},{name:"mujoco",import:"mujoco",spec:"mujoco==3.9.0",group:"physics",note:"CPU physics for the ctf4eai arena (~60 MB, version-pinned for fair judging)"}];export function packagesForGroups(o){const t=new Set(o);return AIENV_PACKAGES.filter(o=>t.has(o.group))}export function aienvPaths(n,r=process.platform){const e="win32"===r?t:o,p=e.join(n,".icoa","aienv");if("win32"===r){const o=e.join(p,"Scripts");return{root:p,binDir:o,python:e.join(o,"python.exe"),pip:e.join(o,"pip.exe"),marker:e.join(p,"icoa-aienv.json")}}const i=e.join(p,"bin");return{root:p,binDir:i,python:e.join(i,"python"),pip:e.join(i,"pip"),marker:e.join(p,"icoa-aienv.json")}}export function icoaStandalonePython(n,r=process.platform){const e="win32"===r?t:o;return"win32"===r?e.join(n,".icoa","python312","python.exe"):e.join(n,".icoa","python312","bin","python3.12")}export function hostPythonCandidates(o=process.platform,t){const n=t?[icoaStandalonePython(t,o)]:[];return"win32"===o?["py -3.12",...n,"python","py -3","py"]:"darwin"===o?["python3.12","/opt/homebrew/opt/python@3.12/bin/python3.12","/usr/local/opt/python@3.12/bin/python3.12","python3"]:["python3.12",...n,"python3"]}export function parsePyVersion(o){if(!o)return null;const t=o.match(/(\d+)\.(\d+)(?:\.\d+)?/);return t?{major:Number(t[1]),minor:Number(t[2])}:null}export function meetsMinPy(o,t){return o.major!==t.major?o.major>t.major:o.minor>=t.minor}export function resolveHostPython(o,t=process.platform,n){for(const r of hostPythonCandidates(t,n)){const t=parsePyVersion(o(r));if(t&&t.major===REQUIRED_PY.major&&t.minor===REQUIRED_PY.minor)return{cmd:r,version:t}}return null}export function importCheckCmd(o,t){return`"${o}" -c "${t.probe??`import ${t.import}`}"`}
+/**
+ * aienv — the AI/ML notebook-arena environment (Phase 0 of the CLI notebook
+ * arena, see `project_cli_notebook_arena_plan`).
+ *
+ * This is the PURE, testable core. The orchestration (venv creation, pip
+ * installs, status rendering) lives in `src/commands/aienv.ts`.
+ *
+ * Hard rule (BUG3 / Team Indonesia): aienv provisions its OWN venv under
+ * ~/.icoa/aienv and NEVER repoints the system python3. It also stays fully
+ * independent of `env.ts` so the heavy ML stack (jupyter/numpy/torch...) can
+ * never drag down the lightweight exam-only `env setup` path, and so a broken
+ * ML install is fault-isolated from the competition toolkit.
+ */
+import { posix as pathPosix, win32 as pathWin32 } from 'node:path';
+// The host python aienv builds its venv from is LOCKED to the 3.12 line — the
+// same minor version env.ts (the exam env) installs/targets. Locking the minor
+// version pins the cp312 wheel ABI, so every student's ML stack
+// (numpy/pandas/scikit-learn/torch...) resolves to the SAME mature, well-tested
+// wheels: uniform across the cohort + parity with the server's fixed-model box.
+// We accept any 3.12.x PATCH (patch is a floor, like env.ts) but deliberately
+// refuse 3.10 / 3.11 / 3.13 — version fragmentation and wheel-availability gaps
+// are exactly what we're avoiding. No 3.12 → an actionable "install it" error.
+export const REQUIRED_PY = { major: 3, minor: 12 };
+// The marker schema version — bump when the marker shape or the package set
+// changes in a way that should trigger a re-setup.
+// v2 (2026-06-22): data group expanded with scipy / scikit-image / Pillow /
+// imageio / requests / pyyaml / tqdm. Re-run `aienv setup` to pull the new ones
+// (the install loop adds only the missing packages).
+export const AIENV_MARKER_VERSION = 2;
+/**
+ * ML stack for the notebook arena.
+ *
+ * Versions are FLOOR-pinned (`>=`), not exact-pinned like the CTF toolkit in
+ * env.ts. The scientific/ML stack ships platform- and arch-specific wheels that
+ * churn fast; exact pins across macOS/Linux/WSL × x64/arm64 routinely fail wheel
+ * resolution. Phase 0 only provisions — fairness-critical determinism lives
+ * server-side on the (fixed-model) GPU box, not in the student's local venv.
+ *
+ *  - core: the Jupyter kernel-protocol foundation Phase 1's cell loop talks to.
+ *  - data: the everyday data-science stack students compute with on CPU.
+ *  - deep: multi-GB DL stack — OPT-IN via `aienv setup --deep` only. Under the
+ *    fixed-model GPU design, most students call the server's inference API and
+ *    never need torch locally, so it must not be in the default footprint.
+ */
+export const AIENV_PACKAGES = [
+    // ── core (Jupyter kernel protocol) ──────────────────────────────────────
+    { name: 'jupyter_client', import: 'jupyter_client', spec: 'jupyter_client>=8.6', group: 'core' },
+    { name: 'ipykernel', import: 'ipykernel', spec: 'ipykernel>=6.29', group: 'core' },
+    // ── data (CPU compute surface) ──────────────────────────────────────────
+    // NB: pip name ≠ import name for several — Pillow→PIL, scikit-image→skimage,
+    // scikit-learn→sklearn, pyyaml→yaml. The `import` field is the readiness probe.
+    { name: 'numpy', import: 'numpy', spec: 'numpy>=1.26', group: 'data' },
+    { name: 'scipy', import: 'scipy', spec: 'scipy>=1.13', group: 'data' },
+    { name: 'pandas', import: 'pandas', spec: 'pandas>=2.2', group: 'data' },
+    { name: 'scikit-learn', import: 'sklearn', spec: 'scikit-learn>=1.4', group: 'data' },
+    { name: 'matplotlib', import: 'matplotlib', spec: 'matplotlib>=3.8', group: 'data' },
+    { name: 'scikit-image', import: 'skimage', spec: 'scikit-image>=0.23', group: 'data' },
+    // probe: `import PIL` passes even when the `_imaging` C extension is broken
+    // (the env.ts ABI-shadow lesson). Exercise the real usable import instead.
+    { name: 'Pillow', import: 'PIL', spec: 'Pillow>=10.2', group: 'data', probe: 'from PIL import Image' },
+    { name: 'imageio', import: 'imageio', spec: 'imageio>=2.34', group: 'data' },
+    { name: 'requests', import: 'requests', spec: 'requests>=2.31', group: 'data' },
+    { name: 'pyyaml', import: 'yaml', spec: 'pyyaml>=6.0', group: 'data' },
+    { name: 'tqdm', import: 'tqdm', spec: 'tqdm>=4.66', group: 'data' },
+    // ── deep (opt-in, multi-GB) ─────────────────────────────────────────────
+    { name: 'torch', import: 'torch', spec: 'torch>=2.2', group: 'deep', note: 'large download (~2 GB)' },
+    { name: 'transformers', import: 'transformers', spec: 'transformers>=4.40', group: 'deep' },
+    { name: 'datasets', import: 'datasets', spec: 'datasets>=2.19', group: 'deep' },
+    // ── physics (opt-in, ctf4eai MuJoCo-physics arena) ──────────────────────
+    // EXACT-pinned (== not >=) — the one deliberate deviation from the floor-pin
+    // rule above. The ctf4eai physics judge is fairness-critical: contact-solver
+    // behaviour can shift between MuJoCo minor versions, so the student self-check
+    // and the server judge MUST agree on one version (arena-design risk #3). A
+    // single pure-CPU cp312 wheel, headless (mj_step needs no renderer).
+    {
+        name: 'mujoco',
+        import: 'mujoco',
+        spec: 'mujoco==3.9.0',
+        group: 'physics',
+        note: 'CPU physics for the ctf4eai arena (~60 MB, version-pinned for fair judging)',
+    },
+];
+export function packagesForGroups(groups) {
+    const want = new Set(groups);
+    return AIENV_PACKAGES.filter((p) => want.has(p.group));
+}
+/** Compute the venv paths for a given home directory + platform. */
+export function aienvPaths(home, plat = process.platform) {
+    // Use the platform-specific path flavour keyed off `plat` (not the host) so a
+    // win32 result has backslashes even when computed on a posix box, and vice
+    // versa — deterministic and testable.
+    const p = plat === 'win32' ? pathWin32 : pathPosix;
+    const root = p.join(home, '.icoa', 'aienv');
+    if (plat === 'win32') {
+        const binDir = p.join(root, 'Scripts');
+        return {
+            root,
+            binDir,
+            python: p.join(binDir, 'python.exe'),
+            pip: p.join(binDir, 'pip.exe'),
+            marker: p.join(root, 'icoa-aienv.json'),
+        };
+    }
+    const binDir = p.join(root, 'bin');
+    return {
+        root,
+        binDir,
+        python: p.join(binDir, 'python'),
+        pip: p.join(binDir, 'pip'),
+        marker: p.join(root, 'icoa-aienv.json'),
+    };
+}
+/**
+ * Absolute path to the icoa-provisioned standalone CPython 3.12. `env setup`
+ * installs a relocatable python-build-standalone build here ONLY on Linux
+ * distros where neither apt nor the Ubuntu deadsnakes PPA can deliver 3.12
+ * (e.g. Kali / non-Ubuntu Debian). Side-by-side: the system python3 is never
+ * touched. On the four already-supported platforms this path simply never
+ * exists, so probing it is a no-op.
+ */
+export function icoaStandalonePython(home, plat = process.platform) {
+    const p = plat === 'win32' ? pathWin32 : pathPosix;
+    return plat === 'win32'
+        ? p.join(home, '.icoa', 'python312', 'python.exe')
+        : p.join(home, '.icoa', 'python312', 'bin', 'python3.12');
+}
+/**
+ * Ordered host-python candidates to build the venv from. We probe a versioned
+ * 3.12 BEFORE the bare `python3` so we don't accidentally seed the venv with a
+ * distro 3.10 when a 3.12 is present. We never touch the system python3 beyond
+ * reading its --version.
+ *
+ * When `home` is given, the icoa-provisioned standalone 3.12 (Kali / non-Ubuntu
+ * Debian — see icoaStandalonePython) is probed right after the on-PATH
+ * `python3.12` and before the distro `python3`. Omitting `home` (the default,
+ * and what the unit tests use) leaves the candidate list byte-identical to
+ * before, so the four working platforms are unaffected.
+ */
+export function hostPythonCandidates(plat = process.platform, home) {
+    const standalone = home ? [icoaStandalonePython(home, plat)] : [];
+    if (plat === 'win32') {
+        // The `py` launcher can target an exact minor; fall back to bare python.
+        return ['py -3.12', ...standalone, 'python', 'py -3', 'py'];
+    }
+    if (plat === 'darwin') {
+        return [
+            'python3.12',
+            '/opt/homebrew/opt/python@3.12/bin/python3.12',
+            '/usr/local/opt/python@3.12/bin/python3.12',
+            'python3',
+        ];
+    }
+    // linux / wsl / crostini
+    return ['python3.12', ...standalone, 'python3'];
+}
+/** Parse `Python 3.12.13` → {major:3, minor:12}. Tolerant of trailing newline. */
+export function parsePyVersion(out) {
+    if (!out)
+        return null;
+    const m = out.match(/(\d+)\.(\d+)(?:\.\d+)?/);
+    if (!m)
+        return null;
+    return { major: Number(m[1]), minor: Number(m[2]) };
+}
+/** True if `v` is at least `min` (major-then-minor comparison). */
+export function meetsMinPy(v, min) {
+    if (v.major !== min.major)
+        return v.major > min.major;
+    return v.minor >= min.minor;
+}
+/**
+ * Resolve the best host python to create the venv from.
+ *
+ * `probe(cmd)` runs `cmd --version` and returns its stdout (or null if the
+ * command is absent / errored) — injected so this stays pure + testable.
+ *
+ * Returns the first interpreter on the locked 3.12 line (any patch); otherwise
+ * null. We deliberately do NOT fall back to 3.10 / 3.11 / 3.13 — a uniform 3.12
+ * cohort is the whole point (see REQUIRED_PY). The caller surfaces an actionable
+ * "install Python 3.12" message when this is null.
+ */
+export function resolveHostPython(probe, plat = process.platform, home) {
+    for (const cmd of hostPythonCandidates(plat, home)) {
+        const version = parsePyVersion(probe(cmd));
+        if (!version)
+            continue;
+        if (version.major === REQUIRED_PY.major && version.minor === REQUIRED_PY.minor) {
+            return { cmd, version };
+        }
+    }
+    return null;
+}
+/**
+ * Build the readiness probe for one package, run via the VENV python (absolute
+ * path) — never the system python3. Mirrors env.ts's `python3 -c "import x"`
+ * convention but always targets the venv interpreter.
+ */
+export function importCheckCmd(venvPython, pkg) {
+    // A `probe` override exercises the real usable import (e.g. Pillow's
+    // `from PIL import Image`, which loads the `_imaging` C extension) so a
+    // package whose bare `import x` passes but is actually broken still reads as
+    // not-ready. Falls back to the plain `import x` for everything else.
+    const stmt = pkg.probe ?? `import ${pkg.import}`;
+    return `"${venvPython}" -c "${stmt}"`;
+}

package/dist/lib/arena-submit.js

@@ -1 +1,21 @@
-export function buildSubmitPayload(e,r,t){let i=e.trim();return i.startsWith("file://")&&(i=i.slice(7)),i&&t.exists(i)?{arena_token:r,predictions_csv:t.read(i),source:"local"}:{arena_token:r,gdrive_url:e.trim(),source:"gdrive"}}
+/**
+ * arena-submit — pure builder for an arena submission payload (Phase 3 of the
+ * CLI notebook arena). The all-in-CLI loop: a student computes in `icoa ipynb`,
+ * saves a local predictions.csv, and submits it here.
+ *
+ * If the input is a path that exists on disk, we send its CONTENT inline
+ * (`predictions_csv`) — this is what makes local submission work against a
+ * REMOTE server (prod can't read the student's disk, so a bare path is useless;
+ * the legacy Google-Drive link existed only to get the file TO the server).
+ * Otherwise we fall back to the Drive link (`gdrive_url`). Kept pure (fs deps
+ * injected) so the routing decision is unit-tested.
+ */
+export function buildSubmitPayload(input, arenaToken, deps) {
+    let path = input.trim();
+    if (path.startsWith('file://'))
+        path = path.slice('file://'.length);
+    if (path && deps.exists(path)) {
+        return { arena_token: arenaToken, predictions_csv: deps.read(path), source: 'local' };
+    }
+    return { arena_token: arenaToken, gdrive_url: input.trim(), source: 'gdrive' };
+}

package/dist/lib/banner.js

@@ -1 +1,31 @@
-import chalk from"chalk";export const ICOA_BIG=["██╗ ██████╗ ██████╗  █████╗","██║██╔════╝██╔═══██╗██╔══██╗","██║██║     ██║   ██║███████║","██║██║     ██║   ██║██╔══██║","██║╚██████╗╚██████╔╝██║  ██║","╚═╝ ╚═════╝ ╚═════╝ ╚═╝  ╚═╝"];export function icoaBannerLines(o="  "){return(process.stdout.columns||80)<60?[o+chalk.bold.white("I C O A")+chalk.gray("  2026")]:ICOA_BIG.map(t=>o+chalk.bold.white(t))}
+/**
+ * ICOA logo — single source of truth for the big block-letter "ICOA" art.
+ *
+ * Defined ONCE here and reused by the boot banner (src/index.ts) and the learn
+ * score screens (learn-render.ts) so the logo can never drift between surfaces
+ * (same anti-drift principle as docker/constraints.txt). Raw, uncolored rows;
+ * callers apply chalk + indent.
+ */
+import chalk from 'chalk';
+export const ICOA_BIG = [
+    '██╗ ██████╗ ██████╗  █████╗',
+    '██║██╔════╝██╔═══██╗██╔══██╗',
+    '██║██║     ██║   ██║███████║',
+    '██║██║     ██║   ██║██╔══██║',
+    '██║╚██████╗╚██████╔╝██║  ██║',
+    '╚═╝ ╚═════╝ ╚═════╝ ╚═╝  ╚═╝',
+];
+/**
+ * Ready-to-print logo lines, bold white, indented by `indent`.
+ *
+ * Degrades to a one-line wordmark when the terminal is too narrow for the block
+ * art (Chromebook split-screen / narrow WSL pane), so it never overflow-wraps.
+ * 60 cols is the rich-display floor from the cross-platform baseline.
+ */
+export function icoaBannerLines(indent = '  ') {
+    const cols = process.stdout.columns || 80;
+    if (cols < 60) {
+        return [indent + chalk.bold.white('I C O A') + chalk.gray('  2026')];
+    }
+    return ICOA_BIG.map((l) => indent + chalk.bold.white(l));
+}

package/dist/lib/budget.js

@@ -1 +1,6 @@
-import{getBudget as o,saveBudget as n}from"./config.js";export function addTokenUsage(e){const s=o();s.tokensUsed+=e,n(s)}
+import { getBudget, saveBudget } from './config.js';
+export function addTokenUsage(tokensUsed) {
+    const budget = getBudget();
+    budget.tokensUsed += tokensUsed;
+    saveBudget(budget);
+}

package/dist/lib/challenge-dir.js

@@ -1 +1,16 @@
-import{join as o}from"node:path";import{getActiveCwd as r}from"./exam-sandbox.js";export function challengeDownloadDir(n,e=r()){return o(e,n)}
+import { join } from 'node:path';
+import { getActiveCwd } from './exam-sandbox.js';
+// Single source of truth for where `files <id>` downloads challenge attachments
+// and where `view <id>` looks for them. They MUST agree, so both import this.
+//
+// Why under the active workspace (NOT the legacy ~/icoa-challenges/<id>): the
+// in-REPL shell runs every command with cwd = getActiveCwd() (~/icoa-workspace,
+// or the per-exam tmpdir), and the REPL path-guard (repl.ts) blocks any absolute
+// path outside that workspace plus all `..` traversal. A file dropped in
+// ~/icoa-challenges/<id> was therefore UNREACHABLE by ls/file/python/steghide —
+// fatal for steg/forensics challenges. Downloading into <workspace>/<id>/ keeps
+// the file reachable via the relative path `<id>/<file>` while still namespacing
+// per challenge so two challenges shipping the same filename never collide.
+export function challengeDownloadDir(id, base = getActiveCwd()) {
+    return join(base, id);
+}

package/dist/lib/colors.js

@@ -1 +1,17 @@
-const e=(e,n,o)=>t=>`[38;2;${e};${n};${o}m${t}`;export const c={fg:e(169,183,198),muted:e(85,85,85),red:e(255,107,104),green:e(168,192,35),yellow:e(214,191,85),blue:e(126,174,241),cyan:e(40,123,222),orange:e(204,120,50),white:e(255,255,255)};
+// Darcula palette — from ICOA Terminal xterm.js theme spec.
+// Use c.* helpers when you need brand-accurate truecolor (e.g. the orange
+// accent #CC7832). For generic success/error/warning, chalk.green/.red/.yellow
+// remain fine — they render as the terminal's Darcula 16-color when using an
+// ICOA theme and as close-enough defaults elsewhere.
+const tc = (r, g, b) => (s) => `\x1b[38;2;${r};${g};${b}m${s}\x1b[39m`;
+export const c = {
+    fg: tc(169, 183, 198), // #A9B7C6 body text
+    muted: tc(85, 85, 85), // #555555 comments / secondary
+    red: tc(255, 107, 104), // #FF6B68 error
+    green: tc(168, 192, 35), // #A8C023 success
+    yellow: tc(214, 191, 85), // #D6BF55 warning
+    blue: tc(126, 174, 241), // #7EAEF1 link
+    cyan: tc(40, 123, 222), // #287BDE command / path
+    orange: tc(204, 120, 50), // #CC7832 brand accent
+    white: tc(255, 255, 255), // #FFFFFF highlight
+};

package/dist/lib/comms.js

@@ -1 +1,212 @@
-import chalk from"chalk";import{getConfig as t}from"./config.js";const e=/\x1b\[[0-9;?]*[ -/]*[@-~]/g,o=/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;let n=!1;export function isCommsActive(){return n}export function setCommsActive(t){n=t}export function isLeaderToken(t){return/^LDR[A-Z0-9]{10,}$/i.test((t||"").trim())}export function isLeaderSession(){return Boolean(t().leaderToken)}export function isLeaderAccount(t){return(t||"").trim().toUpperCase().startsWith("TMLD")}export function sanitizeCommsLine(t){let n=(t??"").toString();return n=n.replace(e,""),n=n.replace(/[\r\n\t]/g," "),n=n.replace(o," "),n=n.replace(/\s+/g," ").trim(),n.slice(0,500)}export function commsBaseUrl(){return(t().ctfdUrl||"").replace(/\/+$/,"")}export function isCompetitionJoined(){const e=t();return Boolean((e.token||e.leaderToken)&&e.ctfdUrl&&e.userName)}export function isMelCompetition(){return isCompetitionJoined()&&function(t){try{return new URL(t).host}catch{return(t||"").replace(/^https?:\/\//,"").replace(/\/.*$/,"")}}(t().ctfdUrl).endsWith("au.icoa2026.au")}export function formatBroadcastBar(t){const e=sanitizeCommsLine(t);if(!e)return chalk.green("  ✓ No issues reported — enjoy the competition!");const o="─".repeat(49);return[chalk.yellow(`  ${o}`),chalk.bold.yellow("  ⚠  BROADCAST  ")+chalk.yellow(e),chalk.yellow(`  ${o}`)].join("\n")}function r(){const e=t(),o={"Content-Type":"application/json"};return e.token&&(o.Authorization=`Token ${e.token}`),o}export async function fetchBroadcast(){try{const t=await fetch(`${commsBaseUrl()}/api/icoa/broadcast`,{headers:r(),signal:AbortSignal.timeout(5e3)});if(!t.ok)return{text:"",ts:null};const e=await t.json(),o=e?.data??{};return{text:sanitizeCommsLine(o.text||""),ts:o.ts??null}}catch{return{text:"",ts:null}}}async function a(e,o){try{const n=await fetch(`${commsBaseUrl()}/api/icoa/${e}`,{method:"POST",headers:r(),body:JSON.stringify({text:sanitizeCommsLine(o),account:t().userName||"",leader_token:t().leaderToken||void 0}),signal:AbortSignal.timeout(8e3)}),a=await n.json().catch(()=>({}));return n.ok&&a?.success?{ok:!0,id:a.data?.id,ts:a.data?.ts,status:n.status}:{ok:!1,status:n.status,message:a?.message}}catch(t){return{ok:!1,status:0,message:t?.message||"network error"}}}export function postMemo(t){return a("memo",t)}export function postJury(t){return a("jury",t)}export async function leaderAuth(t,e){try{const o=await fetch(`${t.replace(/\/+$/,"")}/api/icoa/leader-auth`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({token:(e||"").trim()}),signal:AbortSignal.timeout(8e3)}),n=await o.json().catch(()=>({}));return o.ok&&n?.success&&n.data?.account?{account:String(n.data.account),team:String(n.data.team||"")}:null}catch{return null}}export async function fetchPublicScoreboard(){try{const t=await fetch(`${commsBaseUrl()}/api/v1/scoreboard`,{headers:{Accept:"application/json"},signal:AbortSignal.timeout(8e3)});if(!t.ok)return[];const e=await t.json().catch(()=>({}));return(Array.isArray(e?.data)?e.data:[]).map((t,e)=>({pos:t.pos??e+1,name:String(t.name??""),score:Number(t.score??0)}))}catch{return[]}}let s=null,c="",i=!1;export function showBroadcast(){console.log(),console.log(formatBroadcastBar(c))}export function startBroadcastPoll(t){if(s)return;const e=async()=>{const{text:e}=await fetchBroadcast(),o=e!==c;c=e,i&&o&&e&&(console.log(),console.log(formatBroadcastBar(e)),t()),i=!0};e(),s=setInterval(()=>{e()},45e3)}export function stopBroadcastPoll(){s&&clearInterval(s),s=null,c="",i=!1}
+import chalk from 'chalk';
+import { getConfig } from './config.js';
+const MEL_HOST = 'au.icoa2026.au';
+const MAX_TEXT_LEN = 500;
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+// eslint-disable-next-line no-control-regex
+const CTRL_RE = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;
+// Comms sub-screen (memo/jury) active flag. The main REPL wraps rl.prompt() to
+// force computePrompt() (→ `icoa 2026>`) on every prompt; chat/exam sub-modes
+// bypass that wrap via their own active flags. Memo/jury need the same, or the
+// wrapper clobbers their `icoa memo>` / `icoa jury>` prompt back to `icoa 2026>`.
+let _commsActive = false;
+export function isCommsActive() {
+    return _commsActive;
+}
+export function setCommsActive(active) {
+    _commsActive = active;
+}
+// A leader token (printed on the leader's card) — `LDR` + confusable-free body.
+// Typed at the join Username prompt; the CLI authenticates it via token-api
+// instead of doing a CTFd login, so the leader never gets a web session.
+export function isLeaderToken(s) {
+    return /^LDR[A-Z0-9]{10,}$/i.test((s || '').trim());
+}
+// A leader SESSION = authenticated by a leader token (config.leaderToken set).
+// Distinct from isLeaderAccount (name-prefix), which still gates legacy logins.
+export function isLeaderSession() {
+    return Boolean(getConfig().leaderToken);
+}
+export function isLeaderAccount(name) {
+    // Team-leader accounts use the `TMLD` prefix (confirmed 2026-06-23). This is
+    // collision-free: `ZZRH` and `ZZCP` are BOTH contestants (ZZRH = reused AU-camp
+    // student logins) and must never be blocked from challenges. Only `TMLD` gets
+    // the minimal leader REPL + the hidden `jury` command; everyone else competes.
+    // (Replaces the earlier broken `ZZRH`=leader rule and the interim fail-open.)
+    return (name || '').trim().toUpperCase().startsWith('TMLD');
+}
+export function sanitizeCommsLine(s) {
+    let out = (s ?? '').toString();
+    out = out.replace(ANSI_RE, '');
+    out = out.replace(/[\r\n\t]/g, ' ');
+    // remap (not delete) remaining control chars to space, matching comms_store.py
+    out = out.replace(CTRL_RE, ' ');
+    out = out.replace(/\s+/g, ' ').trim();
+    return out.slice(0, MAX_TEXT_LEN);
+}
+function hostOf(url) {
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        return (url || '').replace(/^https?:\/\//, '').replace(/\/.*$/, '');
+    }
+}
+export function commsBaseUrl() {
+    return (getConfig().ctfdUrl || '').replace(/\/+$/, '');
+}
+export function isCompetitionJoined() {
+    const c = getConfig();
+    // Contestants join with a CTFd token; leaders join with a leader token (no
+    // CTFd login). Either counts as "in the competition" for comms gating.
+    return Boolean((c.token || c.leaderToken) && c.ctfdUrl && c.userName);
+}
+export function isMelCompetition() {
+    return isCompetitionJoined() && hostOf(getConfig().ctfdUrl).endsWith(MEL_HOST);
+}
+export function formatBroadcastBar(text) {
+    const clean = sanitizeCommsLine(text);
+    if (!clean) {
+        return chalk.green('  ✓ No issues reported — enjoy the competition!');
+    }
+    const rule = '─'.repeat(49);
+    return [
+        chalk.yellow(`  ${rule}`),
+        chalk.bold.yellow('  ⚠  BROADCAST  ') + chalk.yellow(clean),
+        chalk.yellow(`  ${rule}`),
+    ].join('\n');
+}
+// ─── network ───
+function authHeaders() {
+    const c = getConfig();
+    const h = { 'Content-Type': 'application/json' };
+    if (c.token)
+        h.Authorization = `Token ${c.token}`;
+    return h;
+}
+export async function fetchBroadcast() {
+    try {
+        const res = await fetch(`${commsBaseUrl()}/api/icoa/broadcast`, {
+            headers: authHeaders(),
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!res.ok)
+            return { text: '', ts: null };
+        const json = await res.json();
+        const d = json?.data ?? {};
+        return { text: sanitizeCommsLine(d.text || ''), ts: d.ts ?? null };
+    }
+    catch {
+        return { text: '', ts: null };
+    }
+}
+async function postComms(kind, text) {
+    try {
+        const res = await fetch(`${commsBaseUrl()}/api/icoa/${kind}`, {
+            method: 'POST',
+            headers: authHeaders(),
+            // account = self-reported fallback for session-mode logins (no API token).
+            // leader_token = un-forgeable leader identity (server validates it) so a
+            // leader with no CTFd login can still file jury appeals.
+            // Server prefers token-verified > leader-token > self-reported account.
+            body: JSON.stringify({
+                text: sanitizeCommsLine(text),
+                account: getConfig().userName || '',
+                leader_token: getConfig().leaderToken || undefined,
+            }),
+            signal: AbortSignal.timeout(8000),
+        });
+        const json = await res.json().catch(() => ({}));
+        if (res.ok && json?.success) {
+            return { ok: true, id: json.data?.id, ts: json.data?.ts, status: res.status };
+        }
+        return { ok: false, status: res.status, message: json?.message };
+    }
+    catch (e) {
+        return { ok: false, status: 0, message: e?.message || 'network error' };
+    }
+}
+export function postMemo(text) {
+    return postComms('memo', text);
+}
+export function postJury(text) {
+    return postComms('jury', text);
+}
+// Authenticate a leader token against token-api. No CTFd login happens.
+// Returns the resolved account + team on success, null otherwise.
+export async function leaderAuth(baseUrl, token) {
+    try {
+        const res = await fetch(`${baseUrl.replace(/\/+$/, '')}/api/icoa/leader-auth`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ token: (token || '').trim() }),
+            signal: AbortSignal.timeout(8000),
+        });
+        const json = await res.json().catch(() => ({}));
+        if (res.ok && json?.success && json.data?.account) {
+            return { account: String(json.data.account), team: String(json.data.team || '') };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+// Read the PUBLIC CTFd scoreboard (score_visibility=public → no auth needed).
+// Leaders use this since they have no CTFd session. Returns [] on any failure.
+export async function fetchPublicScoreboard() {
+    try {
+        const res = await fetch(`${commsBaseUrl()}/api/v1/scoreboard`, {
+            headers: { Accept: 'application/json' },
+            signal: AbortSignal.timeout(8000),
+        });
+        if (!res.ok)
+            return [];
+        const json = await res.json().catch(() => ({}));
+        const data = Array.isArray(json?.data) ? json.data : [];
+        return data.map((e, i) => ({
+            pos: e.pos ?? i + 1,
+            name: String(e.name ?? ''),
+            score: Number(e.score ?? 0),
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+// ─── background poll + render ───
+let pollTimer = null;
+let cachedText = '';
+let primed = false;
+export function showBroadcast() {
+    console.log();
+    console.log(formatBroadcastBar(cachedText));
+}
+export function startBroadcastPoll(redraw) {
+    if (pollTimer)
+        return;
+    const tick = async () => {
+        const { text } = await fetchBroadcast();
+        const changed = text !== cachedText;
+        cachedText = text;
+        // Print a fresh alert when the text changes after the first prime — never
+        // on the very first fetch (that would clobber the join screen), and only a
+        // non-empty change is loud (clearing is silent).
+        if (primed && changed && text) {
+            console.log();
+            console.log(formatBroadcastBar(text));
+            redraw();
+        }
+        primed = true;
+    };
+    void tick();
+    pollTimer = setInterval(() => void tick(), 45_000);
+}
+export function stopBroadcastPoll() {
+    if (pollTimer)
+        clearInterval(pollTimer);
+    pollTimer = null;
+    cachedText = '';
+    primed = false;
+}

package/dist/lib/config.js

@@ -1 +1,93 @@
-import{mkdirSync as t,readFileSync as n,writeFileSync as o,existsSync as r,chmodSync as e,statSync as i}from"node:fs";import{join as c}from"node:path";import{homedir as f}from"node:os";import{randomUUID as s}from"node:crypto";import{DEFAULT_CONFIG as u,DEFAULT_BUDGET as g}from"../types/index.js";const p=c(f(),".icoa"),d=c(p,"config.json"),m=c(p,"budget.json");function a(t,n){o(t,n);try{e(t,384)}catch{}}function y(t){try{63&i(t).mode&&e(t,384)}catch{}}function l(){r(p)||t(p,{recursive:!0,mode:448})}export function getConfig(){if(l(),!r(d)){const t={...u,sessionId:s()};return a(d,JSON.stringify(t,null,2)),t}y(d);try{const t=n(d,"utf-8");return{...u,...JSON.parse(t)}}catch{return{...u,sessionId:s()}}}export function saveConfig(t){l();const n={...getConfig(),...t};a(d,JSON.stringify(n,null,2))}export function getBudget(){if(l(),!r(m))return a(m,JSON.stringify(g,null,2)),{...g};y(m);try{const t=n(m,"utf-8");return{...g,...JSON.parse(t)}}catch{return{...g}}}export function saveBudget(t){l(),a(m,JSON.stringify(t,null,2))}export function getIcoaDir(){return l(),p}export function isConnected(){const t=getConfig();return!(!t.ctfdUrl||!t.token)}
+import { mkdirSync, readFileSync, writeFileSync, existsSync, chmodSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { DEFAULT_CONFIG, DEFAULT_BUDGET } from '../types/index.js';
+const ICOA_DIR = join(homedir(), '.icoa');
+const CONFIG_FILE = join(ICOA_DIR, 'config.json');
+const BUDGET_FILE = join(ICOA_DIR, 'budget.json');
+// V16 fix (v2.19.181): config.json holds the exam token, geminiApiKey, and
+// accessToken in plaintext. On shared/multi-user hosts (school labs, family
+// machines) a world-readable 0o644 leaks them to anyone with a shell. We
+// force 0o600 (owner-only read/write) at every write, and proactively re-
+// chmod on read for files created before this fix.
+function writePrivate(path, contents) {
+    // Write first so we can chmod afterwards. The Node fs.writeFile mode
+    // option only applies on file CREATION, not existing files — chmodSync
+    // is the reliable cross-platform path. Best-effort on Windows where
+    // POSIX modes don't apply.
+    writeFileSync(path, contents);
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        /* ignore — Windows/restricted FS */
+    }
+}
+function ensurePrivateMode(path) {
+    // For files written by older versions at 0o644: tighten on first read.
+    try {
+        const st = statSync(path);
+        // Mode low bits: group + other. If any non-zero, tighten.
+        if ((st.mode & 0o077) !== 0) {
+            chmodSync(path, 0o600);
+        }
+    }
+    catch {
+        /* ignore */
+    }
+}
+function ensureDir() {
+    if (!existsSync(ICOA_DIR)) {
+        mkdirSync(ICOA_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+export function getConfig() {
+    ensureDir();
+    if (!existsSync(CONFIG_FILE)) {
+        const config = { ...DEFAULT_CONFIG, sessionId: randomUUID() };
+        writePrivate(CONFIG_FILE, JSON.stringify(config, null, 2));
+        return config;
+    }
+    ensurePrivateMode(CONFIG_FILE);
+    try {
+        const raw = readFileSync(CONFIG_FILE, 'utf-8');
+        return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG, sessionId: randomUUID() };
+    }
+}
+export function saveConfig(config) {
+    ensureDir();
+    const current = getConfig();
+    const merged = { ...current, ...config };
+    writePrivate(CONFIG_FILE, JSON.stringify(merged, null, 2));
+}
+export function getBudget() {
+    ensureDir();
+    if (!existsSync(BUDGET_FILE)) {
+        writePrivate(BUDGET_FILE, JSON.stringify(DEFAULT_BUDGET, null, 2));
+        return { ...DEFAULT_BUDGET };
+    }
+    ensurePrivateMode(BUDGET_FILE);
+    try {
+        const raw = readFileSync(BUDGET_FILE, 'utf-8');
+        return { ...DEFAULT_BUDGET, ...JSON.parse(raw) };
+    }
+    catch {
+        return { ...DEFAULT_BUDGET };
+    }
+}
+export function saveBudget(budget) {
+    ensureDir();
+    writePrivate(BUDGET_FILE, JSON.stringify(budget, null, 2));
+}
+export function getIcoaDir() {
+    ensureDir();
+    return ICOA_DIR;
+}
+export function isConnected() {
+    const config = getConfig();
+    return !!(config.ctfdUrl && config.token);
+}