windscout 0.6.5 → 0.7.1

package/dist/tui/picker.js

@@ -1,23 +1,39 @@
 import { loadDockerWireGuard, MIN_TIMEOUT, saveConfig, SPEED_TEST } from "../config.js";
 import { dockerState, loginSeconds, notInContainers, workerCount } from "../docker.js";
-import { attemptSeconds, estimate } from "../scan.js";
+import { STEADY_SECONDS } from "../probe.js";
+import { attemptSeconds, estimate, ORDERS, plan } from "../scan.js";
 import { duration } from "../time.js";
 import { canUpdate, checkUpdate, versionLines } from "../update.js";
-import { COUNTRIES, protocolPorts, PROTOCOLS } from "../windscribe.js";
+import { COUNTRIES, protocolPorts, PROTOCOLS, withPorts } 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 { draw, drawUntilNext, 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";
+import { box, centerIn, grid, spin } from "./widgets.js";
+const ORDER_NAMES = {
+    default: "default",
+    random: "by random country",
+    "last-first": "by last success result first",
+    "last-only": "only the last results",
+};
+const needsLast = (o) => o === "last-first" || o === "last-only";
+// only the last results: the countries, protocols and ports are greyed out, and their keys and clicks say why
+const SKIPPED = "skipped with only the last results: o changes the scanning type";
 const flip = (set, value) => (set.has(value) ? set.delete(value) : set.add(value));
+// "5m ago", "3h ago", "2 days ago"
+const ago = (ms) => {
+    const m = Math.max(0, Math.round((Date.now() - ms) / 60000)), h = Math.round(m / 60), d = Math.round(h / 24);
+    return m < 1 ? "just now" : m < 60 ? `${m}m ago` : h < 48 ? `${h}h ago` : `${d} days ago`;
+};
 /** 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, allPorts, docker }) {
+export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst, allPorts, docker, last }) {
     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 portLists = null; // each protocol's ports, once the app said
+    let starting = -1; // once start is pressed: the start button's spinner frame, until the next screen shows
     let hit;
     const visible = () => {
         const q = query.toLowerCase();
@@ -25,8 +41,15 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
     };
     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);
-    const attempts = () => selected.size * perCountry(protos);
     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));
+        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]))] };
+    };
     enterScreen();
     return new Promise((resolve) => {
         const render = () => {
@@ -34,89 +57,114 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
                 return;
             const rows = out.rows || 24;
             const version = versionLines(true);
-            const matches = visible();
-            const height = Math.max(3, rows - 23 - 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 protoLine = PROTOCOLS.map((p, i) => `${dim(under(String(i + 1)))} ${protos.has(p) ? green("● " + p) : dim("○ " + p)}`).join("   ");
+            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, 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);
-            const portsLine = `${dim(under("p"))} ${allPorts ? green("● all ports") : dim("○ all ports")}  ${dim(!allPorts
-                ? "off: each protocol on its default port"
-                : !portLists ? "checking the ports…"
-                    : !listed ? "this Windscribe app can't list its ports: 2.22 and newer can"
-                        : `every port of each protocol: ${each} attempt${each === 1 ? "" : "s"} per country${each > protos.size ? `, not ${protos.size}` : ""}`)}`;
+            const portsLine = `${dim(under("p"))} ${allPorts ? (off ? dim : green)("● all ports") : dim("○ all ports")}  ${dim(off
+                ? "not used: each saved connection on its own protocol and port"
+                : !allPorts
+                    ? "off: each protocol on its default port"
+                    : !portLists ? "checking the ports…"
+                        : !listed ? "this Windscribe app can't list its ports: 2.22 and newer can"
+                            : `every port of each protocol: ${each} attempt${each === 1 ? "" : "s"} per country${each > protos.size ? `, not ${protos.size}` : ""}`)}`;
             const speedLine = `${dim(under("s"))} ${speedTest ? green("● speed test") : dim("○ speed test")}  ${dim(speedTest
                 ? "ranks by download speed · adds ~15s per working connection"
-                : "off: connect-only, ranks by latency")}`;
+                : stopAtFirst ? "off · stop at the first still runs it on each 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(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 * perCountry([...protos].filter((p) => !here.includes(p)));
-            const parallel = docker && dockerAt === "ready" && inContainers > 0;
-            const slots = parallel ? workerCount(inContainers) : 1;
-            const login = parallel ? loginSeconds(slots) : 0; // the containers log in before the scan starts
             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");
-            const shown = matches.slice(top, top + height);
-            const range = matches.length > height ? `${top + 1}–${top + shown.length} of ${matches.length}` : `${matches.length} countries`;
+                : (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
+                ? "no saved scan yet"
+                : order === "default" ? "countries in list order"
+                    : order === "random" ? "countries shuffled, a new order each run"
+                        : 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: 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("the last results' countries: only these are scanned")
+                : searching ? `${cyan("🔍")} ${bold(query)}${cyan("▏")}`
+                    : query ? `🔍 ${query}` : dim("🔍 press / to search");
+            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 here = top + j === cursor;
-                const mark = selected.has(code) ? green("●") : dim("○");
+                const current = !off && top + j === cursor;
+                const mark = off || selected.has(code) ? (off ? dim : green)("●") : dim("○");
                 const name = `${flag(code)} ${countryName(code)}`;
-                return [`${here ? cyan("❯") : " "} ${mark}`, here ? bold(code) : dim(code), here ? bold(cyan(name)) : name];
+                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", "▶ Start"],
+                ["start", starting < 0 ? "▶ Start" : `${spin(starting++)} Starting…`],
                 ["all", under("A") + (query ? "ll shown" : "ll")],
                 ["none", under("N") + (query ? "one shown" : "one")],
                 ["quit", under("Q") + "uit"],
             ];
-            const buttonLine = buttons.map(([id, label]) => (id === "start" ? bold(cyan(`[ ${label} ]`)) : dim(`[ ${label} ]`))).join("  ");
-            const settings = [protoLine, portsLine, ...(SPEED_TEST ? [speedLine] : []), fwLine, randomLine, timeoutLine, dockerLine];
+            const buttonLine = buttons.map(([id, label]) => (id === "start" && n && !missing ? bold(cyan(`[ ${label} ]`)) : dim(`[ ${label} ]`))).join("  ");
+            const settings = [protoLine, portsLine, ...(SPEED_TEST ? [speedLine] : []), fwLine, timeoutLine, dockerLine, orderLine, stopLine];
             const table = grid([{ title: "" }, { title: "Code" }, { title: "Country" }], body, { caption: search, captionRight: dim(range), minWidth: Math.max(...settings.map(vw)) + 4 });
             const width = vw(table[0]);
             const head = box(settings, {
                 title: bold(cyan("WindScout")),
-                right: `${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(n, timeout, slots);
+            const costs = dim(`(~${attemptSeconds(timeout)}s each${slots > 1 ? `, ${slots} at a time` : ""}${login ? `, + ~${duration(login)} login` : ""})`);
             const lines = [
                 ...head,
                 ...table,
                 "",
                 centerIn(buttonLine, width),
                 "",
-                centerIn(n
-                    ? `${bold(String(n))} attempts · estimated ${bold("≈ " + duration(login + estimate(inContainers, timeout, slots) + estimate(n - inContainers, timeout)))} ${dim(`(~${attemptSeconds(timeout)}s each${slots > 1 ? `, ${slots} at a time` : ""}${login ? `, + ~${duration(login)} login` : ""})`)}`
-                    : yellow("select at least one country and one protocol"), width),
+                centerIn(missing
+                    ? yellow("no saved scan yet, so start is off: press o for another scanning type")
+                    : !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),
                 centerIn(dim(editing
                     ? "type the seconds to wait for each connection · enter/esc done"
                     : searching
                         ? "type to filter · ↑↓ move · enter/esc done"
-                        // 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 · p ports${SPEED_TEST ? " · s speed" : ""} · f firewall · r random · t timeout · d docker`), width),
+                centerIn(dim(searching || editing ? "" : `1-${PROTOCOLS.length} protocols · p ports${SPEED_TEST ? " · s speed" : ""} · f firewall · t timeout · d docker · o type · w first`), width),
             ];
             if (message)
                 lines.push(centerIn(yellow(message), width));
@@ -140,7 +188,7 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
             });
             hit = {
                 protoRow: row(protoLine), protoHits, portsRow: row(portsLine), speedRow: SPEED_TEST ? row(speedLine) : -1,
-                firewallRow: row(fwLine), randomRow: row(randomLine), timeoutRow: row(timeoutLine), dockerRow: row(dockerLine),
+                firewallRow: row(fwLine), timeoutRow: row(timeoutLine), dockerRow: row(dockerLine), orderRow: row(orderLine), stopRow: row(stopLine),
                 searchRow: at.top + head.length + 1,
                 firstRow: at.top + head.length + 5, shown: shown.length,
                 buttonRow: at.top + head.length + table.length + 1, buttonHits,
@@ -161,7 +209,9 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
             resolve(value);
         };
         const start = () => {
-            if (!attempts()) {
+            if (needsLast(order) && !last)
+                return false; // start is off: the warning under the table says why
+            if (!todo().list.length) {
                 message = "nothing to scan yet";
                 return false;
             }
@@ -175,15 +225,20 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
                 protocols: PROTOCOLS.filter((p) => protos.has(p)),
                 speed: speedTest,
                 firewall,
-                random,
+                order,
+                stopAtFirst,
                 allPorts,
                 timeout,
                 docker,
             };
             saveConfig(choice);
             finish(choice);
+            // the scan can take a moment to show (the firewall, docker): the button spins until its screen, or a docker one, draws
+            starting = 0;
+            drawUntilNext(render);
             return true;
         };
+        const cycleOrder = () => (order = ORDERS[(ORDERS.indexOf(order) + 1) % ORDERS.length]); // o: the next scanning type
         // 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") {
@@ -205,14 +260,20 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
             if (!m.press)
                 return;
             message = "";
-            const matches = visible();
+            const matches = visible(), off = order === "last-only";
             const { x, y } = m;
+            const button = y === hit.buttonRow ? hit.buttonHits.find(([, a, b]) => x >= a && x < b)?.[0] : undefined;
+            const onCountries = y === hit.searchRow || (y >= hit.firstRow && y < hit.firstRow + hit.shown) || button === "all" || button === "none";
+            if (off && (m.button === 64 || m.button === 65))
+                return; // the skipped countries don't scroll
             if (m.button === 64)
                 cursor = Math.max(0, cursor - 3); // wheel up
             else if (m.button === 65)
                 cursor = Math.min(matches.length - 1, cursor + 3); // wheel down
             else if (m.button !== 0)
                 return; // left button only
+            else if (off && (onCountries || y === hit.protoRow || y === hit.portsRow))
+                message = SKIPPED;
             else if (y === hit.searchRow)
                 searching = true, editing = false;
             else if (y === hit.timeoutRow)
@@ -236,19 +297,20 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
                     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.orderRow)
+                    cycleOrder();
+                else if (y === hit.stopRow)
+                    stopAtFirst = !stopAtFirst;
                 else if (y === hit.buttonRow) {
-                    const id = hit.buttonHits.find(([, a, b]) => x >= a && x < b)?.[0];
-                    if (id === "start" && start())
+                    if (button === "start" && start())
                         return;
-                    if (id === "quit")
+                    if (button === "quit")
                         return finish(null);
-                    if (id === "all")
+                    if (button === "all")
                         matches.forEach((c) => selected.add(c));
-                    if (id === "none")
+                    if (button === "none")
                         matches.forEach((c) => selected.delete(c));
                 }
             }
@@ -267,9 +329,14 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
                 flip(selected, c);
                 cursor = Math.min(matches.length - 1, cursor + 1);
             };
+            // only the last results: the keys for the countries, protocols and ports change nothing
+            const skipped = order === "last-only" && !editing && !searching
+                && (["up", "down", "pageup", "pagedown", "home", "end", "j", "k", "space", "a", "n", "p"].includes(k ?? "") || str === "/" || /^[1-9]$/.test(str ?? ""));
             if (key.ctrl && k === "c")
                 return finish(null);
-            if (k === "up")
+            if (skipped)
+                message = SKIPPED;
+            else if (k === "up")
                 cursor = Math.max(0, cursor - 1);
             else if (k === "down")
                 cursor = Math.min(matches.length - 1, cursor + 1);
@@ -318,12 +385,14 @@ export function pick(saved, { timeout, speedTest, firewall, random, allPorts, do
                 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 === "o")
+                cycleOrder();
+            else if (k === "w")
+                stopAtFirst = !stopAtFirst;
             else if (k === "u" && canUpdate())
                 return finish("update");
             else if (/^[1-9]$/.test(str ?? "") && PROTOCOLS[Number(str) - 1])

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";
@@ -7,12 +8,14 @@ import { countryName, flag } from "./country.js";
 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 } from "./widgets.js";
-/** Progress bar, current attempt, results so far. tab switches the table, p pauses, q stops (twice: quits).
+import { bar, box, centerIn, spin } from "./widgets.js";
+/** 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, speedTest } } = scan;
-    let view = speedTest ? "ranking" : "availability"; // tab switches
+    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 = loadView(); // tab switches, and saves it for the next scans
     let frame = 0;
     const render = () => {
         const rows = out.rows || 24;
@@ -22,7 +25,7 @@ export function showProgress(scan, blocking) {
         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) / slots.length);
-        const spinner = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"[frame++ % 10];
+        const spinner = spin(frame++);
         const ok = sortOk(results);
         // blocked: nothing worked, and something was really tried (a key limit or a port the app doesn't offer tries nothing)
         const failed = finished.filter((c) => !results.some((r) => r.query === c && r.status === "ok")
@@ -51,14 +54,15 @@ 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 status = scan.found ? green(" ✓ a connection held up · stopping the other attempts…")
+            : 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 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([
@@ -95,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") {
@@ -102,12 +107,13 @@ export function showProgress(scan, blocking) {
             render();
         }
         else if (key.name === "q" || key.name === "escape" || (key.ctrl && key.name === "c")) {
-            if (scan.stopping) { // second press: bail out now
+            if (quitting) { // second press: bail out now
                 leaveScreen();
                 console.error(`stopped. the VPN may still be connecting: run '${CLI} disconnect'`);
                 await restoreFirewall();
                 process.exit(130);
             }
+            quitting = true;
             scan.stop();
             render();
         }
@@ -126,11 +132,13 @@ const clip = (s, n) => (s.length > n ? s.slice(0, Math.max(0, n - 1)) + "…" :
 /** 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
+    let quitting = false; // Ctrl-C pressed: a second one quits right away
     process.on("SIGINT", async () => {
-        if (scan.stopping) {
+        if (quitting) {
             await restoreFirewall();
             process.exit(130);
         }
+        quitting = true;
         scan.stop();
     });
     return {

package/dist/tui/tables.js

@@ -14,7 +14,7 @@ const resultRow = (r, i) => [
     r.connectS === null ? "-" : `${fmt(r.connectS, 1)} s`,
     r.latencyMs === null ? "-" : `${fmt(r.latencyMs, 0)} ms`,
     r.speedMbps === null ? "-" : bold(`${fmt(r.speedMbps, 1)} Mbps`),
-    r.status === "ok" ? green("✓ ok") : r.status === "key limit" || r.status === "no such port" ? yellow(r.status) : red(r.status),
+    r.status === "ok" ? green("✓ ok") : ["key limit", "no such port", "unreliable"].includes(r.status) ? yellow(r.status) : red(r.status),
 ];
 /** Numbered attempts, in the given order; the Speed column only when the speed test ran */
 export function resultTable(results, speedTest, options) {

package/dist/tui/terminal.js

@@ -13,6 +13,8 @@ export const input = new PassThrough();
 emitKeypressEvents(input);
 let fullscreen = false;
 let link = null; // where draw() last put the repo link
+let waiting; // drawUntilNext()'s timer
+let redrawing = false; // drawUntilNext()'s own redraw is drawing
 const openUrl = (url) => spawn({ darwin: "open", win32: "explorer" }[process.platform] ?? "xdg-open", [url], { stdio: "ignore", detached: true })
     .on("error", () => { }).unref();
 // SGR mouse report: ESC [ < button ; col ; row (M = press, m = release)
@@ -40,6 +42,7 @@ export function enterScreen() {
 }
 /** Back to the normal screen; drops every key and mouse listener */
 export function leaveScreen() {
+    clearInterval(waiting);
     if (!fullscreen)
         return;
     fullscreen = false;
@@ -51,8 +54,26 @@ export function leaveScreen() {
     out.write("\x1b[?1000l\x1b[?1006l\x1b[?25h\x1b[?1049l");
 }
 process.on("exit", leaveScreen);
+/** Calls redraw every 120 ms (for a spinner) while the screen waits for the next one: until another screen draws, or leaveScreen() */
+export function drawUntilNext(redraw) {
+    const tick = () => {
+        redrawing = true;
+        try {
+            redraw();
+        }
+        finally {
+            redrawing = false;
+        }
+    };
+    clearInterval(waiting);
+    waiting = setInterval(tick, 120);
+    waiting.unref(); // never what keeps the process alive
+    tick();
+}
 /** Redraws in place, centered: home, each line cleared to its end, then clear below (no flicker). Returns the top-left corner */
 export function draw(lines) {
+    if (!redrawing)
+        clearInterval(waiting); // another screen: it takes over from drawUntilNext()
     const cols = out.columns || 80, rows = out.rows || 24;
     const w = Math.max(...lines.map(vw));
     const left = " ".repeat(Math.max(0, Math.floor((cols - w) / 2)));

package/dist/tui/widgets.js

@@ -32,6 +32,8 @@ export function grid(cols, rows, { caption, captionRight = "", minWidth = 0, str
     out.push(row(cols.map((c) => bold(c.title))), rule("├", "┼", "┤"), ...rows.map(row), rule("╰", "┴", "╯"));
     return out;
 }
+/** A spinner's character for this frame */
+export const spin = (frame) => "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"[frame % 10];
 /** s, indented to sit centered in width columns */
 export const centerIn = (s, width) => " ".repeat(Math.max(0, Math.floor((width - vw(s)) / 2))) + s;
 /** Gradient bar (cyan → green) with eighth-block precision on the leading edge */

package/dist/worker.js

@@ -55,9 +55,9 @@ export async function worker() {
         if (!m.probe)
             continue;
         stop = false;
-        const { query, protocol, timeout, speedTest } = m.probe;
+        const { query, protocol, timeout, speedTest, steady } = m.probe;
         const result = await probe(query, protocol, {
-            timeout, speedTest,
+            timeout, speedTest, steady,
             stopped: () => stop,
             onStep: (step) => send({ step }),
             measure: async (fn) => {

package/package.json

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