windscout 0.7.0 → 0.9.0

package/dist/tui/picker.js

@@ -1,8 +1,8 @@
-import { loadDockerWireGuard, MIN_TIMEOUT, saveConfig, SPEED_TEST } from "../config.js";
+import { loadDockerWireGuard, MIN_HOLD, MIN_TIMEOUT, saveConfig, SPEED_TEST } from "../config.js";
 import { dockerState, loginSeconds, notInContainers, workerCount } from "../docker.js";
-import { STEADY_SECONDS } from "../probe.js";
+import { steadySeconds } from "../probe.js";
 import { attemptSeconds, estimate, ORDERS, plan } from "../scan.js";
-import { duration } from "../time.js";
+import { ago, duration } from "../time.js";
 import { canUpdate, checkUpdate, versionLines } from "../update.js";
 import { COUNTRIES, protocolPorts, PROTOCOLS, withPorts } from "../windscribe.js";
 import { countryName, flag } from "./country.js";
@@ -20,17 +20,13 @@ 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, order, stopAtFirst, allPorts, docker, last }) {
+export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst, hold, 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
+    const typed = { timeout: String(timeout), hold: String(hold) }; // the settings in seconds, as typed
+    let editing = null; // the one being 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
@@ -41,12 +37,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 +53,25 @@ 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;
+            timeout = Number(typed.timeout);
+            hold = Number(typed.hold);
+            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 - 25 - 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);
@@ -90,13 +90,14 @@ export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst,
             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 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}`)}`;
+            // a setting in seconds: as typed, with the cursor while typing, yellow when it's under its least
+            const field = (k, least) => editing === k ? bold(typed[k]) + cyan("▏") : (Number(typed[k]) < least ? yellow : bold)(typed[k] || "?");
+            const timeoutLine = `${dim(under("t"))} timeout ${field("timeout", MIN_TIMEOUT)} s  ${dim(`per connection · at least ${MIN_TIMEOUT}`)}`;
             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 +107,29 @@ 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")}`;
+                : lead ? `≈ ${duration(login + steadySeconds(hold))} if ${lead.country} ${lead.protocol} still holds up`
+                    : `≈ ${duration(steadySeconds(hold))} of checks per working one`)}`;
+            const holdLine = `${dim(under("h"))} hold ${field("hold", MIN_HOLD)} s  ${dim(stopAtFirst
+                ? `each working one stays connected this long · at least ${MIN_HOLD}`
+                : "not used: stop at the first is off")}`;
             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")],
@@ -133,15 +137,15 @@ export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst,
                 ["quit", under("Q") + "uit"],
             ];
             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 settings = [protoLine, portsLine, ...(SPEED_TEST ? [speedLine] : []), fwLine, timeoutLine, dockerLine, orderLine, stopLine, holdLine];
             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: `${(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,15 +155,18 @@ 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" : ""}`)
-                        : 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}`
+                    : !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, and each working one adds its checks (the w line)
+                            ? `up to ${bold(String(n))} attempts · ${bold("≈ " + duration(total))} if none connects ${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"
-                        : `↑↓ move · space select · a/n ${query ? "all/none shown · esc clear" : "all/none · / search"} · enter start · q quit`), width),
+                centerIn(dim(editing === "hold"
+                    ? "type the seconds each working connection has to stay connected · enter/esc done"
+                    : 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 · 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 · t timeout · d docker · o type · w first`), width),
             ];
             if (message)
@@ -184,7 +191,7 @@ export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst,
             });
             hit = {
                 protoRow: row(protoLine), protoHits, portsRow: row(portsLine), speedRow: SPEED_TEST ? row(speedLine) : -1,
-                firewallRow: row(fwLine), timeoutRow: row(timeoutLine), dockerRow: row(dockerLine), orderRow: row(orderLine), stopRow: row(stopLine),
+                firewallRow: row(fwLine), timeoutRow: row(timeoutLine), dockerRow: row(dockerLine), orderRow: row(orderLine), stopRow: row(stopLine), holdRow: row(holdLine),
                 searchRow: at.top + head.length + 1,
                 firstRow: at.top + head.length + 5, shown: shown.length,
                 buttonRow: at.top + head.length + table.length + 1, buttonHits,
@@ -207,7 +214,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;
             }
@@ -215,6 +222,10 @@ export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst,
                 message = `the timeout must be at least ${MIN_TIMEOUT} seconds`;
                 return false;
             }
+            if (stopAtFirst && !(hold >= MIN_HOLD)) {
+                message = `the hold must be at least ${MIN_HOLD} seconds`;
+                return false;
+            }
             // keep the user's order of preference stable: list order
             const choice = {
                 countries: COUNTRIES.filter((c) => selected.has(c)),
@@ -223,6 +234,7 @@ export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst,
                 firewall,
                 order,
                 stopAtFirst,
+                hold,
                 allPorts,
                 timeout,
                 docker,
@@ -271,11 +283,13 @@ export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst,
             else if (off && (onCountries || y === hit.protoRow || y === hit.portsRow))
                 message = SKIPPED;
             else if (y === hit.searchRow)
-                searching = true, editing = false;
+                searching = true, editing = null;
             else if (y === hit.timeoutRow)
-                editing = true, searching = false;
+                editing = "timeout", searching = false;
+            else if (y === hit.holdRow)
+                editing = "hold", searching = false;
             else {
-                searching = editing = false; // clicking anywhere else ends typing, like leaving a text field
+                searching = false, editing = null; // clicking anywhere else ends typing, like leaving a text field
                 if (y >= hit.firstRow && y < hit.firstRow + hit.shown) {
                     cursor = top + (y - hit.firstRow);
                     const c = matches[cursor];
@@ -341,12 +355,13 @@ export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst,
             else if (k === "pagedown")
                 cursor = Math.min(matches.length - 1, cursor + 10);
             else if (editing) {
+                const text = typed[editing];
                 if (k === "return" || k === "escape")
-                    editing = false;
+                    editing = null;
                 else if (k === "backspace")
-                    seconds = seconds.slice(0, -1);
-                else if (/^[0-9]$/.test(str ?? "") && seconds.length < 4)
-                    seconds = seconds === "0" ? str : seconds + str;
+                    typed[editing] = text.slice(0, -1);
+                else if (/^[0-9]$/.test(str ?? "") && text.length < 4)
+                    typed[editing] = text === "0" ? str : text + str;
             }
             else if (searching) {
                 // typing goes into the search box; letters are not shortcuts here
@@ -382,7 +397,9 @@ export function pick(saved, { timeout, speedTest, firewall, order, stopAtFirst,
             else if (k === "f")
                 firewall = !firewall;
             else if (k === "t")
-                editing = true, seconds = "";
+                editing = "timeout", typed.timeout = "";
+            else if (k === "h")
+                editing = "hold", typed.hold = "";
             else if (k === "d")
                 return void toggleDocker();
             else if (k === "o")

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/dist/tui/report.js

@@ -1,12 +1,11 @@
 // The final report, printed to the normal screen so it stays in the scrollback.
-import { sortOk } from "../probe.js";
+import { sortOk, target } from "../probe.js";
+import { ago } from "../time.js";
 import { CLI } from "../windscribe.js";
 import { flag } from "./country.js";
 import { matrix, resultTable } from "./tables.js";
-import { bold, cyan, dim, fmt, green, vw, yellow } from "./text.js";
+import { bold, cyan, dim, fmt, green, red, vw, yellow } from "./text.js";
 import { box, grid } from "./widgets.js";
-// nickname pins the exact datacenter
-export const target = (r) => r.location.split(" - ").at(-1) || r.query;
 export const command = (r) => `${CLI} connect "${target(r)}" ${r.protocol}`;
 /** Prints the report; returns the connections it numbered: the best (#0), then the others (#1…) */
 export function report(results, protocols, { all, speedTest }) {
@@ -62,3 +61,14 @@ export function report(results, protocols, { all, speedTest }) {
         console.log(rest.join("\n"));
     return [b, ...others];
 }
+/** Prints the list as the results screen left it, best first, as windscout connect will try it: on the way out, when it
+ * changed there (a test, a drop, a background check) */
+export function printList(list) {
+    if (!list.length)
+        return;
+    const speeds = list.some((e) => e.speedMbps !== null);
+    console.log(grid([{ title: "#", align: "right" }, { title: "Location" }, { title: "Protocol" }, { title: "Latency", align: "right" },
+        ...(speeds ? [{ title: "Speed", align: "right" }] : []), { title: "Last check" }], list.map((e, i) => [dim(String(i + 1)), `${flag(e.query)} ${e.location || e.query}`, e.protocol,
+        e.latencyMs === null ? "-" : `${fmt(e.latencyMs, 0)} ms`, ...(speeds ? [e.speedMbps === null ? "-" : `${fmt(e.speedMbps, 1)} Mbps`] : []),
+        e.failed ? red(`✗ ${e.failed} · ${ago(e.failedAt ?? Date.now())}`) : e.checked ? green(`✓ ${ago(e.checked)}`) : dim("✓ in the scan")]), { caption: `${bold("Your connections now")} ${dim("· saved: windscout connect tries them in this order")}`, minWidth: 64 }).join("\n"));
+}