windscout 0.7.0 → 0.7.1

package/README.md

@@ -116,7 +116,7 @@ Run `windscout` with no arguments to open the interactive picker:
 
 Your selection is saved to `~/.config/windscout/config.json` (`%USERPROFILE%\.config\windscout\config.json` on Windows) and preselected next time.
 
-After you start, the Start button spins (`[ ⠋ Starting… ]`) until the scan's screen shows, which can take a moment when it turns the firewall on or starts docker. While scanning, WindScout shows a progress bar, elapsed time and remaining time. It also shows what it's doing right now (connecting, measuring latency or measuring speed). The table of working locations refreshes after each country. When the scan finishes, the final report is printed to your normal terminal. It ends with the best connection and the other working ones, each with its `windscribe-cli connect` command. At the prompt, press enter to connect to the best one, type another one's number to connect to that, or `q` to quit.
+After you start, the Start button spins (`[ ⠋ Starting… ]`) until the scan's screen shows, which can take a moment when it turns the firewall on or starts docker. While scanning, WindScout shows a progress bar, elapsed time and remaining time. It also shows what it's doing right now (connecting, measuring latency or measuring speed). The table of working locations refreshes after each country. When the scan finishes, the final report is printed to your normal terminal. It ends with the best connection and the other working ones, each with its `windscribe-cli connect` command. At the prompt, press enter or `0` to connect to the best one, type another one's number and press enter to connect to that, or press `q` to quit. `0` and `q` work right away, without enter.
 
 ### Non-interactive
 
@@ -164,7 +164,7 @@ Press `o` in the picker, or pass `-o`, to choose what a scan tries and in which
 | default | `default` | the selected countries × protocols, the countries in list order |
 | by random country | `random` | the same, with the countries shuffled, a new order each run |
 | by last success result first | `last-first` | the same, but the [last result](#last-result-rescan-and-connect)'s working connections among them go first, best first and on their own port, then the rest. With one country selected, only that country is scanned, its saved connections first. The line shows how many saved connections are in your selection (`1 of 7 saved selected · 3h ago`) |
-| only the last results | `last-only` | only the last result's working connections, each on its own protocol and port. The countries, protocols and all ports are skipped, so the picker greys them out and locks them (your selection stays for next time). With `-o last-only`, `-c` isn't needed |
+| only the last results | `last-only` | only the last result's working connections, each on its own protocol and port. The countries, protocols and all ports are skipped, so the picker greys them out and locks them. Its country list shows just the countries this scan tries, all selected; your own selection comes back when you change the type, and stays for next time. With `-o last-only`, `-c` isn't needed |
 
 The two types by the last result need a saved scan. Until there is one, choosing either turns `[ ▶ Start ]` off (greyed out), and a warning takes the estimate's place: `no saved scan yet, so start is off: press o for another scanning type`. Without the picker, `-o last-first` and `-o last-only` stop with an error instead. The estimate counts each saved connection once: `tcp` and `tcp:443` are the same attempt when 443 is tcp's default port.
 
@@ -198,7 +198,7 @@ Both modes show an **availability grid**: one row per country, and ✓ / ✗ for
 ╰─────────────────────────┴────────────────────────┴─────────┴───────────┴─────╯
 ```
 
-While scanning, press `tab` to switch between the availability grid and the speed or latency ranking. Press `p` (or `space`) to pause: the current attempt finishes, the VPN disconnects, and the scan waits until you press `p` again. Paused time doesn't count toward elapsed or remaining. In connect-only mode the scan starts on the availability grid.
+While scanning, press `tab` to switch between the availability grid and the speed or latency ranking. Press `p` (or `space`) to pause: the current attempt finishes, the VPN disconnects, and the scan waits until you press `p` again. Paused time doesn't count toward elapsed or remaining. The scan starts on the ranking (*Working so far*) until you switch: then the next scans start on the table you left it on (saved to `~/.config/windscout/view.json`).
 
 ## All ports
 
@@ -248,7 +248,7 @@ Then the first parallel scan builds a local image, `windscout-worker`, with Node
 
 The mirrors come from [Mirava](https://github.com/MiravaOrg/Mirava)'s list of mirrors in Iran; they come and go, and that's where to look for new ones.
 
-**Kernel check:** each container first checks that docker's Linux kernel gives it what Windscribe needs: a tunnel device (tun) and a firewall (nftables). If not, the scan stops and says so, rather than showing every location as blocked. Windscribe's WireGuard also needs nftables' `fib` in its firewall table, which Docker Desktop's own Linux VM lacks (on macOS, and on Windows without WSL 2). There, WireGuard runs on this computer instead (see below).
+**Kernel check:** each container first checks that docker's Linux kernel gives it what Windscribe needs: a tunnel device (tun) and a firewall (nftables). If not, the scan stops and says so, rather than showing every location as blocked. Windscribe's WireGuard also needs nftables' `fib` in its firewall table, which Docker Desktop's own Linux VM lacks (on macOS, and on Windows without WSL 2). There, a parallel scan skips WireGuard (see below).
 
 **Login:** the containers' Windscribe apps log in with the session that the Windscribe app on this computer is logged in with, so they never log in with your password. Windscribe locks an account that logs in many times at once, and a login per container would do that. WindScout reads the session from the app's settings (`~/.config/Windscribe/Windscribe2.conf` on Linux, the `com.windscribe.Windscribe2` defaults on macOS, `HKEY_CURRENT_USER\Software\Windscribe\Windscribe2` in the registry on Windows) and hands it to each container on its standard input, not on a command line, where other programs could see it. Each container's docker volume (`windscout-1`, `windscout-2`, …) keeps its app's settings for the next scans, with the WireGuard keys it registered with your account. A volume that another account used starts over. If you log out of the Windscribe app, the containers' session ends too, and the next scan gives them the new one.
 
@@ -260,7 +260,7 @@ WindScout 0.6.0 asked for your username and password instead, and could save the
 
 **Differences from a normal scan:**
 
-- IKEv2, and WireGuard when the kernel check finds it can't run in the containers, are tried on this computer once the containers are done, one at a time like a normal scan. The scan screen shows them on a line of their own (`this computer`), and the picker's estimate counts them. Windscribe's Linux app has no IKEv2.
+- The containers do the whole scan: nothing runs on this computer. What they can't run is skipped: IKEv2 (Windscribe's Linux app has none), and WireGuard when the kernel check finds it can't run in the containers. The picker's docker line says so (`ikev2 skipped`), its estimate leaves them out, and a line after the scan lists them. To try them, scan without docker. If every container stops, the scan ends there, with what they found, and says why.
 - This computer's own Windscribe connection is disconnected at the start and stays off while the containers scan, since it would carry their traffic too.
 - No firewall: "block internet while scanning" isn't used, since it would block the containers' traffic too.
 

package/dist/cli.js

@@ -49,10 +49,14 @@ Examples: windscout -c DE,NL,TR -p stealth,tcp:443
           windscout connect`;
 // "DE, NL,,TR" → ["DE", "NL", "TR"]
 const list = (s) => s.split(",").map((x) => x.trim()).filter(Boolean);
-const ask = (question) => new Promise((resolve) => {
+/** The typed answer; one of instant is taken as soon as it's the whole answer, without enter */
+const ask = (question, instant = []) => new Promise((resolve) => {
     const rl = createInterface({ input: process.stdin, output: out });
+    // runs after readline's own keypress listener, so rl.line has the key in it
+    const onKey = () => instant.includes(rl.line.toLowerCase()) && (out.write("\n"), resolve(rl.line), rl.close());
+    process.stdin.on("keypress", onKey);
     rl.on("SIGINT", () => rl.close()); // Ctrl-C / Ctrl-D: no answer, null
-    rl.on("close", () => resolve(null));
+    rl.on("close", () => (process.stdin.off("keypress", onKey), resolve(null)));
     rl.question(question, (a) => (resolve(a.trim()), rl.close()));
 });
 /** Runs a result's connect command and checks it as the scan does: connected, on its port, with internet through it.
@@ -66,11 +70,12 @@ async function connectTo(r, timeout) {
     await disconnect();
     return false;
 }
-/** Asks which numbered connection to make (enter: the best), then runs its command and waits for it to connect */
+/** Asks which numbered connection to make (enter: the best), then runs its command and waits for it to connect.
+ * 0 and q need no enter; the other numbers do, since 1 may be the start of 10 */
 async function offerConnect(choices, timeout) {
     const others = choices.length > 2 ? `, 1-${choices.length - 1} = other` : choices.length > 1 ? ", 1 = other" : "";
     for (;;) {
-        const a = await ask(`\nconnect to # (enter or 0 = best${others}, q = quit): `);
+        const a = await ask(`\nconnect to # (enter or 0 = best${others}, q = quit): `, ["0", "q"]);
         if (a === null || /^q(uit)?$/i.test(a))
             return;
         const r = a === "" ? choices[0] : /^\d+$/.test(a) ? choices[Number(a)] : undefined;
@@ -218,34 +223,45 @@ async function main() {
     const attempts = plan(order, countries, protocols, fromLast?.results, lists);
     // the tables' columns: the protocols asked for, and the saved connections' own (only those, when only they are scanned)
     const scanned = [...new Set([...(order === "last-only" ? [] : protocols), ...attempts.map((x) => x.protocol)])];
-    let probers = [probe], after; // after: what runs here once the containers are done
-    const later = notInContainers(scanned, loadDockerWireGuard()); // as far as the last parallel scan knows
-    const inContainers = attempts.filter((x) => !later.has(x.protocol)).length;
-    if (docker && inContainers) {
-        const started = await startParallel(inContainers);
+    // a parallel scan is the containers' alone: the protocols they can't run (IKEv2, WireGuard on some kernels) aren't tried
+    let probers = [probe], skipped = new Set();
+    const inContainers = () => attempts.filter((x) => !skipped.has(x.protocol));
+    const nothingLeft = () => new Error(`the docker containers can't run ${[...skipped].join(" or ")}, and nothing else is selected:`
+        + " scan without --docker (d in the picker)");
+    if (docker && attempts.length) {
+        skipped = notInContainers(scanned, loadDockerWireGuard()); // as far as the last parallel scan knows
+        if (!inContainers().length)
+            throw nothingLeft();
+        const started = await startParallel(inContainers().length);
         if (!started)
             return leaveScreen();
         saveDockerWireGuard(started.wireguard);
         probers = started.probers;
-        after = { prober: probe, protocols: notInContainers(scanned, started.wireguard), name: "this computer" };
+        skipped = notInContainers(scanned, started.wireguard); // their kernel may not run WireGuard after all, or may now
+        if (!inContainers().length) {
+            await stopWorkers();
+            throw nothingLeft();
+        }
         await windscribe("disconnect"); // a VPN connection here would carry the containers' traffic too
     }
-    const scan = new Scan(countries, scanned, { timeout, speedTest, only: attempts, stopAtFirst }, probers, after);
+    const scan = new Scan(countries, scanned.filter((p) => !skipped.has(p)), { timeout, speedTest, only: inContainers(), stopAtFirst }, probers);
     // not with containers: their traffic goes out through this computer, and the firewall would block it
-    const blocking = firewall && !after && (await blockInternet());
+    const blocking = firewall && !docker && (await blockInternet());
     const view = tty ? showProgress(scan, blocking) : logProgress(scan);
     await scan.run(view);
-    if (after)
+    if (docker)
         await stopWorkers();
     await restoreFirewall();
     view.close();
     for (const e of new Set(scan.errors))
         console.error(yellow(e));
+    if (skipped.size)
+        console.error(yellow(`not tried: ${[...skipped].join(", ")}, which the docker containers can't run (a scan without --docker can)`));
     if (scan.found)
         console.log(green("stopped at the first connection that held up (a speed test, then staying up)"));
     else if (scan.stopping)
         console.log(yellow("interrupted, showing partial results"));
-    const choices = report(scan.results, scanned, { all: a.all, speedTest: speedTest || stopAtFirst }); // stop at the first measures speed
+    const choices = report(scan.results, scan.protocols, { all: a.all, speedTest: speedTest || stopAtFirst }); // stop at the first measures speed
     // its working connections replace the saved ones it tried, so what stopped working drops out; the saved ones it didn't try
     // (other countries, or what a stopped scan didn't get to) stay, after its own; a scan where nothing worked keeps the last
     const tried = new Set(scan.results.filter((r) => r.status !== "interrupted").map((r) => `${r.query} ${r.protocol}`));

package/dist/config.js

@@ -1,4 +1,5 @@
-// The picker's selection, what the last parallel scan found its containers can do, and the last scan's working results, remembered between runs.
+// The picker's selection, what the last parallel scan found its containers can do, the last scan's working results, and the
+// scan screen's table, remembered between runs.
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -11,6 +12,7 @@ export const MIN_TIMEOUT = 10; // seconds; shorter cuts off connections that wou
 export const CONFIG = join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "windscout", "config.json");
 const DOCKER_FILE = join(dirname(CONFIG), "docker.json"); // what the last parallel scan found its containers can do
 export const LAST_FILE = join(dirname(CONFIG), "last.json"); // the last scan's working connections
+const VIEW_FILE = join(dirname(CONFIG), "view.json"); // the table the scan screen was left on
 /** The saved choice, minus anything this version doesn't offer; null on first run or an unreadable file */
 export function loadConfig() {
     try {
@@ -54,6 +56,22 @@ export function saveDockerWireGuard(wireguard) {
     }
     catch { } // not being able to remember isn't worth failing the scan
 }
+/** The table the last scan was left on; the ranking until the user switches */
+export function loadView() {
+    try {
+        return JSON.parse(readFileSync(VIEW_FILE, "utf8")).view === "availability" ? "availability" : "ranking";
+    }
+    catch {
+        return "ranking";
+    }
+}
+export function saveView(view) {
+    try {
+        mkdirSync(dirname(VIEW_FILE), { recursive: true });
+        writeFileSync(VIEW_FILE, JSON.stringify({ view }) + "\n");
+    }
+    catch { } // not being able to remember isn't worth failing the scan
+}
 /** The last scan that found something; null when there's none or the file is unreadable */
 export function loadLast() {
     try {

package/dist/docker.js

@@ -29,7 +29,7 @@ const REGISTRIES = [...(process.env.WINDSCOUT_REGISTRY_MIRRORS?.split(",").map((
 // openresolv: the app sets the tunnel's DNS through resolvconf; without it, DNS goes nowhere once connected.
 // The CMD first checks the kernel (WSL's builds tun and parts of nftables as modules): no tun or nftables, no tunnel, so
 // the container stops saying so instead of scanning. The helper's WireGuard routing also puts a fib rule in an inet table,
-// which Docker Desktop's own kernel (macOS, Windows without WSL) can't run: WS_WIREGUARD=0 then, and it runs on this computer.
+// which Docker Desktop's own kernel (macOS, Windows without WSL) can't run: WS_WIREGUARD=0 then, and a parallel scan skips it.
 // No systemd in a container: start the helper (root) like its unit would; the worker starts the app once it has the session
 const DOCKERFILE = `FROM ${BASE_TAG}
 ENV LANG=C.UTF-8
@@ -107,8 +107,8 @@ export async function dockerState() {
 const WORKER_MEMORY = 250e6; // bytes per container: Windscribe's app and helper, a tunnel and node take ~120 MB
 // ponytail: past this, more containers mostly add load on the one uplink, and WireGuard keys on the account; raise if real scans say so
 const MAX_WORKERS = 16;
-/** Protocols the containers can't do, which a parallel scan runs on this computer after them: IKEv2 (Windscribe's Linux app
- * has none), and WireGuard when their kernel can't run its routing (see DOCKERFILE) */
+/** Protocols the containers can't do, which a parallel scan skips: IKEv2 (Windscribe's Linux app has none), and WireGuard
+ * when their kernel can't run its routing (see DOCKERFILE) */
 export const notInContainers = (protocols, wireguard) => new Set(protocols.filter((p) => /^ikev2(:|$)/.test(p) || (!wireguard && /^wireguard(:|$)/.test(p))));
 /** Containers for this many attempts, when docker can run at most `most`: one per attempt; past that, the fewest that need no
  * more rounds (17 attempts, 16 at most: 9 containers make 2 rounds, as 16 would), since fewer log in sooner and register fewer keys */

package/dist/scan.js

@@ -29,7 +29,6 @@ export class Scan {
     protocols;
     options;
     probers;
-    after;
     results = [];
     finished = []; // countries with every attempt done: the views refresh their tables per country
     errors = []; // why slots stopped early
@@ -46,16 +45,13 @@ export class Scan {
     idle = 0; // seconds spent paused
     resume = () => { };
     unpaused = Promise.resolve();
-    constructor(countries, protocols, options, probers = [probe], after) {
+    constructor(countries, protocols, options, probers = [probe]) {
         this.countries = countries;
         this.protocols = protocols;
         this.options = options;
         this.probers = probers;
-        this.after = after;
         this.total = this.attempts().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() {
@@ -87,15 +83,12 @@ export class Scan {
         const left = new Map(); // attempts to go, per country
         for (const { country } of queue)
             left.set(country, (left.get(country) ?? 0) + 1);
-        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);
+        // when every slot's container stops, what they left isn't tried: scan.errors says why
+        await Promise.all(this.probers.map((prober, i) => this.work(prober, this.slots[i], 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) {
+    /** One slot: takes the attempts from the queue, one at a time, until there are none */
+    async work(prober, slot, queue, left, hooks) {
         const { timeout, speedTest, stopAtFirst = false } = this.options;
         for (;;) {
             while (this.paused && !this.stopping) {
@@ -105,10 +98,9 @@ export class Scan {
                 }
                 await this.unpaused;
             }
-            const i = this.stopping ? -1 : queue.findIndex((a) => can(a.protocol));
-            if (i < 0)
+            const next = this.stopping ? undefined : queue.shift();
+            if (!next)
                 return;
-            const [next] = queue.splice(i, 1);
             const { country, protocol } = next;
             Object.assign(slot, { current: next, step: "", attemptStart: now() });
             hooks.attempt?.(country, protocol);

package/dist/tui/picker.js

@@ -41,12 +41,15 @@ export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst,
     };
     const ports = (p) => (allPorts && portLists?.get(p)?.length) || 1; // attempts per country for the protocol
     const perCountry = (ps) => [...ps].reduce((n, p) => n + ports(p), 0);
-    // what start scans, in its order: as the CLI plans it, so the estimate counts the same attempts
+    const wireguard = loadDockerWireGuard(); // in docker containers, as the last parallel scan found
+    // what start scans, in its order: as the CLI plans it, so the estimate counts the same attempts. A parallel scan is the
+    // containers' alone: the protocols they can't run are skipped
     const todo = () => {
         const ps = PROTOCOLS.filter((p) => protos.has(p));
-        return plan(order, COUNTRIES.filter((c) => selected.has(c)), allPorts && portLists ? withPorts(ps, portLists) : ps, last?.results, portLists ?? undefined);
+        const all = plan(order, COUNTRIES.filter((c) => selected.has(c)), allPorts && portLists ? withPorts(ps, portLists) : ps, last?.results, portLists ?? undefined);
+        const cant = notInContainers(docker ? all.map((a) => a.protocol) : [], wireguard);
+        return { list: all.filter((a) => !cant.has(a.protocol)), skipped: [...new Set([...cant].map((p) => p.split(":")[0]))] };
     };
-    const wireguard = loadDockerWireGuard(); // in docker containers, as the last parallel scan found
     enterScreen();
     return new Promise((resolve) => {
         const render = () => {
@@ -54,24 +57,24 @@ export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst,
                 return;
             const rows = out.rows || 24;
             const version = versionLines(true);
-            const matches = visible();
-            const height = Math.max(3, rows - 24 - version.length);
-            cursor = Math.max(0, Math.min(cursor, matches.length - 1));
-            if (cursor < top)
-                top = cursor;
-            if (cursor >= top + height)
-                top = cursor - height + 1;
-            top = Math.max(0, Math.min(top, matches.length - height));
             const off = order === "last-only"; // only the saved connections: the countries, protocols and ports are skipped
             const missing = needsLast(order) && !last; // a type by the last result, and no saved scan: start is off
             timeout = Number(seconds);
-            const list = todo(), n = list.length;
-            const base = (p) => p.split(":")[0]; // "wireguard:443" → "wireguard"
-            const scanned = new Set(list.map((a) => base(a.protocol)));
-            const here = PROTOCOLS.filter((p) => docker && scanned.has(p) && notInContainers(PROTOCOLS, wireguard).has(p)); // after the containers
-            const inContainers = list.filter((a) => !here.includes(base(a.protocol))).length;
-            const parallel = docker && dockerAt === "ready" && inContainers > 0;
-            const slots = parallel ? workerCount(inContainers) : 1;
+            const { list, skipped } = todo(), n = list.length;
+            // only the last results lists the countries it scans, all selected; the user's own selection is back with the other types
+            const matches = off ? [...new Set(list.map((a) => a.country))] : visible();
+            const height = Math.max(3, rows - 24 - version.length);
+            if (!off) { // so the selection's list keeps its cursor and scroll for then
+                cursor = Math.max(0, Math.min(cursor, matches.length - 1));
+                if (cursor < top)
+                    top = cursor;
+                if (cursor >= top + height)
+                    top = cursor - height + 1;
+                top = Math.max(0, Math.min(top, matches.length - height));
+            }
+            const from = off ? 0 : top; // the first row shown
+            const parallel = docker && dockerAt === "ready" && n > 0;
+            const slots = parallel ? workerCount(n) : 1;
             const login = parallel ? loginSeconds(slots) : 0; // the containers log in before the scan starts
             const protoLine = PROTOCOLS.map((p, i) => `${dim(under(String(i + 1)))} ${protos.has(p) ? (off ? dim : green)("● " + p) : dim("○ " + p)}`).join("   ");
             const listed = portLists && [...portLists.values()].some((l) => l.length), each = perCountry(protos);
@@ -95,8 +98,8 @@ export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst,
             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…")}`;
+                : (dockerAt === "ready" ? `${slots} at a time` : dockerAt ? "docker isn't ready: start sets it up" : "checking docker…")
+                    + (skipped.length ? ` · ${skipped.join(" and ")} skipped` : ""))}`;
             const saves = last ? plan("last-only", [], [], last.results, portLists ?? undefined).length : 0; // the saved connections, each once
             const firsts = list.filter((a) => a.saved).length; // those this scan tries first
             const orderLine = `${dim(under("o"))} scanning type ${bold(ORDER_NAMES[order])}  ${dim(missing
@@ -106,26 +109,26 @@ export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst,
                         : order === "last-first" ? `${firsts} of ${saves} saved selected · ${ago(last.at)}`
                             : `${saves} saved working connection${saves === 1 ? "" : "s"} · ${ago(last.at)}`)}`;
             const stopLabel = "stop at the first working connection";
-            // the best saved connection goes first (unless it waits for the containers): when it still holds up, the scan ends there
-            const lead = list[0]?.saved && !here.includes(base(list[0].protocol)) ? list[0] : null;
+            // the best saved connection goes first: when it still holds up, the scan ends there
+            const lead = list[0]?.saved ? list[0] : null;
             const stopLine = `${dim(under("w"))} ${stopAtFirst ? green("● " + stopLabel) : dim("○ " + stopLabel)}  ${dim(!stopAtFirst
                 ? "off: tries every attempt"
                 : lead ? `≈ ${duration(login + STEADY_SECONDS)} if ${lead.country} ${lead.protocol} still holds up`
                     : "after a speed and stability check")}`;
             const search = off
-                ? yellow("countries skipped: only the last results are scanned")
+                ? yellow("the last results' countries: only these are scanned")
                 : searching ? `${cyan("🔍")} ${bold(query)}${cyan("▏")}`
                     : query ? `🔍 ${query}` : dim("🔍 press / to search");
-            const shown = matches.slice(top, top + height);
-            const range = matches.length > height ? `${top + 1}–${top + shown.length} of ${matches.length}` : `${matches.length} countries`;
+            const shown = matches.slice(from, from + height);
+            const range = matches.length > height ? `${from + 1}–${from + shown.length} of ${matches.length}` : `${matches.length} countries`;
             const body = shown.map((code, j) => {
                 const current = !off && top + j === cursor;
-                const mark = selected.has(code) ? (off ? dim : green)("●") : dim("○");
+                const mark = off || selected.has(code) ? (off ? dim : green)("●") : dim("○");
                 const name = `${flag(code)} ${countryName(code)}`;
                 return [`${current ? cyan("❯") : " "} ${mark}`, current ? bold(code) : dim(code), current ? bold(cyan(name)) : off ? dim(name) : name];
             });
             if (!body.length)
-                body.push(["   ", "", dim("no country matches")]);
+                body.push(["   ", "", dim(off ? "no saved scan yet" : "no country matches")]);
             const buttons = [
                 ["start", starting < 0 ? "▶ Start" : `${spin(starting++)} Starting…`],
                 ["all", under("A") + (query ? "ll shown" : "ll")],
@@ -138,10 +141,10 @@ export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst,
             const width = vw(table[0]);
             const head = box(settings, {
                 title: bold(cyan("WindScout")),
-                right: `${(off ? dim : bold)(String(selected.size))}${dim(`/${COUNTRIES.length} selected`)}`,
+                right: `${(off ? dim : bold)(String(off ? matches.length : selected.size))}${dim(`/${COUNTRIES.length} selected`)}`,
                 width: width - 4,
             });
-            const total = login + estimate(inContainers, timeout, slots) + estimate(n - inContainers, timeout);
+            const total = login + estimate(n, timeout, slots);
             const costs = dim(`(~${attemptSeconds(timeout)}s each${slots > 1 ? `, ${slots} at a time` : ""}${login ? `, + ~${duration(login)} login` : ""})`);
             const lines = [
                 ...head,
@@ -151,7 +154,8 @@ export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst,
                 "",
                 centerIn(missing
                     ? yellow("no saved scan yet, so start is off: press o for another scanning type")
-                    : !n ? yellow(`select at least one country and one protocol${last ? ", or o for only the last results" : ""}`)
+                    : !n ? yellow(skipped.length ? `the docker containers can't run ${skipped.join(" or ")}: d turns docker off`
+                        : `select at least one country and one protocol${last ? ", or o for only the last results" : ""}`)
                         : stopAtFirst // it can end at any attempt: this is when none holds up
                             ? `up to ${bold(String(n))} attempts · at most ${bold("≈ " + duration(total))} ${costs}`
                             : `${bold(String(n))} attempts · estimated ${bold("≈ " + duration(total))} ${costs}`, width),
@@ -207,7 +211,7 @@ export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst,
         const start = () => {
             if (needsLast(order) && !last)
                 return false; // start is off: the warning under the table says why
-            if (!todo().length) {
+            if (!todo().list.length) {
                 message = "nothing to scan yet";
                 return false;
             }

package/dist/tui/progress.js

@@ -1,3 +1,4 @@
+import { loadView, saveView } from "../config.js";
 import { sortOk } from "../probe.js";
 import { attemptSeconds } from "../scan.js";
 import { duration, now } from "../time.js";
@@ -8,13 +9,13 @@ import { matrix, resultTable } from "./tables.js";
 import { draw, enterScreen, input, leaveScreen, out, repoLink } from "./terminal.js";
 import { bold, cyan, dim, green, red, vw, yellow } from "./text.js";
 import { bar, box, centerIn, spin } from "./widgets.js";
-/** Progress bar, current attempt, results so far. tab switches the table, p pauses, q stops (twice: quits).
+/** Progress bar, current attempt, results so far. tab switches the table (the next scans start on it), p pauses, q stops (twice: quits).
  * blocking: we turned the firewall on for the scan */
 export function showProgress(scan, blocking) {
     const { protocols, options: { timeout } } = scan;
     const speedTest = scan.options.speedTest || Boolean(scan.options.stopAtFirst); // stop at the first measures speed too
     let quitting = false; // q pressed: a second one quits right away
-    let view = speedTest ? "ranking" : "availability"; // tab switches
+    let view = loadView(); // tab switches, and saves it for the next scans
     let frame = 0;
     const render = () => {
         const rows = out.rows || 24;
@@ -60,8 +61,8 @@ export function showProgress(scan, blocking) {
         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 s.step ? ` ${red("✗")} ${dim(clip(s.step, inner - 3))}` : dim(" · idle");
+            const head = ` ${cyan(spinner)} ${bold(attempt(s))} `, time = ` · ${duration(now() - s.attemptStart)}`;
             return head + dim(clip(s.step, inner - vw(head) - time.length) + time);
         };
         const panel = box([
@@ -98,6 +99,7 @@ export function showProgress(scan, blocking) {
     input.on("keypress", async (_str, key = {}) => {
         if (key.name === "tab") {
             view = view === "ranking" ? "availability" : "ranking";
+            saveView(view);
             render();
         }
         else if (key.name === "p" || key.name === "space") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windscout",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Find which Windscribe locations and protocols work from your network, ranked by speed (unofficial)",
   "type": "module",
   "bin": {