windscout 0.5.7 → 0.6.0

package/dist/tui/docker.js

@@ -0,0 +1,241 @@
+// Docker on screen, for parallel scans: dialogs to install or start it (taking the sudo password),
+// progress while the image builds and the containers start, and the Windscribe login the containers need.
+import { homedir } from "node:os";
+import { LOGIN_FILE, loadLogin, saveLogin } from "../config.js";
+import { buildImage, dockerState, INSTALL_DOCS, runSteps, startWorkers, steps, sudoLogin, sudoReady, waitReady, workerCount } from "../docker.js";
+import { duration, now } from "../time.js";
+import { draw, enterScreen, input, leaveScreen, out } from "./terminal.js";
+import { bold, cyan, dim, green, 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];
+let asking = false; // a dialog waits for the user: progress doesn't draw over it
+function paint({ lines, fields = [], check, buttons, error }, a = { values: [], checked: false, focus: 0 }) {
+    const many = fields.length + (check ? 1 : 0) > 1; // then a ❯ marks where the keys go
+    const mark = (i) => (!many ? "" : i === a.focus ? cyan("❯ ") : "  ");
+    const body = [...lines], items = [];
+    if (fields.length || check)
+        body.push("");
+    fields.forEach((f, i) => {
+        items.push(body.length);
+        body.push(`${mark(i)}${f.label} ${bold(f.secret ? "•".repeat(a.values[i].length) : a.values[i])}${i === a.focus ? cyan("▏") : ""}`);
+    });
+    if (check) {
+        items.push(body.length);
+        body.push(`${mark(fields.length)}${a.checked ? green("[✓]") : dim("[ ]")} ${check.label}`);
+        if (check.note)
+            body.push(dim(`${many ? "  " : ""}    ${check.note}`));
+    }
+    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([many && "tab/↑↓ move", check && "space ticks the box", `enter ${ok.toLowerCase()}`,
+            cancel && `esc ${cancel.toLowerCase()}`].filter(Boolean).join(" · ")), width));
+    }
+    enterScreen();
+    const at = draw(box(body, { title: bold(cyan("WindScout · docker")), width }));
+    // a body line sits a row under the box's top border, two columns right of its left one
+    const rows = items.map((i) => at.top + 1 + i);
+    if (!buttons)
+        return { rows, buttons: -1, ok: [0, 0], cancel: [0, 0] };
+    const x = at.left + 2 + Math.floor((width - vw(line)) / 2), okEnd = x + vw(`[ ${buttons[0]} ]`);
+    return { rows, buttons: 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 and ticked on enter (or a click on ok), null on esc.
+ * tab, ↑↓ and enter move between the fields; space or a click ticks the checkbox */
+function form(d) {
+    if (!tty())
+        return Promise.resolve(null);
+    asking = true;
+    const fields = d.fields ?? [];
+    const n = fields.length + (d.check ? 1 : 0);
+    const a = { values: fields.map((f) => f.value ?? ""), checked: d.check?.on ?? false, focus: 0 };
+    let hits = paint(d, a);
+    const redraw = () => (hits = paint(d, a));
+    return new Promise((resolve) => {
+        const done = (v) => {
+            asking = false;
+            input.off("keypress", onKey);
+            input.off("mouse", onMouse);
+            out.off("resize", redraw);
+            resolve(v);
+        };
+        const onKey = (str, key = {}) => {
+            const field = a.focus < fields.length;
+            if (key.name === "escape" || (key.ctrl && key.name === "c"))
+                return done(null);
+            if (key.name === "return") {
+                if (a.focus >= fields.length - 1)
+                    return done(a);
+                a.focus++; // like a form: on to the next field
+            }
+            else if (n > 1 && (key.name === "tab" || key.name === "down"))
+                a.focus = (a.focus + (key.shift ? n - 1 : 1)) % n;
+            else if (n > 1 && key.name === "up")
+                a.focus = (a.focus + n - 1) % n;
+            else if (!field) {
+                if (key.name === "space")
+                    a.checked = !a.checked;
+            }
+            else if (key.name === "backspace")
+                a.values[a.focus] = a.values[a.focus].slice(0, -1);
+            else if (str && !key.ctrl && !key.meta && str >= " ")
+                a.values[a.focus] += str;
+            redraw();
+        };
+        const onMouse = (m) => {
+            if (!m.press || m.button !== 0)
+                return;
+            const i = hits.rows.indexOf(m.y);
+            const on = ([from, to]) => m.y === hits.buttons && m.x >= from && m.x < to;
+            if (i >= 0) {
+                a.focus = i;
+                if (i === fields.length)
+                    a.checked = !a.checked; // the checkbox
+            }
+            else if (on(hits.ok))
+                return done(a);
+            else if (on(hits.cancel))
+                return done(null);
+            redraw();
+        };
+        input.on("keypress", onKey);
+        input.on("mouse", onMouse);
+        out.on("resize", redraw);
+    });
+}
+/** A dialog with one field or none: the field's text ("" without one) on enter, null on esc */
+const ask = async (d) => {
+    const a = await form(d);
+    return a && (a.values[0] ?? "");
+};
+/** 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 = () => asking || paint({ lines: [`${cyan("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"[frame++ % 10])} ${status.label} ${dim("· " + duration(now() - t))}`,
+            dim(clip(status.line)), "", dim("esc quits")] });
+    // a dialog on top (the login) takes its own keys; the exit handlers remove containers already started
+    const quit = (_, key = {}) => !asking && (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, fields: root ? [{ label: "password for sudo:", secret: true }] : [], 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();
+    }
+}
+const LOGIN = [
+    "Each container runs its own Windscribe app, which logs in once:",
+    "the login stays in the container's docker volume for the next scans.",
+];
+let lastUser = "", remember = true; // the box as last ticked: ticked to start with
+/** A remembered login unless that just failed, else the login form */
+async function credentials(error) {
+    const saved = loadLogin();
+    if (saved && !error)
+        return saved;
+    const a = await form({
+        lines: LOGIN,
+        fields: [{ label: "Windscribe username:", value: lastUser || saved?.username }, { label: "Windscribe password:", secret: true }],
+        check: { label: "remember username and password", on: remember,
+            note: `saved in ${LOGIN_FILE.replace(homedir(), "~")}, only you can read it` },
+        buttons: ["Log in", "Cancel"],
+        error,
+    });
+    if (!a)
+        return null;
+    remember = a.checked;
+    if (!remember)
+        saveLogin(null); // unticked: forget the one saved before, if any
+    const [username, password] = a.values;
+    return { username: (lastUser = username), password };
+}
+/** Starts the containers for a parallel scan of this many attempts: docker, the image, the logins.
+ * Resolves to their probers and whether WireGuard works in them; null if the user backed out */
+export async function startParallel(attempts) {
+    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, {
+        credentials,
+        answer: (question) => ask({ lines: ["Windscribe asks:", "", ...question.split("\n")], fields: [{ label: "answer:" }], buttons: ["Send", "Cancel"] }),
+        loggedIn: (c) => remember && saveLogin(c), // saved only once it worked
+    }, (line) => (status.line = line)));
+    if (!started.probers.length) {
+        const why = status.line.startsWith("container") ? ` (${status.line})` : ""; // the last container's trouble
+        throw new Error(why || tty() ? `no container got ready${why}` : "the containers aren't logged in to Windscribe yet: run windscout --docker in a terminal once");
+    }
+    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 }) {
+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 - 21 - 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,12 +44,24 @@ export function pick(saved, { timeout, speedTest, firewall }) {
                 ? "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");
@@ -63,14 +82,13 @@ export function pick(saved, { timeout, speedTest, firewall }) {
                 ["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(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, 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,
@@ -78,14 +96,15 @@ export function pick(saved, { timeout, speedTest, firewall }) {
                 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 · 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));
@@ -107,7 +126,7 @@ export function pick(saved, { timeout, speedTest, firewall }) {
                 return range;
             });
             hit = {
-                protoRow: at.top + 1, protoHits, speedRow: at.top + 2, firewallRow: at.top + 3, timeoutRow: at.top + 4,
+                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,
@@ -115,6 +134,8 @@ export function pick(saved, { timeout, speedTest, firewall }) {
         };
         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);
@@ -125,7 +146,7 @@ export function pick(saved, { timeout, speedTest, firewall }) {
             resolve(value);
         };
         const start = () => {
-            if (!selected.size || !protos.size) {
+            if (!attempts()) {
                 message = "nothing to scan yet";
                 return false;
             }
@@ -139,13 +160,32 @@ export function pick(saved, { timeout, speedTest, firewall }) {
                 protocols: PROTOCOLS.filter((p) => protos.has(p)),
                 speed: speedTest,
                 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 = "";
@@ -178,6 +218,10 @@ export function pick(saved, { timeout, speedTest, firewall }) {
                     speedTest = !speedTest;
                 else if (y === hit.firewallRow)
                     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())
@@ -191,9 +235,10 @@ export function pick(saved, { timeout, speedTest, firewall }) {
                 }
             }
             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();
@@ -253,8 +298,12 @@ export function pick(saved, { timeout, speedTest, firewall }) {
                 speedTest = !speedTest;
             else if (k === "f")
                 firewall = !firewall;
+            else if (k === "r")
+                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])
@@ -268,7 +317,8 @@ export function pick(saved, { timeout, speedTest, firewall }) {
             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() { },
     };
 }

package/dist/worker.js

@@ -0,0 +1,92 @@
+// windscout --worker: runs in a parallel scan's docker container (docker.ts), beside the container's own Windscribe app.
+// Takes the host's messages from stdin and answers on stdout, a JSON object per line.
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { probe } from "./probe.js";
+import { sleep } from "./time.js";
+import { CLI, windscribe } from "./windscribe.js";
+const send = (m) => process.stdout.write(JSON.stringify(m) + "\n");
+// the CLI mixes JSON log lines into its output
+const text = (s) => s.split("\n").filter((l) => !l.startsWith('{"tm"')).join("\n").trim();
+export async function worker() {
+    const inbox = [];
+    let wake = () => { }, closed = false, stop = false;
+    createInterface({ input: process.stdin })
+        .on("line", (l) => {
+        const m = JSON.parse(l);
+        if (m.stop)
+            stop = true; // the scan is stopping: give up connecting
+        else
+            inbox.push(m), wake();
+    })
+        .on("close", () => ((closed = true), wake()));
+    /** The host's next message; null once it closed stdin: the scan is over */
+    const next = async () => {
+        while (!inbox.length && !closed)
+            await new Promise((resolve) => (wake = resolve));
+        return inbox.shift() ?? null;
+    };
+    // the app starts beside us (the image's CMD); its CLI answers once it's up
+    let status = "";
+    for (let i = 0; i < 60 && !(status = await windscribe("status")).includes("Login state"); i++)
+        await sleep(1000);
+    if (!status.includes("Login state"))
+        return void console.error("Windscribe's app didn't start in the container");
+    if (!status.includes("Logged in")) {
+        for (let error = "";;) {
+            send({ need: "login", text: error });
+            const m = await next();
+            if (!m?.login)
+                return; // no credentials for us: this container sits out the scan
+            if (!(error = await login(m.login.username, m.login.password, next)))
+                break;
+        }
+    }
+    send({ ready: true, wireguard: process.env.WS_WIREGUARD !== "0" }); // the image's CMD checked the kernel
+    for (let m; (m = await next());) {
+        if (!m.probe)
+            continue;
+        stop = false;
+        const { query, protocol, timeout, speedTest } = m.probe;
+        const result = await probe(query, protocol, {
+            timeout, speedTest,
+            stopped: () => stop,
+            onStep: (step) => send({ step }),
+            measure: async (fn) => {
+                send({ measure: true });
+                await next(); // go
+                try {
+                    await fn();
+                }
+                finally {
+                    send({ measured: true });
+                }
+            },
+        });
+        send({ result });
+    }
+}
+/** windscribe-cli login, with the password on its stdin; what it asks next (a 2FA code, a captcha) goes to the host.
+ * "" once logged in, else why not */
+function login(username, password, next) {
+    return new Promise((resolve) => {
+        const p = spawn(CLI, ["login", username], { stdio: ["pipe", "pipe", "ignore"] });
+        p.stdin.on("error", () => { });
+        p.stdin.write(password + "\n");
+        let out = "";
+        p.stdout.on("data", async (d) => {
+            out += d;
+            const asked = text(out);
+            // a question ends the output, with no newline after it: "2FA code:", or under a captcha "…to continue:"
+            if (!asked.endsWith(":"))
+                return;
+            out = "";
+            if (asked.endsWith("Password:"))
+                return; // answered already
+            send({ need: "input", text: asked });
+            p.stdin.write(((await next())?.input ?? "") + "\n");
+        });
+        // it exits 0 whether that worked or not: ask the app
+        p.on("close", async () => resolve((await windscribe("status")).includes("Logged in") ? "" : text(out).split("\n").at(-1) || "login failed"));
+    });
+}