windscout 0.5.8 → 0.6.1

package/dist/probe.js

@@ -4,7 +4,7 @@ import { now, sleep } from "./time.js";
 import { connectState, windscribe } from "./windscribe.js";
 // "Connected: Miami - Vice" → "Miami - Vice"
 const place = (state) => state.split(":").slice(1).join(":").trim();
-export async function probe(query, protocol, { timeout, speedTest, stopped = () => false, onStep = () => { } }) {
+export async function probe(query, protocol, { timeout, speedTest, stopped = () => false, onStep = () => { }, measure = (fn) => fn() }) {
     const r = { query, protocol, location: "", connectS: null, latencyMs: null, speedMbps: null };
     const end = (status) => ({ ...r, status });
     onStep("connecting");
@@ -32,15 +32,15 @@ export async function probe(query, protocol, { timeout, speedTest, stopped = ()
             onStep(`connecting ${r.location}`.trim());
             await sleep(1000);
         }
-        onStep(`measuring latency · ${r.location}`);
-        r.latencyMs = await latencyMs();
-        if (r.latencyMs === null)
-            return end("no internet");
-        if (speedTest) {
-            onStep(`measuring speed · ${r.location}`);
-            r.speedMbps = await speedMbps();
-        }
-        return end("ok");
+        await measure(async () => {
+            onStep(`measuring latency · ${r.location}`);
+            r.latencyMs = await latencyMs();
+            if (r.latencyMs !== null && speedTest) {
+                onStep(`measuring speed · ${r.location}`);
+                r.speedMbps = await speedMbps();
+            }
+        });
+        return end(r.latencyMs === null ? "no internet" : "ok");
     }
     finally {
         onStep("disconnecting");

package/dist/scan.js

@@ -1,34 +1,42 @@
 // A scan: every country × protocol pair, tried in order, with pause and stop.
+// Each slot runs one attempt at a time: one slot here, or one per docker container in a parallel scan.
 import { probe } from "./probe.js";
 import { now } from "./time.js";
 // ponytail: rough per-attempt cost: a failure burns the timeout, a success ~connect+speed test; refine from real runs
 export const attemptSeconds = (timeout) => timeout + 5;
-export const estimate = (countries, protocols, timeout) => countries * protocols * attemptSeconds(timeout);
+export const estimate = (attempts, timeout, slots = 1) => Math.ceil(attempts / slots) * attemptSeconds(timeout);
 /** Progress views read the fields; their keys call togglePause() and stop() */
 export class Scan {
     countries;
     protocols;
     options;
+    probers;
+    after;
     results = [];
     finished = []; // countries with every attempt done: the views refresh their tables per country
+    errors = []; // why slots stopped early
+    slots;
     total;
     started = now();
     done = 0;
-    attemptStart = now();
-    current = null;
-    step = ""; // what the running attempt is doing
-    stopping = false; // stop after the current attempt
+    stopping = false; // stop after the current attempts
     // a pause lands between attempts, so the VPN is disconnected while waiting
     paused = false;
-    waiting = false;
+    waiting = false; // paused, and no attempt running
     waitStart = 0;
     idle = 0; // seconds spent paused
     resume = () => { };
-    constructor(countries, protocols, options) {
+    unpaused = Promise.resolve();
+    constructor(countries, protocols, options, probers = [probe], after) {
         this.countries = countries;
         this.protocols = protocols;
         this.options = options;
+        this.probers = probers;
+        this.after = after;
         this.total = countries.length * protocols.length;
+        this.slots = probers.map(() => ({ current: null, step: "", attemptStart: now() }));
+        if (after)
+            this.slots.push({ current: null, step: "", attemptStart: now(), name: after.name });
     }
     /** Seconds spent scanning, pauses not counted */
     elapsed() {
@@ -36,40 +44,71 @@ export class Scan {
     }
     togglePause() {
         this.paused = !this.paused;
-        if (!this.paused)
-            this.resume();
+        if (this.paused)
+            this.unpaused = new Promise((resolve) => (this.resume = resolve));
+        else
+            this.wake();
     }
     stop() {
         this.stopping = true;
-        this.resume(); // a paused scan stops right away
+        this.wake(); // a paused scan stops right away
+    }
+    wake() {
+        if (this.waiting)
+            this.idle += now() - this.waitStart;
+        this.waiting = false;
+        this.resume();
     }
     async run(hooks = {}) {
+        const queue = this.countries.flatMap((country) => this.protocols.map((protocol) => ({ country, protocol })));
+        const left = new Map(this.countries.map((c) => [c, this.protocols.length])); // attempts to go, per country
+        const later = this.after?.protocols ?? new Set();
+        await Promise.all(this.probers.map((prober, i) => this.work(prober, this.slots[i], (p) => !later.has(p), queue, left, hooks)));
+        // then the rest, also what slots whose container stopped left over
+        if (this.after)
+            await this.work(this.after.prober, this.slots[this.probers.length], () => true, queue, left, hooks);
+        return this.results;
+    }
+    /** One slot: takes the attempts it can make from the queue, one at a time, until there are none */
+    async work(prober, slot, can, queue, left, hooks) {
         const { timeout, speedTest } = this.options;
-        outer: for (const country of this.countries) {
-            for (const protocol of this.protocols) {
-                if (this.paused && !this.stopping) {
+        for (;;) {
+            while (this.paused && !this.stopping) {
+                if (!this.waiting && this.slots.every((s) => !s.current)) { // the last running attempt is over
                     this.waiting = true;
                     this.waitStart = now();
-                    await new Promise((resolve) => (this.resume = resolve));
-                    this.waiting = false;
-                    this.idle += now() - this.waitStart;
-                }
-                if (this.stopping)
-                    break outer;
-                this.current = { country, protocol };
-                this.attemptStart = now();
-                hooks.attempt?.(country, protocol);
-                const r = await probe(country, protocol, { timeout, speedTest, stopped: () => this.stopping, onStep: (s) => (this.step = s) });
-                this.results.push(r);
-                this.done++;
-                hooks.result?.(r);
-                if (r.status === "no such location") { // its other protocols won't connect either
-                    this.done += this.protocols.length - this.protocols.indexOf(protocol) - 1;
-                    break;
                 }
+                await this.unpaused;
             }
-            this.finished.push(country);
+            const i = this.stopping ? -1 : queue.findIndex((a) => can(a.protocol));
+            if (i < 0)
+                return;
+            const [next] = queue.splice(i, 1);
+            const { country, protocol } = next;
+            Object.assign(slot, { current: next, step: "", attemptStart: now() });
+            hooks.attempt?.(country, protocol);
+            let r;
+            try {
+                r = await prober(country, protocol, { timeout, speedTest, stopped: () => this.stopping, onStep: (s) => (slot.step = s) });
+            }
+            catch (e) { // this slot is done for (its container stopped): the others take over its attempt
+                queue.unshift(next);
+                Object.assign(slot, { current: null, step: e.message });
+                this.errors.push(e.message);
+                return;
+            }
+            Object.assign(slot, { current: null, step: "" });
+            this.results.push(r);
+            let n = 1;
+            if (r.status === "no such location") // its other protocols won't connect either
+                for (let j = queue.length - 1; j >= 0; j--)
+                    if (queue[j].country === country)
+                        queue.splice(j, 1), n++;
+            this.done += n;
+            left.set(country, left.get(country) - n);
+            if (!left.get(country))
+                this.finished.push(country);
+            hooks.result?.(r);
         }
-        return this.results;
     }
 }

package/dist/tui/docker.js

@@ -0,0 +1,166 @@
+import { buildImage, dockerState, INSTALL_DOCS, runSteps, startWorkers, steps, sudoLogin, sudoReady, waitReady, workerCount } from "../docker.js";
+import { duration, now } from "../time.js";
+import { session } from "../windscribe.js";
+import { draw, enterScreen, input, leaveScreen, out } from "./terminal.js";
+import { bold, cyan, dim, vw, yellow } from "./text.js";
+import { box, centerIn } from "./widgets.js";
+const tty = () => Boolean(process.stdin.isTTY && out.isTTY);
+const clip = (s, n = 76) => (s.length > n ? s.slice(0, n - 1) + "…" : s);
+// lines of at most n columns, broken at spaces: an error can be longer than the screen is wide
+const wrap = (s, n = 76) => s.match(new RegExp(`.{1,${n}}(\\s+|$)|\\S+`, "g"))?.map((l) => l.trim()) ?? [s];
+function paint({ lines, password, buttons, error }, typed = "") {
+    const body = [...lines];
+    if (password !== undefined)
+        body.push("", `${password} ${bold("•".repeat(typed.length))}${cyan("▏")}`);
+    if (error)
+        body.push("", yellow(error));
+    const width = Math.max(56, ...body.map(vw));
+    let row = -1, line = "";
+    if (buttons) {
+        const [ok, cancel] = buttons;
+        line = `${bold(cyan(`[ ${ok} ]`))}${cancel ? dim(`  [ ${cancel} ]`) : ""}`;
+        row = body.length + 1;
+        body.push("", centerIn(line, width), centerIn(dim([`enter ${ok.toLowerCase()}`, cancel && `esc ${cancel.toLowerCase()}`].filter(Boolean).join(" · ")), width));
+    }
+    enterScreen();
+    const at = draw(box(body, { title: bold(cyan("WindScout · docker")), width }));
+    if (!buttons)
+        return { row: -1, ok: [0, 0], cancel: [0, 0] };
+    // a body line sits a row under the box's top border, two columns right of its left one
+    const x = at.left + 2 + Math.floor((width - vw(line)) / 2), okEnd = x + vw(`[ ${buttons[0]} ]`);
+    return { row: at.top + 1 + row, ok: [x, okEnd], cancel: buttons[1] ? [okEnd + 2, okEnd + 2 + vw(`[ ${buttons[1]} ]`)] : [0, 0] };
+}
+/** Shows the dialog until the user answers: what was typed in its field ("" without one) on enter or a click on ok, null on esc */
+function ask(d) {
+    if (!tty())
+        return Promise.resolve(null);
+    let typed = "";
+    let hits = paint(d, typed);
+    const redraw = () => (hits = paint(d, typed));
+    return new Promise((resolve) => {
+        const done = (v) => {
+            input.off("keypress", onKey);
+            input.off("mouse", onMouse);
+            out.off("resize", redraw);
+            resolve(v);
+        };
+        const onKey = (str, key = {}) => {
+            if (key.name === "escape" || (key.ctrl && key.name === "c"))
+                return done(null);
+            if (key.name === "return")
+                return done(typed);
+            if (key.name === "backspace")
+                typed = typed.slice(0, -1);
+            else if (d.password !== undefined && str && !key.ctrl && !key.meta && str >= " ")
+                typed += str;
+            redraw();
+        };
+        const onMouse = (m) => {
+            const on = ([from, to]) => m.press && m.button === 0 && m.y === hits.row && m.x >= from && m.x < to;
+            if (on(hits.ok))
+                done(typed);
+            else if (on(hits.cancel))
+                done(null);
+        };
+        input.on("keypress", onKey);
+        input.on("mouse", onMouse);
+        out.on("resize", redraw);
+    });
+}
+/** Waits for work while the screen shows a spinner, status.label, the time so far and status.line (its latest output). esc quits */
+async function busy(status, work) {
+    if (!tty()) {
+        console.error(`${status.label}…`);
+        return work;
+    }
+    const t = now();
+    let frame = 0;
+    const tick = () => paint({ lines: [`${cyan("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"[frame++ % 10])} ${status.label} ${dim("· " + duration(now() - t))}`,
+            dim(clip(status.line)), "", dim("esc quits")] });
+    // the exit handlers remove containers already started
+    const quit = (_, key = {}) => (key.name === "escape" || key.name === "q" || (key.ctrl && key.name === "c"))
+        && (leaveScreen(), process.exit(130));
+    const timer = setInterval(tick, 120);
+    input.on("keypress", quit);
+    tick();
+    try {
+        return await work;
+    }
+    finally {
+        clearInterval(timer);
+        input.off("keypress", quit);
+    }
+}
+const WHY = {
+    missing: "A parallel scan runs each attempt in a docker container, and docker isn't installed.",
+    stopped: "A parallel scan runs each attempt in a docker container, and docker isn't running.",
+    denied: "Docker is installed, but your user can't use it yet.",
+};
+/** Gets docker answering: asks, then installs or starts it. False when the user cancels, it fails, or (Linux) a new login is needed first */
+export async function setupDocker() {
+    const state = await dockerState();
+    if (state === "ready")
+        return true;
+    if (!tty())
+        throw new Error(`${WHY[state]} Run windscout in a terminal to set it up, or scan without --docker.`);
+    const todo = steps(state);
+    const root = todo.some((s) => s.root) && !(await sudoReady());
+    const lines = [WHY[state], "", "WindScout will:", ...todo.map((s) => `  • ${s.label}${s.root ? dim(" (sudo)") : ""}`),
+        ...(state === "missing" && process.platform !== "linux"
+            ? ["", dim("Docker Desktop is free for personal use, education and small businesses;"), dim("bigger companies need a paid plan: docker.com/pricing")]
+            : [])];
+    let password, error = "";
+    for (;;) {
+        const a = await ask({ lines, password: root ? "password for sudo:" : undefined, buttons: [state === "missing" ? "Install" : "Start", "Cancel"], error });
+        if (a === null)
+            return false;
+        if (!root)
+            break;
+        if (!(error = await sudoLogin(a))) {
+            password = a; // kept until the steps are done: one may need sudo again after a long download
+            break;
+        }
+    }
+    const status = { label: "", line: "" };
+    try {
+        await busy(status, runSteps(todo, password, (label) => Object.assign(status, { label, line: "" }), (line) => (status.line = line)));
+        if (process.platform === "linux" && state !== "stopped") {
+            await ask({ lines: ["Docker is ready, and you're in the docker group now.", "That takes effect in a new login session: log out and back in",
+                    `(or run ${bold("newgrp docker")}), then start windscout again.`], buttons: ["OK"] });
+            return false;
+        }
+        Object.assign(status, { label: "waiting for docker to start", line: "" });
+        await busy(status, waitReady());
+        return true;
+    }
+    catch (e) {
+        const why = e.message;
+        // docker.com refuses some countries (Iran: US sanctions), and nobody mirrors Docker Desktop: only a VPN gets it there
+        const refused = /\b403\b|forbidden/i.test(why);
+        const a = await ask({ lines: [...wrap(why).map(yellow),
+                ...(refused ? ["", ...wrap(`docker.com refuses downloads from some countries, Iran among them${process.platform === "linux" ? ""
+                        : ", and no mirror carries Docker Desktop"}: connect a VPN (Windscribe will do), then retry.`)] : []),
+                ...(state === "missing" ? ["", `To install docker yourself: ${INSTALL_DOCS}`] : [])], buttons: ["Retry", "Cancel"] });
+        return a !== null && setupDocker();
+    }
+}
+/** Starts the containers for a parallel scan of this many attempts: docker, the image, the containers' apps logged in with
+ * this computer's session. Resolves to their probers and whether WireGuard works in them; null if the user backed out */
+export async function startParallel(attempts) {
+    const s = session();
+    if (!s)
+        throw new Error("can't find the session this computer's Windscribe app is logged in with, which the containers' apps log in with:"
+            + " update the Windscribe app, or scan without --docker (d in the picker)");
+    if (!(await setupDocker()))
+        return null;
+    const status = { label: "building the containers' image (the first time takes a few minutes)", line: "" };
+    await busy(status, buildImage((line) => (status.line = line)));
+    const n = workerCount(attempts);
+    Object.assign(status, { label: `starting ${n} container${n > 1 ? "s" : ""}`, line: "" });
+    const started = await busy(status, startWorkers(n, s, (line) => (status.line = line)));
+    if (!started.probers.length) {
+        const why = status.line.startsWith("container") ? ` (${status.line})` : ""; // the last container's trouble
+        throw new Error(`no container got ready${why}`);
+    }
+    return started;
+}

package/dist/tui/picker.js

@@ -1,31 +1,38 @@
-import { MIN_TIMEOUT, saveConfig } from "../config.js";
+import { loadDockerWireGuard, MIN_TIMEOUT, saveConfig } from "../config.js";
+import { dockerState, notInContainers, workerCount } from "../docker.js";
 import { attemptSeconds, estimate } from "../scan.js";
 import { duration } from "../time.js";
 import { canUpdate, checkUpdate, versionLines } from "../update.js";
 import { COUNTRIES, PROTOCOLS } from "../windscribe.js";
 import { countryName, flag } from "./country.js";
+import { setupDocker } from "./docker.js";
 import { draw, enterScreen, input, leaveScreen, out, repoLink } from "./terminal.js";
 import { bold, cyan, dim, green, under, vw, yellow } from "./text.js";
 import { box, centerIn, grid } from "./widgets.js";
 const flip = (set, value) => (set.has(value) ? set.delete(value) : set.add(value));
 /** Resolves to the choice (also saved for next time), null when the user quits, or "update" for u */
-export function pick(saved, { timeout, speedTest, firewall, random }) {
+export function pick(saved, { timeout, speedTest, firewall, random, docker }) {
     const selected = new Set(saved?.countries ?? []);
     const protos = new Set(saved?.protocols.length ? saved.protocols : PROTOCOLS);
     let cursor = 0, top = 0, message = "", query = "", searching = false;
     let seconds = String(timeout), editing = false; // the timeout, as typed
+    let dockerAt = null, inDialog = false; // docker's state once checked; a docker dialog has the screen
     let hit;
     const visible = () => {
         const q = query.toLowerCase();
         return q ? COUNTRIES.filter((c) => c.toLowerCase().includes(q) || countryName(c).toLowerCase().includes(q)) : COUNTRIES;
     };
+    const attempts = () => selected.size * protos.size;
+    const wireguard = loadDockerWireGuard(); // in docker containers, as the last parallel scan found
     enterScreen();
     return new Promise((resolve) => {
         const render = () => {
+            if (inDialog)
+                return;
             const rows = out.rows || 24;
             const version = versionLines(true);
             const matches = visible();
-            const height = Math.max(3, rows - 22 - version.length);
+            const height = Math.max(3, rows - 23 - version.length);
             cursor = Math.max(0, Math.min(cursor, matches.length - 1));
             if (cursor < top)
                 top = cursor;
@@ -37,15 +44,24 @@ export function pick(saved, { timeout, speedTest, firewall, random }) {
                 ? "ranks by download speed · adds ~15s per working connection"
                 : "off: connect-only, ranks by latency")}`;
             const fwLabel = "block internet while scanning (firewall)";
-            const fwLine = `${dim(under("f"))} ${firewall ? green("● " + fwLabel) : dim("○ " + fwLabel)}  ${dim(firewall
-                ? "only VPN traffic gets through"
-                : "off: apps may leak in between")}`;
+            const fwLine = `${dim(under("f"))} ${firewall ? green("● " + fwLabel) : dim("○ " + fwLabel)}  ${dim(docker
+                ? "not used with docker"
+                : firewall ? "only VPN traffic gets through" : "off: apps may leak in between")}`;
             const randomLine = `${dim(under("r"))} ${random ? green("● random order") : dim("○ random order")}  ${dim(random
                 ? "scans the countries shuffled, a new order each run"
                 : "off: scans in list order")}`;
             timeout = Number(seconds);
             const short = timeout < MIN_TIMEOUT;
             const timeoutLine = `${dim(under("t"))} timeout ${editing ? bold(seconds) + cyan("▏") : (short ? yellow : bold)(seconds || "?")} s  ${dim(`per connection · at least ${MIN_TIMEOUT}`)}`;
+            const n = attempts();
+            const here = PROTOCOLS.filter((p) => docker && protos.has(p) && notInContainers(PROTOCOLS, wireguard).has(p)); // after the containers
+            const inContainers = selected.size * (protos.size - here.length);
+            const slots = docker && dockerAt === "ready" && inContainers ? workerCount(inContainers) : 1;
+            const dockerLabel = "parallel scan in docker containers";
+            const dockerLine = `${dim(under("d"))} ${docker ? green("● " + dockerLabel) : dim("○ " + dockerLabel)}  ${dim(!docker
+                ? "off: one attempt at a time"
+                : dockerAt === "ready" ? `${slots} at a time${here.length ? ` · ${here.join(" and ")} here, after them` : ""}`
+                    : dockerAt ? "docker isn't ready: start sets it up" : "checking docker…")}`;
             const search = searching
                 ? `${cyan("🔍")} ${bold(query)}${cyan("▏")}`
                 : query ? `🔍 ${query}` : dim("🔍 press / to search");
@@ -66,14 +82,13 @@ export function pick(saved, { timeout, speedTest, firewall, random }) {
                 ["quit", under("Q") + "uit"],
             ];
             const buttonLine = buttons.map(([id, label]) => (id === "start" ? bold(cyan(`[ ${label} ]`)) : dim(`[ ${label} ]`))).join("  ");
-            const table = grid([{ title: "" }, { title: "Code" }, { title: "Country" }], body, { caption: search, captionRight: dim(range), minWidth: Math.max(vw(protoLine), vw(speedLine), vw(fwLine), vw(randomLine), vw(timeoutLine)) + 4 });
+            const table = grid([{ title: "" }, { title: "Code" }, { title: "Country" }], body, { caption: search, captionRight: dim(range), minWidth: Math.max(...[protoLine, speedLine, fwLine, randomLine, timeoutLine, dockerLine].map(vw)) + 4 });
             const width = vw(table[0]);
-            const head = box([protoLine, speedLine, fwLine, randomLine, timeoutLine], {
+            const head = box([protoLine, speedLine, fwLine, randomLine, timeoutLine, dockerLine], {
                 title: bold(cyan("WindScout")),
                 right: `${bold(String(selected.size))}${dim(`/${COUNTRIES.length} selected`)}`,
                 width: width - 4,
             });
-            const n = selected.size * protos.size;
             const lines = [
                 ...head,
                 ...table,
@@ -81,14 +96,15 @@ export function pick(saved, { timeout, speedTest, firewall, random }) {
                 centerIn(buttonLine, width),
                 "",
                 centerIn(n
-                    ? `${bold(String(n))} attempts · estimated ${bold("≈ " + duration(estimate(selected.size, protos.size, timeout)))} ${dim(`(~${attemptSeconds(timeout)}s each)`)}`
+                    ? `${bold(String(n))} attempts · estimated ${bold("≈ " + duration(estimate(inContainers, timeout, slots) + estimate(n - inContainers, timeout)))} ${dim(`(~${attemptSeconds(timeout)}s each${slots > 1 ? `, ${slots} at a time` : ""})`)}`
                     : yellow("select at least one country and one protocol"), width),
                 centerIn(dim(editing
                     ? "type the seconds to wait for each connection · enter/esc done"
                     : searching
                         ? "type to filter · ↑↓ move · enter/esc done"
-                        : `↑↓ move · space select · a/n ${query ? "all/none shown" : "all/none"} · / search`), width),
-                centerIn(dim(searching || editing ? "" : `1-${PROTOCOLS.length} protocols · s speed test · f firewall · r random · t timeout · enter start · ${query ? "esc clear · " : ""}q quit`), width),
+                        // both lines fit 80 columns
+                        : `↑↓ move · space select · a/n ${query ? "all/none shown · esc clear" : "all/none · / search"} · enter start · q quit`), width),
+                centerIn(dim(searching || editing ? "" : `1-${PROTOCOLS.length} protocols · s speed test · f firewall · r random · t timeout · d docker`), width),
             ];
             if (message)
                 lines.push(centerIn(yellow(message), width));
@@ -110,7 +126,7 @@ export function pick(saved, { timeout, speedTest, firewall, random }) {
                 return range;
             });
             hit = {
-                protoRow: at.top + 1, protoHits, speedRow: at.top + 2, firewallRow: at.top + 3, randomRow: at.top + 4, timeoutRow: at.top + 5,
+                protoRow: at.top + 1, protoHits, speedRow: at.top + 2, firewallRow: at.top + 3, randomRow: at.top + 4, timeoutRow: at.top + 5, dockerRow: at.top + 6,
                 searchRow: at.top + head.length + 1,
                 firstRow: at.top + head.length + 5, shown: shown.length,
                 buttonRow: at.top + head.length + table.length + 1, buttonHits,
@@ -118,6 +134,8 @@ export function pick(saved, { timeout, speedTest, firewall, random }) {
         };
         let closed = false;
         checkUpdate().then(() => !closed && render()); // the check usually lands after the first draw
+        if (docker)
+            dockerState().then((s) => ((dockerAt = s), !closed && render()));
         const finish = (value) => {
             closed = true;
             out.off("resize", render);
@@ -128,7 +146,7 @@ export function pick(saved, { timeout, speedTest, firewall, random }) {
             resolve(value);
         };
         const start = () => {
-            if (!selected.size || !protos.size) {
+            if (!attempts()) {
                 message = "nothing to scan yet";
                 return false;
             }
@@ -144,12 +162,30 @@ export function pick(saved, { timeout, speedTest, firewall, random }) {
                 firewall,
                 random,
                 timeout,
+                docker,
             };
             saveConfig(choice);
             finish(choice);
             return true;
         };
-        input.on("mouse", (m) => {
+        // turning it on gets docker going first: installs or starts it (after asking), unless it answers already
+        const toggleDocker = async () => {
+            if (!docker && (dockerAt = await dockerState()) !== "ready") {
+                inDialog = true;
+                input.off("keypress", onKey);
+                input.off("mouse", onMouse);
+                const ok = await setupDocker();
+                input.on("keypress", onKey);
+                input.on("mouse", onMouse);
+                inDialog = false;
+                dockerAt = await dockerState();
+                if (!ok)
+                    return render();
+            }
+            docker = !docker;
+            render();
+        };
+        const onMouse = (m) => {
             if (!m.press)
                 return;
             message = "";
@@ -184,6 +220,8 @@ export function pick(saved, { timeout, speedTest, firewall, random }) {
                     firewall = !firewall;
                 else if (y === hit.randomRow)
                     random = !random;
+                else if (y === hit.dockerRow)
+                    return void toggleDocker();
                 else if (y === hit.buttonRow) {
                     const id = hit.buttonHits.find(([, a, b]) => x >= a && x < b)?.[0];
                     if (id === "start" && start())
@@ -197,9 +235,10 @@ export function pick(saved, { timeout, speedTest, firewall, random }) {
                 }
             }
             render();
-        });
+        };
+        input.on("mouse", onMouse);
         out.on("resize", render);
-        input.on("keypress", (str, key = {}) => {
+        const onKey = (str, key = {}) => {
             message = "";
             const k = key.name;
             const matches = visible();
@@ -263,6 +302,8 @@ export function pick(saved, { timeout, speedTest, firewall, random }) {
                 random = !random;
             else if (k === "t")
                 editing = true, seconds = "";
+            else if (k === "d")
+                return void toggleDocker();
             else if (k === "u" && canUpdate())
                 return finish("update");
             else if (/^[1-9]$/.test(str ?? "") && PROTOCOLS[Number(str) - 1])
@@ -276,7 +317,8 @@ export function pick(saved, { timeout, speedTest, firewall, random }) {
             else if (k === "q" || k === "escape")
                 return finish(null);
             render();
-        });
+        };
+        input.on("keypress", onKey);
         render();
     });
 }

package/dist/tui/progress.js

@@ -16,16 +16,17 @@ export function showProgress(scan, blocking) {
     let frame = 0;
     const render = () => {
         const rows = out.rows || 24;
-        const { done, total, waiting, paused, stopping, results, finished } = scan;
+        const { done, total, waiting, paused, stopping, results, finished, slots } = scan;
         const elapsed = scan.elapsed();
-        // smooth bar: count the running attempt as partially done
-        const partial = waiting ? 0 : Math.min(0.95, (now() - scan.attemptStart) / attemptSeconds(timeout));
+        // smooth bar: count the running attempts as partially done
+        const partial = slots.reduce((sum, s) => sum + (s.current ? Math.min(0.95, (now() - s.attemptStart) / attemptSeconds(timeout)) : 0), 0);
         const fraction = (done + (done < total ? partial : 0)) / total;
-        const eta = (total - done) * (done ? elapsed / done : attemptSeconds(timeout));
+        const eta = (total - done) * (done ? elapsed / done : attemptSeconds(timeout) / slots.length);
         const spinner = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"[frame++ % 10];
         const ok = sortOk(results);
         const failed = finished.filter((c) => !results.some((r) => r.query === c && r.status === "ok"));
-        const current = scan.current ? `${flag(scan.current.country)} ${countryName(scan.current.country)} ${dim("·")} ${scan.current.protocol}` : "";
+        const attempt = ({ current: c }) => (c ? `${flag(c.country)} ${countryName(c.country)} ${dim("·")} ${c.protocol}` : "");
+        const many = slots.length > 1; // a parallel scan: a line per container
         const pct = bold(`${String(Math.floor(fraction * 100)).padStart(3)}%`);
         const stats = [
             `${dim("elapsed")} ${duration(elapsed)}`,
@@ -36,7 +37,7 @@ export function showProgress(scan, blocking) {
         const minW = Math.max(64, vw(stats) + 6); // panel and table share one width
         // results table gets whatever height the status panel and footer leave
         const version = versionLines();
-        const room = Math.max(1, rows - 22 - version.length);
+        const room = Math.max(1, rows - 20 - (many ? slots.length + 1 : 2) - version.length);
         const table = view === "availability"
             ? matrix(results, protocols, { minWidth: minW, limit: room })
             : ok.length
@@ -48,15 +49,25 @@ export function showProgress(scan, blocking) {
                 : [];
         const width = Math.max(minW, table.length ? vw(table[0]) : 0);
         const inner = width - 4;
+        const status = stopping ? yellow(` stopping after the current attempt${many ? "s" : ""}…`)
+            : waiting ? yellow(` paused · VPN disconnected${blocking ? " · firewall blocking internet" : ""} · press p to resume`)
+                : "";
+        const pausing = paused && !waiting && frame % 8 < 5;
+        const slotLine = (s) => {
+            if (!s.current)
+                return s.step ? ` ${red("✗")} ${dim(clip(s.step, inner - 3))}` : dim(s.name ? ` · ${s.name}: after the containers` : " · idle");
+            const head = ` ${cyan(spinner)} ${s.name ? dim(`${s.name}: `) : ""}${bold(attempt(s))} `, time = ` · ${duration(now() - s.attemptStart)}`;
+            return head + dim(clip(s.step, inner - vw(head) - time.length) + time);
+        };
         const panel = box([
             "",
             ` ${bar(fraction, inner - 8)}  ${pct}`,
             "",
-            stopping
-                ? yellow(" stopping after the current attempt…")
-                : waiting ? yellow(` paused · VPN disconnected${blocking ? " · firewall blocking internet" : ""} · press p to resume`)
-                    : ` ${cyan(spinner)} ${bold(current)}`,
-            stopping || waiting ? "" : `   ${dim(scan.step)} ${dim("·")} ${duration(now() - scan.attemptStart)}${paused && frame % 8 < 5 ? yellow(" · pausing after this attempt") : ""}`,
+            ...(many
+                ? [...slots.map(slotLine), status || (pausing ? yellow(" pausing after these attempts") : "")]
+                : status ? [status, ""]
+                    : [` ${cyan(spinner)} ${bold(attempt(slots[0]))}`,
+                        `   ${dim(slots[0].step)} ${dim("·")} ${duration(now() - slots[0].attemptStart)}${pausing ? yellow(" · pausing after this attempt") : ""}`]),
             null,
             centerIn(stats, inner),
         ], {
@@ -109,8 +120,10 @@ export function showProgress(scan, blocking) {
         },
     };
 }
+const clip = (s, n) => (s.length > n ? s.slice(0, Math.max(0, n - 1)) + "…" : s);
 /** A line per attempt. Ctrl-C stops after the current attempt, a second one quits */
 export function logProgress(scan) {
+    const many = scan.slots.length > 1; // attempts overlap: a whole line once each is done
     process.on("SIGINT", async () => {
         if (scan.stopping) {
             await restoreFirewall();
@@ -119,8 +132,9 @@ export function logProgress(scan) {
         scan.stop();
     });
     return {
-        attempt: (country, protocol) => process.stdout.write(`[${scan.done + 1}/${scan.total}] ${country} ${protocol} ... `),
-        result: (r) => console.log([r.status, r.location, r.speedMbps ? `${r.speedMbps.toFixed(1)} Mbps` : ""].join(" ").trim()),
+        attempt: (country, protocol) => many || process.stdout.write(`[${scan.done + 1}/${scan.total}] ${country} ${protocol} ... `),
+        result: (r) => console.log([many ? `[${scan.done}/${scan.total}] ${r.query} ${r.protocol} ...` : "", r.status, r.location,
+            r.speedMbps ? `${r.speedMbps.toFixed(1)} Mbps` : ""].join(" ").trim()),
         close() { },
     };
 }