windscout 0.6.5 → 0.7.1

package/dist/probe.js

@@ -1,62 +1,100 @@
 // One attempt: connect to a location over a protocol, measure through the tunnel, disconnect.
-import { latencyMs, speedMbps } from "./measure.js";
+// windscout connect makes the same attempt and, when it works, stays connected.
+import { latencyMs, SPEED_SECONDS, speedMbps } from "./measure.js";
 import { now, sleep } from "./time.js";
 import { connectState, windscribe } from "./windscribe.js";
+// Stop at the first ends the scan at one connection, so that one has to last: a tunnel can connect and then be cut or throttled
+// once traffic flows. It counts once it downloads at MIN_MBPS or more, then stays up with internet for STEADY_CHECKS round trips
+export const MIN_MBPS = 1;
+const STEADY_CHECKS = 5, STEADY_GAP = 2; // seconds between the round trips
+// shortcut: guesses ~5 s to connect and the whole speed test; refine from real runs
+export const STEADY_SECONDS = 5 + SPEED_SECONDS + STEADY_CHECKS * (STEADY_GAP + 0.5);
+/** Whether stop at the first can stop at this result: it worked, held up, and is fast enough for real use */
+export const reliable = (r) => r.status === "ok" && (r.speedMbps ?? 0) >= MIN_MBPS;
 // "Connected: Miami - Vice" → "Miami - Vice"
 const place = (state) => state.split(":").slice(1).join(":").trim();
-export async function probe(query, protocol, { timeout, speedTest, stopped = () => false, onStep = () => { }, measure = (fn) => fn() }) {
+export async function probe(query, protocol, options) {
+    try {
+        return await attempt(query, protocol, options);
+    }
+    finally {
+        options.onStep?.("disconnecting");
+        await disconnect();
+    }
+}
+/** Disconnects, and waits until the app has */
+export async function disconnect() {
+    await windscribe("disconnect");
+    // the CLI's disconnect can return while the app is still tearing down (it does after a timed-out connect);
+    // a connect sent then is swallowed and the next attempt reads as an instant "failed", so wait it out
+    for (let i = 0; i < 30 && (await connectState()) === "Disconnecting"; i++)
+        await sleep(1000);
+}
+/** Connects and measures through the tunnel, as probe does, but leaves the connection as it is: up when it worked */
+export async function attempt(query, protocol, { timeout, speedTest, steady = false, stopped = () => false, onStep = () => { }, measure = (fn) => fn() }) {
     const r = { query, protocol, location: "", connectS: null, latencyMs: null, speedMbps: null };
     const end = (status) => ({ ...r, status });
     onStep("connecting");
     await windscribe("connect", "-n", query, protocol);
     const t = now();
-    try {
-        for (;;) {
-            if (stopped())
-                return end("interrupted");
-            if (now() - t >= timeout)
-                return end("timeout");
-            const s = await connectState();
-            if (s.startsWith("Connecting:"))
+    for (;;) {
+        if (stopped())
+            return end("interrupted");
+        if (now() - t >= timeout)
+            return end("timeout");
+        const s = await connectState();
+        if (s.startsWith("Connecting:"))
+            r.location = place(s);
+        else if (s.startsWith("Connected")) {
+            if (s.includes(":"))
                 r.location = place(s);
-            else if (s.startsWith("Connected")) {
-                if (s.includes(":"))
-                    r.location = place(s);
-                r.connectS = now() - t;
-                break;
-            }
-            else if (s.includes("does not exist"))
-                return end("no such location");
-            // Windscribe refused this app another WireGuard key for the account: says nothing about this network
-            else if (s.includes("WireGuard key limit") && now() - t > 3)
-                return end("key limit");
-            else if (s === "Disconnected" && now() - t > 3)
-                return end("failed");
-            onStep(`connecting ${r.location}`.trim());
-            await sleep(1000);
+            r.connectS = now() - t;
+            break;
         }
-        // a port the app doesn't offer for the protocol: it connects on the protocol's default instead, so this port wasn't tried
-        const port = protocol.split(":")[1], shown = (await windscribe("status")).match(/^Protocol: .*:(\d+)\s*$/m)?.[1];
-        if (port && shown && shown !== port)
-            return end("no such port");
-        await measure(async () => {
-            onStep(`measuring latency · ${r.location}`);
-            r.latencyMs = await latencyMs();
-            if (r.latencyMs !== null && speedTest) {
-                onStep(`measuring speed · ${r.location}`);
-                r.speedMbps = await speedMbps();
-            }
-        });
-        return end(r.latencyMs === null ? "no internet" : "ok");
+        else if (s.includes("does not exist"))
+            return end("no such location");
+        // Windscribe refused this app another WireGuard key for the account: says nothing about this network
+        else if (s.includes("WireGuard key limit") && now() - t > 3)
+            return end("key limit");
+        else if (s === "Disconnected" && now() - t > 3)
+            return end("failed");
+        onStep(`connecting ${r.location}`.trim());
+        await sleep(1000);
     }
-    finally {
-        onStep("disconnecting");
-        await windscribe("disconnect");
-        // the CLI's disconnect can return while the app is still tearing down (it does after a timed-out connect);
-        // a connect sent then is swallowed and the next attempt reads as an instant "failed", so wait it out
-        for (let i = 0; i < 30 && (await connectState()) === "Disconnecting"; i++)
-            await sleep(1000);
+    // a port the app doesn't offer for the protocol: it connects on the protocol's default instead, so this port wasn't tried
+    const port = protocol.split(":")[1], shown = (await windscribe("status")).match(/^Protocol: .*:(\d+)\s*$/m)?.[1];
+    if (port && shown && shown !== port)
+        return end("no such port");
+    let measured = false, holds = true;
+    await measure(async () => {
+        // a stopping scan waits for no more measurements: a parallel scan's containers measure one at a time, so they'd queue up
+        if (stopped())
+            return;
+        measured = true;
+        onStep(`measuring latency · ${r.location}`);
+        r.latencyMs = await latencyMs();
+        if (r.latencyMs === null)
+            return;
+        if (speedTest || steady) {
+            onStep(`measuring speed · ${r.location}`);
+            r.speedMbps = await speedMbps();
+        }
+        if (steady)
+            holds = await holdsUp(r.location, onStep);
+    });
+    if (!measured)
+        return end("interrupted");
+    return end(r.latencyMs === null ? "no internet" : holds ? "ok" : "unreliable");
+}
+/** Whether the connection stays up with internet through it: STEADY_CHECKS round trips, STEADY_GAP seconds apart, each with a retry */
+async function holdsUp(location, onStep) {
+    for (let i = 1; i <= STEADY_CHECKS; i++) {
+        onStep(`checking it holds up ${i}/${STEADY_CHECKS} · ${location}`);
+        await sleep(STEADY_GAP * 1000);
+        if (!(await connectState()).startsWith("Connected") || (await latencyMs(2)) === null)
+            return false;
     }
+    return true;
 }
 /** The attempts that worked, best first: fastest, then lowest latency */
 export const sortOk = (results) => results.filter((r) => r.status === "ok")

package/dist/scan.js

@@ -1,17 +1,34 @@
-// A scan: every country × protocol pair, tried in order, with pause and stop.
+// A scan: the attempts its scanning type plans (plan()), tried in order, with pause and stop.
 // Each slot runs one attempt at a time: one slot here, or one per docker container in a parallel scan.
-import { probe } from "./probe.js";
+import { probe, reliable } from "./probe.js";
 import { now } from "./time.js";
 // ponytail: rough per-attempt cost: a failure burns the timeout, a success ~connect+speed test; refine from real runs
 export const attemptSeconds = (timeout) => timeout + 5;
 export const estimate = (attempts, timeout, slots = 1) => Math.ceil(attempts / slots) * attemptSeconds(timeout);
+export const ORDERS = ["default", "random", "last-first", "last-only"];
+const base = (protocol) => protocol.split(":")[0]; // "tcp:443" → "tcp"
+/** What a scan of these countries and protocols tries, in the order of the scanning type, each once. saved: the last result's
+ * connections, best first. ports: each protocol's ports, its default first, so "tcp" and "tcp:443" are one attempt */
+export function plan(order, countries, protocols, saved = [], ports = new Map()) {
+    const seen = new Set();
+    const once = ({ country, protocol }) => {
+        const [p, port] = protocol.split(":"), key = `${country} ${p}:${port ?? ports.get(p)?.[0] ?? ""}`;
+        return !seen.has(key) && !!seen.add(key);
+    };
+    const last = saved.map((r) => ({ country: r.query, protocol: r.protocol, saved: true }));
+    if (order === "last-only")
+        return last.filter(once);
+    const bases = new Set(protocols.map(base));
+    const first = order === "last-first" ? last.filter((a) => countries.includes(a.country) && bases.has(base(a.protocol))) : [];
+    const list = order === "random" ? countries.map((c) => [Math.random(), c]).sort(([x], [y]) => x - y).map(([, c]) => c) : countries;
+    return [...first, ...list.flatMap((country) => protocols.map((protocol) => ({ country, protocol })))].filter(once);
+}
 /** Progress views read the fields; their keys call togglePause() and stop() */
 export class Scan {
     countries;
     protocols;
     options;
     probers;
-    after;
     results = [];
     finished = []; // countries with every attempt done: the views refresh their tables per country
     errors = []; // why slots stopped early
@@ -20,6 +37,7 @@ export class Scan {
     started = now();
     done = 0;
     stopping = false; // stop after the current attempts
+    found = false; // stopAtFirst: a connection held up, so the scan is stopping
     // a pause lands between attempts, so the VPN is disconnected while waiting
     paused = false;
     waiting = false; // paused, and no attempt running
@@ -27,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 = countries.length * protocols.length;
+        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() {
@@ -59,19 +74,22 @@ export class Scan {
         this.waiting = false;
         this.resume();
     }
+    attempts() {
+        return this.options.only?.map((a) => ({ ...a }))
+            ?? this.countries.flatMap((country) => this.protocols.map((protocol) => ({ country, protocol })));
+    }
     async run(hooks = {}) {
-        const queue = this.countries.flatMap((country) => this.protocols.map((protocol) => ({ country, protocol })));
-        const left = new Map(this.countries.map((c) => [c, this.protocols.length])); // attempts to go, per country
-        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);
+        const queue = this.attempts();
+        const left = new Map(); // attempts to go, per country
+        for (const { country } of queue)
+            left.set(country, (left.get(country) ?? 0) + 1);
+        // 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) {
-        const { timeout, speedTest } = this.options;
+    /** 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) {
                 if (!this.waiting && this.slots.every((s) => !s.current)) { // the last running attempt is over
@@ -80,16 +98,15 @@ 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);
             let r;
             try {
-                r = await prober(country, protocol, { timeout, speedTest, stopped: () => this.stopping, onStep: (s) => (slot.step = s) });
+                r = await prober(country, protocol, { timeout, speedTest, steady: stopAtFirst, stopped: () => this.stopping, onStep: (s) => (slot.step = s) });
             }
             catch (e) { // this slot is done for (its container stopped): the others take over its attempt
                 queue.unshift(next);
@@ -109,6 +126,10 @@ export class Scan {
             if (!left.get(country))
                 this.finished.push(country);
             hooks.result?.(r);
+            if (stopAtFirst && reliable(r) && !this.stopping) {
+                this.found = true;
+                this.stop();
+            }
         }
     }
 }

package/dist/tui/docker.js

@@ -3,7 +3,7 @@ import { duration, now } from "../time.js";
 import { session } from "../windscribe.js";
 import { draw, enterScreen, input, leaveScreen, out } from "./terminal.js";
 import { bold, cyan, dim, vw, yellow } from "./text.js";
-import { box, centerIn } from "./widgets.js";
+import { box, centerIn, spin } from "./widgets.js";
 const tty = () => Boolean(process.stdin.isTTY && out.isTTY);
 const clip = (s, n = 76) => (s.length > n ? s.slice(0, n - 1) + "…" : s);
 // lines of at most n columns, broken at spaces: an error can be longer than the screen is wide
@@ -75,7 +75,7 @@ async function busy(status, work) {
     }
     const t = now();
     let frame = 0;
-    const tick = () => paint({ lines: [`${cyan("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"[frame++ % 10])} ${status.label} ${dim("· " + duration(now() - t))}`,
+    const tick = () => paint({ lines: [`${cyan(spin(frame++))} ${status.label} ${dim("· " + duration(now() - t))}`,
             dim(clip(status.line)), "", dim("esc quits")] });
     // the exit handlers remove containers already started
     const quit = (_, key = {}) => (key.name === "escape" || key.name === "q" || (key.ctrl && key.name === "c"))