windscout 0.5.1 → 0.5.3

package/README.md

@@ -59,7 +59,7 @@ Run `windscout` with no arguments to open the interactive picker:
 
 Your selection is saved to `~/.config/windscout/config.json` (`%USERPROFILE%\.config\windscout\config.json` on Windows) and preselected next time.
 
-While scanning, WindScout shows a progress bar, elapsed time and remaining time. It also shows what it's doing right now (connecting, measuring latency or measuring speed). The table of working locations refreshes after each country. When the scan finishes, the final report is printed to your normal terminal.
+While scanning, WindScout shows a progress bar, elapsed time and remaining time. It also shows what it's doing right now (connecting, measuring latency or measuring speed). The table of working locations refreshes after each country. When the scan finishes, the final report is printed to your normal terminal. It ends with the best connection and the other working ones, each with its `windscribe-cli connect` command; type a number at the prompt to connect to it.
 
 ### Non-interactive
 
@@ -79,7 +79,7 @@ windscout -t 40 -a                          # longer connect timeout, also list
 | `-a, --all` | include failed attempts in the final table | off |
 | `-n, --no-speed` | connect-only mode: skip the download test, rank by latency | picker: saved, or connect-only on first run; with `-c`: speed test on |
 | `-f, --firewall` | block internet while scanning, except through the VPN | picker: saved, or off; with `-c`: off |
-| `-v, --version` | print the installed version, and the update command if a newer one is on npm | |
+| `-v, --version` | print the installed version; if a newer one is on npm, show the update command and ask (y/n) to run it | |
 
 ## Connect-only mode
 

package/dist/cli.js

@@ -2,16 +2,19 @@
 // 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.
+import { createInterface } from "node:readline";
+import { spawnSync } from "node:child_process";
 import { parseArgs } from "node:util";
 import { CONFIG, DEFAULT_TIMEOUT, loadConfig, MIN_TIMEOUT } from "./config.js";
 import { Scan } from "./scan.js";
 import { pick } from "./tui/picker.js";
 import { logProgress, showProgress } from "./tui/progress.js";
-import { report } from "./tui/report.js";
+import { command, report, target } from "./tui/report.js";
 import { leaveScreen, out } from "./tui/terminal.js";
-import { yellow } from "./tui/text.js";
-import { checkUpdate, updateNotice, VERSION } from "./update.js";
-import { blockInternet, CLI, isFirewallOn, PROTOCOLS, restoreFirewall, waitForLogin } from "./windscribe.js";
+import { cyan, green, yellow } from "./tui/text.js";
+import { now, sleep } from "./time.js";
+import { checkUpdate, UPDATE_COMMAND, updateNotice, VERSION, viaNpx } from "./update.js";
+import { blockInternet, CLI, connectState, isFirewallOn, PROTOCOLS, restoreFirewall, waitForLogin, windscribe } from "./windscribe.js";
 const HELP = `Usage: windscout [options]
 
 Find which Windscribe locations and protocols work from your network, ranked by speed.
@@ -24,13 +27,40 @@ Options:
   -a, --all             also show failed attempts in the final table
   -n, --no-speed        connect-only: skip the download test, rank by latency (faster scan)
   -f, --firewall        block internet while scanning, except through the VPN (turned back off afterwards)
-  -v, --version         show the installed version (and whether a newer one is out)
+  -v, --version         show the installed version (and offer to update if a newer one is out)
   -h, --help            show this help
 
 Selection is stored in ${CONFIG}
 Example: windscout -c DE,NL,TR -p stealth,tcp:443`;
 // "DE, NL,,TR" → ["DE", "NL", "TR"]
 const list = (s) => s.split(",").map((x) => x.trim()).filter(Boolean);
+const ask = (question) => new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: out });
+    rl.on("SIGINT", () => rl.close()); // Ctrl-C / Ctrl-D: same as enter
+    rl.on("close", () => resolve(""));
+    rl.question(question, (a) => (resolve(a.trim()), rl.close()));
+});
+/** Asks which numbered connection to make, then runs its command and waits for it to connect */
+async function offerConnect(choices, timeout) {
+    const others = choices.length > 1 ? `, 1-${choices.length - 1} = other` : "";
+    for (;;) {
+        const a = await ask(`\nconnect to # (0 = best${others}, enter to quit): `);
+        if (!a)
+            return;
+        const r = /^\d+$/.test(a) ? choices[Number(a)] : undefined;
+        if (!r) {
+            console.log(yellow(`no #${a} in the tables`));
+            continue;
+        }
+        console.log(cyan(command(r)));
+        await windscribe("connect", target(r), r.protocol);
+        let state = "";
+        for (const t = now(); now() - t < timeout && !(state = await connectState()).startsWith("Connected");)
+            await sleep(1000);
+        console.log(state.startsWith("Connected") ? green(state) : yellow(`${state || "not connected"} after ${timeout} s`));
+        return;
+    }
+}
 async function main() {
     const { values: a } = parseArgs({
         options: {
@@ -51,8 +81,16 @@ async function main() {
         console.log(`windscout ${VERSION}`);
         await checkUpdate();
         const notice = updateNotice();
-        if (notice)
-            console.error(yellow(notice));
+        if (!notice)
+            return;
+        console.error(yellow(notice));
+        if (process.stdin.isTTY && out.isTTY && !viaNpx() && /^y(es)?$/i.test(await ask("update now? (y/n) "))) {
+            console.log(cyan(UPDATE_COMMAND));
+            // shell: npm is npm.cmd on Windows
+            const { status } = spawnSync(UPDATE_COMMAND, { shell: true, stdio: "inherit" });
+            if (status)
+                process.exitCode = status;
+        }
         return;
     }
     let timeout = a.timeout ? Number(a.timeout) : undefined;
@@ -94,11 +132,13 @@ async function main() {
     view.close();
     if (scan.stopping)
         console.log(yellow("interrupted, showing partial results"));
-    report(scan.results, protocols, { all: a.all, speedTest });
+    const choices = report(scan.results, protocols, { all: a.all, speedTest });
     await checkUpdate();
     const notice = updateNotice();
     if (notice)
         console.error("\n" + yellow(notice));
+    if (tty && choices.length)
+        await offerConnect(choices, timeout);
 }
 main().catch(async (e) => {
     leaveScreen();

package/dist/tui/report.js

@@ -5,26 +5,35 @@ import { flag } from "./country.js";
 import { matrix, resultTable } from "./tables.js";
 import { bold, cyan, dim, fmt, green, 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 }) {
     const ok = sortOk(results);
     const rows = [...ok, ...(all ? results.filter((r) => r.status !== "ok") : [])];
+    const others = ok.slice(1).sort((x, y) => (x.latencyMs ?? Infinity) - (y.latencyMs ?? Infinity));
     // render once to learn the widest table, then again so every box lines up
     const build = (minWidth) => ({
         avail: matrix(results, protocols, { minWidth }),
         main: rows.length
             ? resultTable(rows, speedTest, { caption: bold("Results"), captionRight: dim(`${ok.length} working`), minWidth })
             : [],
+        others: others.length
+            ? grid([{ title: "#", align: "right" }, { title: "Location" }, { title: "Protocol" }, { title: "Latency", align: "right" }, { title: "Connect with" }], others.map((r, i) => [dim(String(i + 1)), `${flag(r.query)} ${r.location}`, r.protocol,
+                r.latencyMs === null ? "-" : `${fmt(r.latencyMs, 0)} ms`, cyan(command(r))]), { caption: bold("Other working locations"), captionRight: dim("by latency"), minWidth })
+            : [],
     });
     const first = build(0);
-    const width = Math.max(64, ...[first.avail[0], first.main[0]].filter(Boolean).map(vw));
-    const { avail, main } = build(width);
+    const width = Math.max(64, ...[first.avail[0], first.main[0], first.others[0]].filter(Boolean).map(vw));
+    const { avail, main, others: rest } = build(width);
     console.log();
     if (avail.length)
         console.log(avail.join("\n"));
     if (!ok.length) {
         console.log(box([yellow("Nothing connected."),
             dim("Try other countries, ports (e.g. -p stealth:443,tcp:443) or a longer --timeout.")], { title: bold(cyan("WindScout")), width: width - 4 }).join("\n"));
-        return;
+        return [];
     }
     console.log(main.join("\n"));
     const stats = protocols.map((p) => {
@@ -35,10 +44,12 @@ export function report(results, protocols, { all, speedTest }) {
     const bestValue = (r) => (speedTest ? `${fmt(r.speedMbps, 1)} Mbps` : `${fmt(r.latencyMs, 0)} ms`);
     console.log(grid([{ title: "Protocol" }, { title: "Worked", align: "right" }, { title: speedTest ? "Best speed" : "Best latency", align: "right" }, { title: "Best location" }], stats.map((s) => [s.p, `${s.good}/${s.tried}`, s.best ? bestValue(s.best) : "-", s.best ? `${flag(s.best.query)} ${s.best.location}` : "-"]), { caption: bold("Per protocol"), minWidth: width }).join("\n"));
     const b = ok[0];
-    const target = b.location.split(" - ").at(-1) || b.query; // nickname pins the exact datacenter
     const facts = [speedTest && `${fmt(b.speedMbps, 1)} Mbps`, `${fmt(b.latencyMs, 0)} ms`].filter(Boolean).join(" · ");
     console.log(box([
         `${flag(b.query)} ${bold(b.location)} over ${bold(b.protocol)} ${dim("· " + facts)}`,
-        cyan(`${CLI} connect "${target}" ${b.protocol}`),
+        cyan(command(b)),
     ], { title: green(speedTest ? "★ Best" : "★ Best (lowest latency)"), width: width - 4 }).join("\n"));
+    if (rest.length)
+        console.log(rest.join("\n"));
+    return [b, ...others];
 }

package/dist/update.js

@@ -20,9 +20,12 @@ export function checkUpdate() {
         .catch(() => { });
     return check;
 }
+// run through npx: there's nothing installed to update, the next npx windscout@latest fetches it
+export const viaNpx = () => process.env.npm_command === "exec";
+export const UPDATE_COMMAND = "npm install -g windscout@latest";
 /** "update available: …" with the command to run, once checkUpdate() found a newer version */
 export function updateNotice() {
     if (!latest)
         return null;
-    return `update available: ${VERSION} → ${latest} · run: ${process.env.npm_command === "exec" ? "npx windscout@latest" : "npm install -g windscout@latest"}`;
+    return `update available: ${VERSION} → ${latest} · run: ${viaNpx() ? "npx windscout@latest" : UPDATE_COMMAND}`;
 }

package/package.json

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