windscout 0.7.0 → 0.9.0

package/dist/cli.js

@@ -2,30 +2,41 @@
 // WindScout: find which Windscribe locations and protocols actually work from here.
 // Drives the official windscribe-cli: connects to each country/protocol pair,
 // measures latency and download speed through the tunnel, prints a ranked table.
+// In a terminal, the results then stay on screen (tui/results.ts): connect, test again, and stay connected.
 import { createInterface } from "node:readline";
 import { spawnSync } from "node:child_process";
 import { parseArgs } from "node:util";
-import { CONFIG, DEFAULT_TIMEOUT, forgetLogin, LAST_FILE, loadConfig, loadDockerWireGuard, loadLast, MIN_TIMEOUT, saveDockerWireGuard, saveLast, SPEED_TEST } from "./config.js";
+import { dockerChecker } from "./background.js";
+import { CONFIG, DEFAULT_HOLD, DEFAULT_TIMEOUT, forgetLogin, LAST_FILE, loadConfig, loadDockerWireGuard, loadLast, MIN_HOLD, MIN_TIMEOUT, saveDockerWireGuard, saveLast, SPEED_TEST } from "./config.js";
 import { notInContainers, stopWorkers } from "./docker.js";
-import { attempt, disconnect, MIN_MBPS, probe } from "./probe.js";
+import { disconnect, MIN_MBPS, probe } from "./probe.js";
 import { ORDERS, plan, Scan } from "./scan.js";
+import { connectFrom } from "./tui/connect.js";
 import { startParallel } from "./tui/docker.js";
 import { pick } from "./tui/picker.js";
 import { logProgress, showProgress } from "./tui/progress.js";
-import { command, report, target } from "./tui/report.js";
+import { report } from "./tui/report.js";
+import { showResults } from "./tui/results.js";
 import { leaveScreen, out } from "./tui/terminal.js";
-import { cyan, green, yellow } from "./tui/text.js";
-import { duration, now } from "./time.js";
+import { green, yellow } from "./tui/text.js";
+import { duration } from "./time.js";
 import { canUpdate, checkUpdate, runUpdate, updateNotice, versionLines } from "./update.js";
-import { blockInternet, CLI, isFirewallOn, protocolPorts, PROTOCOLS, restoreFirewall, waitForLogin, windscribe, withPorts } from "./windscribe.js";
+import { blockInternet, CLI, isFirewallOn, protocolPorts, PROTOCOLS, restoreFirewall, waitForLogin, withPorts } from "./windscribe.js";
 import { worker } from "./worker.js";
+import { CHECK_EVERY } from "./watch.js";
 const HELP = `Usage: windscout [options]
        windscout connect [-t SEC]
 
 Find which Windscribe locations and protocols work from your network, ranked by ${SPEED_TEST ? "speed" : "latency"}.
 Without -c it opens an interactive country picker (your selection is remembered).
+In a terminal, the results then stay on screen until you quit: connect to one (the screen shows
+where you're connected, live), test them all again for speed or latency (what doesn't connect
+goes to the end of the list), and watch the connection: when it drops, windscout connects you to
+the next best. While watching, docker containers can check the list every ${duration(CHECK_EVERY)} without touching
+your VPN (b there; latency only). n there starts a new scan; q quits and leaves the VPN as it is.
 Each scan's working connections are saved: the scanning type (-o, or o in the picker) can try
-them first or only them, and windscout connect connects to the best of them that still works.
+them first or only them, and windscout connect connects to the best of them that still works
+(in a terminal, on the results screen).
 
 Options:
   -c, --countries LIST  comma-separated ISO codes, city names or nicknames (skips the picker)
@@ -38,7 +49,9 @@ ${SPEED_TEST ? "  -n, --no-speed        connect-only: skip the download test, ra
                         result's working connections among them first, then the rest) or last-only (only those,
                         whatever -c and -p say; needs no -c)
   -w, --stop-at-first   stop at the first working connection that holds up: a speed test (even with -n) of at least
-                        ${MIN_MBPS} Mbps, then about 10 more seconds connected, with internet through it
+                        ${MIN_MBPS} Mbps, staying connected with internet through it (-H), a speed test again, and a reconnect
+  -H, --hold SEC        with -w: seconds each working connection has to stay connected, at least ${MIN_HOLD}
+                        (default: saved, or ${DEFAULT_HOLD})
   -d, --docker          scan in parallel, in docker containers (one per attempt, up to 16, as docker's CPUs and memory allow)
   -v, --version         show the installed version (and offer to update if a newer one is out)
   -h, --help            show this help
@@ -49,41 +62,18 @@ 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.
- * True once it is; otherwise disconnects (and waits until the app has), so the next connect isn't swallowed */
-async function connectTo(r, timeout) {
-    console.log(cyan(command(r)));
-    const t = now(), { status, location } = await attempt(target(r), r.protocol, { timeout, speedTest: false });
-    if (status === "ok")
-        return console.log(green(`Connected: ${location}`)), true;
-    console.log(yellow(`${status} after ${duration(now() - t)}`));
-    await disconnect();
-    return false;
-}
-/** Asks which numbered connection to make (enter: the best), then runs its command and waits for it to connect */
-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): `);
-        if (a === null || /^q(uit)?$/i.test(a))
-            return;
-        const r = a === "" ? choices[0] : /^\d+$/.test(a) ? choices[Number(a)] : undefined;
-        if (!r) {
-            console.log(yellow(`no #${a} in the tables`));
-            continue;
-        }
-        await connectTo(r, timeout);
-        return;
-    }
-}
 const RESCAN_HINT = "rescan them with windscout -o last-only, or start a new scan";
-/** windscout connect: the last result's connections, best first, until one connects */
+/** windscout connect without a terminal: the last result's connections, best first, until one connects */
 async function connectLast(timeout) {
     const last = loadLast();
     if (!last) {
@@ -93,13 +83,11 @@ async function connectLast(timeout) {
     }
     await waitForLogin();
     await disconnect(); // a connection already up would read as the first one connecting
-    for (const [i, r] of last.results.entries()) {
-        console.log(`\n${i + 1}/${last.results.length} ${r.location || r.query} over ${r.protocol}`);
-        if (await connectTo(r, timeout))
-            return;
+    const i = await connectFrom(last.results, 0, timeout);
+    if (i < 0) {
+        console.log(yellow(`\nnone of the last result's ${last.results.length} connection${last.results.length === 1 ? "" : "s"} works now: ${RESCAN_HINT}`));
+        process.exitCode = 1;
     }
-    console.log(yellow(`\nnone of the last result's ${last.results.length} connection${last.results.length === 1 ? "" : "s"} works now: ${RESCAN_HINT}`));
-    process.exitCode = 1;
 }
 /** u in the picker: update, then run the new version in this one's place, with the same arguments */
 function updateAndRestart() {
@@ -112,63 +100,12 @@ function updateAndRestart() {
     console.log(green("updated · restarting windscout"));
     process.exitCode = spawnSync(process.execPath, [...process.execArgv, ...process.argv.slice(1)], { stdio: "inherit" }).status ?? 1;
 }
-async function main() {
-    const { values: a, positionals } = parseArgs({
-        allowPositionals: true,
-        options: {
-            countries: { type: "string", short: "c" },
-            protocols: { type: "string", short: "p" },
-            "all-ports": { type: "boolean", short: "P", default: false },
-            timeout: { type: "string", short: "t" },
-            all: { type: "boolean", short: "a", default: false },
-            help: { type: "boolean", short: "h", default: false },
-            version: { type: "boolean", short: "v", default: false },
-            "no-speed": { type: "boolean", short: "n", default: false },
-            firewall: { type: "boolean", short: "f", default: false },
-            order: { type: "string", short: "o" },
-            "stop-at-first": { type: "boolean", short: "w", default: false },
-            random: { type: "boolean", short: "r", default: false }, // from before scanning types: -o random
-            docker: { type: "boolean", short: "d", default: false },
-            worker: { type: "boolean", default: false }, // in a parallel scan's container
-        },
-    });
-    if (a.worker) {
-        await worker();
-        process.exit(); // its stdin may still be open: its app didn't log in
-    }
-    forgetLogin();
-    if (a.help)
-        return console.log(HELP);
-    const [subcommand, ...extra] = positionals;
-    if (subcommand !== undefined && (subcommand !== "connect" || extra.length))
-        throw new Error(`unknown command '${positionals.join(" ")}': see --help`);
-    if (subcommand === "connect" && Object.entries(a).some(([k, v]) => k !== "timeout" && v))
-        throw new Error("windscout connect takes only -t: see --help");
-    checkUpdate(); // runs while the app starts and the user picks, before the VPN starts switching
-    if (a.version) {
-        await checkUpdate();
-        console.log(versionLines().join("\n"));
-        if (canUpdate() && process.stdin.isTTY && out.isTTY && /^y(es)?$/i.test((await ask("update now? (y/n) ")) ?? ""))
-            process.exitCode = runUpdate();
-        return;
-    }
-    let timeout = a.timeout ? Number(a.timeout) : undefined;
-    if (timeout !== undefined && !(timeout >= MIN_TIMEOUT))
-        throw new Error(`--timeout must be at least ${MIN_TIMEOUT} seconds`);
-    if (a.order !== undefined && !ORDERS.includes(a.order))
-        throw new Error(`--order must be one of: ${ORDERS.join(", ")}`);
-    if (subcommand === "connect")
-        return connectLast(timeout ?? loadConfig()?.timeout ?? DEFAULT_TIMEOUT);
+/** One scan: the picker (unless -c), then the scan, its report, and its working connections saved. Resolves to them, best
+ * first, and the timeout it used; null when the picker was left, "update" when u was pressed there */
+async function scanOnce(f, tty) {
     const status = await waitForLogin();
-    const tty = Boolean(process.stdin.isTTY && out.isTTY);
-    let countries = a.countries ? list(a.countries) : undefined;
-    let protocols = a.protocols ? list(a.protocols) : undefined;
-    let speedTest = SPEED_TEST && !a["no-speed"];
-    let firewall = a.firewall;
-    let order = (a.order ?? (a.random ? "random" : undefined));
-    let stopAtFirst = a["stop-at-first"];
-    let allPorts = a["all-ports"];
-    let docker = a.docker;
+    let { countries, protocols, speedTest, firewall, order, stopAtFirst, allPorts, docker, timeout, hold } = f;
+    speedTest &&= SPEED_TEST;
     const last = loadLast();
     // only the last results needs no countries: without a terminal, it goes without the picker
     if (!countries && !(order === "last-only" && !tty)) {
@@ -184,20 +121,20 @@ async function main() {
             firewall: firewall || isFirewallOn(status) || (saved?.firewall ?? false),
             order: order ?? saved?.order ?? "default",
             stopAtFirst: stopAtFirst || (saved?.stopAtFirst ?? false),
+            hold: hold ?? saved?.hold ?? DEFAULT_HOLD,
             allPorts: allPorts || (saved?.allPorts ?? false),
             docker: docker || (saved?.docker ?? false),
             last,
         });
-        if (!choice)
-            return;
-        if (choice === "update")
-            return updateAndRestart();
+        if (!choice || choice === "update")
+            return choice;
         countries = choice.countries;
         protocols ??= choice.protocols;
         speedTest = choice.speed;
         firewall = choice.firewall;
         order = choice.order;
         stopAtFirst = choice.stopAtFirst;
+        hold = choice.hold;
         allPorts = choice.allPorts;
         timeout = choice.timeout;
         docker = choice.docker;
@@ -205,6 +142,7 @@ async function main() {
     countries ??= [];
     protocols ??= PROTOCOLS;
     timeout ??= DEFAULT_TIMEOUT;
+    hold ??= DEFAULT_HOLD;
     order ??= "default";
     const byLast = order === "last-first" || order === "last-only"; // a type by the last result: it needs a saved scan
     if (byLast && !last)
@@ -212,49 +150,170 @@ async function main() {
     const fromLast = byLast ? last : null; // the saved connections this scan uses
     // the picker asked for the ports already: waiting for that keeps windscribe-cli free for the scan.
     // The saved connections need them too, to tell a saved "tcp:443" from tcp on its default port
-    const lists = allPorts || !a.countries || fromLast ? await protocolPorts() : undefined;
+    const lists = allPorts || !f.countries || fromLast ? await protocolPorts() : undefined;
     if (allPorts && lists)
         protocols = withPorts(protocols, lists);
     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();
+            return leaveScreen(), null;
         saveDockerWireGuard(started.wireguard);
         probers = started.probers;
-        after = { prober: probe, protocols: notInContainers(scanned, started.wireguard), name: "this computer" };
-        await windscribe("disconnect"); // a VPN connection here would carry the containers' traffic too
+        skipped = notInContainers(scanned, started.wireguard); // their kernel may not run WireGuard after all, or may now
+        if (!inContainers().length) {
+            await stopWorkers();
+            throw nothingLeft();
+        }
     }
-    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: stopAtFirst ? hold : 0 }, probers);
+    // the scan switches the VPN anyway: one still up (from before, or the results screen) would read as its first attempt
+    // connecting, and with containers, it would carry their traffic too
+    if (scan.total)
+        await disconnect();
     // 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)"));
+        console.log(green(`stopped at the first connection that held up: a speed test, ${duration(hold)} connected, a speed test again and a reconnect`));
     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
+    // a slower one is never stopped at, so it isn't checked
+    else if (stopAtFirst && scan.results.some((r) => r.status === "ok"))
+        console.log(yellow(`none held up at ${MIN_MBPS} Mbps or more: the connections below are slower, and weren't checked for stability`));
+    const results = report(scan.results, scan.protocols, { all: f.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}`));
-    saveLast(choices, undefined, tried);
+    saveLast(results, undefined, tried);
     await checkUpdate();
     if (updateNotice())
         console.error("\n" + versionLines().join("\n"));
-    if (tty && choices.length)
-        await offerConnect(choices, timeout);
+    return { results, timeout };
+}
+async function main() {
+    const { values: a, positionals } = parseArgs({
+        allowPositionals: true,
+        options: {
+            countries: { type: "string", short: "c" },
+            protocols: { type: "string", short: "p" },
+            "all-ports": { type: "boolean", short: "P", default: false },
+            timeout: { type: "string", short: "t" },
+            all: { type: "boolean", short: "a", default: false },
+            help: { type: "boolean", short: "h", default: false },
+            version: { type: "boolean", short: "v", default: false },
+            "no-speed": { type: "boolean", short: "n", default: false },
+            firewall: { type: "boolean", short: "f", default: false },
+            order: { type: "string", short: "o" },
+            "stop-at-first": { type: "boolean", short: "w", default: false },
+            hold: { type: "string", short: "H" },
+            random: { type: "boolean", short: "r", default: false }, // from before scanning types: -o random
+            docker: { type: "boolean", short: "d", default: false },
+            worker: { type: "boolean", default: false }, // in a parallel scan's container
+        },
+    });
+    if (a.worker) {
+        await worker();
+        process.exit(); // its stdin may still be open: its app didn't log in
+    }
+    forgetLogin();
+    if (a.help)
+        return console.log(HELP);
+    const [subcommand, ...extra] = positionals;
+    if (subcommand !== undefined && (subcommand !== "connect" || extra.length))
+        throw new Error(`unknown command '${positionals.join(" ")}': see --help`);
+    if (subcommand === "connect" && Object.entries(a).some(([k, v]) => k !== "timeout" && v))
+        throw new Error("windscout connect takes only -t: see --help");
+    checkUpdate(); // runs while the app starts and the user picks, before the VPN starts switching
+    if (a.version) {
+        await checkUpdate();
+        console.log(versionLines().join("\n"));
+        if (canUpdate() && process.stdin.isTTY && out.isTTY && /^y(es)?$/i.test((await ask("update now? (y/n) ")) ?? ""))
+            process.exitCode = runUpdate();
+        return;
+    }
+    const timeout = a.timeout ? Number(a.timeout) : undefined;
+    if (timeout !== undefined && !(timeout >= MIN_TIMEOUT))
+        throw new Error(`--timeout must be at least ${MIN_TIMEOUT} seconds`);
+    const hold = a.hold ? Number(a.hold) : undefined;
+    if (hold !== undefined && !(hold >= MIN_HOLD))
+        throw new Error(`--hold must be at least ${MIN_HOLD} seconds`);
+    if (a.order !== undefined && !ORDERS.includes(a.order))
+        throw new Error(`--order must be one of: ${ORDERS.join(", ")}`);
+    const tty = Boolean(process.stdin.isTTY && out.isTTY);
+    // a later scan: the picker, with what was saved
+    const again = { speedTest: true, firewall: false, stopAtFirst: false, allPorts: false, docker: false, all: a.all };
+    let flags = {
+        countries: a.countries ? list(a.countries) : undefined,
+        protocols: a.protocols ? list(a.protocols) : undefined,
+        timeout,
+        hold,
+        order: (a.order ?? (a.random ? "random" : undefined)),
+        speedTest: !a["no-speed"],
+        firewall: a.firewall,
+        stopAtFirst: a["stop-at-first"],
+        allPorts: a["all-ports"],
+        docker: a.docker,
+        all: a.all,
+    };
+    if (subcommand === "connect") {
+        const t = timeout ?? loadConfig()?.timeout ?? DEFAULT_TIMEOUT;
+        if (!tty)
+            return connectLast(t);
+        const last = loadLast();
+        if (!last) {
+            console.log(yellow("no saved scan yet: run windscout to scan first"));
+            process.exitCode = 1;
+            return;
+        }
+        await waitForLogin();
+        // the best that still works, on the results screen, which keeps you connected
+        const to = await showResults({ entries: last.results, at: last.at, timeout: t, saved: true, connect: true, checker: () => dockerChecker(t) });
+        if (to === "quit")
+            return;
+        flags = again;
+    }
+    for (;;) {
+        const found = await scanOnce(flags, tty);
+        if (found === null)
+            return;
+        if (found === "update")
+            return updateAndRestart();
+        if (!tty)
+            return;
+        // nothing worked: the saved ones, which may work again; the screen still lets you scan again
+        const last = found.results.length ? null : loadLast();
+        const to = await showResults({
+            entries: last?.results ?? found.results,
+            at: last?.at ?? Date.now(),
+            timeout: found.timeout,
+            saved: !!last,
+            note: last ? "nothing connected in this scan: these are your saved connections, from earlier" : undefined,
+            checker: () => dockerChecker(found.timeout),
+        });
+        if (to === "quit")
+            return;
+        flags = again;
+    }
 }
 main().catch(async (e) => {
     leaveScreen();

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";
@@ -8,9 +9,12 @@ import { COUNTRIES, PROTOCOLS } from "./windscribe.js";
 export const SPEED_TEST = true;
 export const DEFAULT_TIMEOUT = 15;
 export const MIN_TIMEOUT = 10; // seconds; shorter cuts off connections that would have worked
+export const DEFAULT_HOLD = 30;
+export const MIN_HOLD = 10; // seconds; shorter says little about how long a connection lasts
 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 {
@@ -22,6 +26,7 @@ export function loadConfig() {
             firewall: c.firewall === true,
             order: ORDERS.includes(c.order) ? c.order : c.random === true ? "random" : "default", // before scanning types: random on or off
             stopAtFirst: c.stopAtFirst === true,
+            hold: c.hold >= MIN_HOLD ? c.hold : DEFAULT_HOLD,
             allPorts: c.allPorts === true,
             timeout: c.timeout >= MIN_TIMEOUT ? c.timeout : DEFAULT_TIMEOUT,
             docker: c.docker === true,
@@ -31,13 +36,30 @@ export function loadConfig() {
         return null;
     }
 }
+/** Saves these settings over the saved ones: the rest of the file stays (the results screen's, the picker's) */
 export function saveConfig(c) {
+    let saved = {};
+    try {
+        saved = JSON.parse(readFileSync(CONFIG, "utf8"));
+    }
+    catch { } // first run, or unreadable: start over
     try {
         mkdirSync(dirname(CONFIG), { recursive: true });
-        writeFileSync(CONFIG, JSON.stringify(c, null, 2) + "\n");
+        writeFileSync(CONFIG, JSON.stringify({ ...saved, ...c }, null, 2) + "\n");
     }
     catch { } // not being able to remember isn't worth failing the scan
 }
+/** The results screen's saved settings: watching on until turned off; background checks as docker is for parallel scans until
+ * turned on or off on that screen */
+export function loadSettings() {
+    try {
+        const c = JSON.parse(readFileSync(CONFIG, "utf8"));
+        return { watch: c.watch !== false, background: typeof c.background === "boolean" ? c.background : c.docker === true };
+    }
+    catch {
+        return { watch: true, background: false };
+    }
+}
 /** Whether WireGuard worked in the docker containers last time (yes until a scan finds otherwise), for the picker's estimate */
 export function loadDockerWireGuard() {
     try {
@@ -54,6 +76,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 {
@@ -66,12 +104,13 @@ export function loadLast() {
     }
 }
 /** Saves a scan's working connections; a scan where nothing worked keeps the last one that found something (the network may
- * just be down). With tried (the "query protocol" pairs the scan tried), the saved connections it didn't try stay, after its own */
+ * just be down). With tried (the "query protocol" pairs the scan tried), the saved connections it didn't try stay, after its own
+ * working ones and before the ones whose last check failed */
 export function saveLast(results, at = Date.now(), tried) {
     if (!results.length)
         return;
-    if (tried)
-        results = [...results, ...(loadLast()?.results ?? []).filter((r) => !tried.has(`${r.query} ${r.protocol}`))];
+    const all = [...results, ...(tried ? (loadLast()?.results ?? []).filter((r) => !tried.has(`${r.query} ${r.protocol}`)) : [])];
+    results = [...all.filter((r) => !r.failed), ...all.filter((r) => r.failed)];
     try {
         mkdirSync(dirname(LAST_FILE), { recursive: true });
         writeFileSync(LAST_FILE, JSON.stringify({ at, results }, null, 2) + "\n");