windscout 0.4.0 → 0.4.2

package/README.md

@@ -4,6 +4,8 @@ Find which Windscribe locations and protocols actually work from your network, r
 
 WindScout drives the official `windscribe-cli`: it connects to each country × protocol pair, measures latency and download speed through the tunnel, disconnects, and prints a ranked table.
 
+![WindScout picking countries, scanning, and printing the availability grid and ranked results](demo.gif)
+
 > Unofficial tool, not affiliated with Windscribe.
 
 ## Requirements
@@ -27,6 +29,7 @@ Run `windscout` with no arguments to open the interactive picker:
 ```
 ╭─ WindScout ──────────────────────────────────── 2/68 selected ─╮
 │ 1 ● wireguard   2 ● stealth   3 ○ wstunnel   4 ● udp   5 ● tcp │
+│ s ○ speed test  off: connect-only, ranks by latency            │
 ╰────────────────────────────────────────────────────────────────╯
 ╭────────────────────────────────────────────────────────────────╮
 │ 🔍 an▏                                              1–16 of 18 │
@@ -51,7 +54,7 @@ Run `windscout` with no arguments to open the interactive picker:
 | `enter` | start scanning |
 | `q` | quit (during a scan: stop and show partial results; press again to force quit) |
 
-**Mouse:** click a country to select or unselect it, click a protocol or the speed-test line to toggle it, click the search box to start typing (click anywhere else to leave it), and scroll the list with the wheel. The `[ ▶ Start ]  [ All ]  [ None ]  [ Quit ]` buttons under the table do the same as their keys. This needs a terminal with mouse support, which most have. On Windows, use Windows Terminal; if clicks do nothing there, the keyboard does everything.
+**Mouse:** click a country to select or unselect it, click a protocol or the speed-test line to toggle it, click the search box to start typing (click anywhere else to leave it), and scroll the list with the wheel. The `[ ▶ Start ]  [ All ]  [ None ]  [ Quit ]` buttons under the table do the same as their keys; the shortcut key is underlined on screen (on the buttons, the protocol numbers and `s`). This needs a terminal with mouse support, which most have. On Windows, use Windows Terminal; if clicks do nothing there, the keyboard does everything.
 
 Your selection is saved to `~/.config/windscout/config.json` (`%USERPROFILE%\.config\windscout\config.json` on Windows) and preselected next time.
 
@@ -73,25 +76,26 @@ windscout -t 40 -a                          # longer connect timeout, also list
 | `-p, --protocols` | comma-separated: `wireguard`, `ikev2` (macOS and Windows), `stealth`, `wstunnel`, `udp`, `tcp`, optionally `:port` | saved, or all |
 | `-t, --timeout` | seconds to wait for each connection | 20 |
 | `-a, --all` | include failed attempts in the final table | off |
-| `-n, --no-speed` | connect-only mode: skip the download test, rank by latency | saved, or 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 |
 | `-v, --version` | print the installed version, and the update command if a newer one is on npm | |
 
 ## Connect-only mode
 
-Often you only need to know **what connects**, not how fast it is. Turn the speed test off with `s` in the picker or with `--no-speed`. Each working connection is then checked with a quick latency test only. That saves about 15 s per working connection, and results are ranked by latency. The choice is remembered.
+Often you only need to know **what connects**, not how fast it is. Turn the speed test off with `s` in the picker or with `--no-speed`. Each working connection is then checked with a quick latency test only. That saves about 15 s per working connection, and results are ranked by latency. Connect-only is the default on the first run, and the choice is remembered.
 
-Both modes show an **availability grid**: one row per country, and ✓ / ✗ for each protocol (`·` = not tried yet):
+Both modes show an **availability grid**: one row per country, and ✓ / ✗ for each protocol (`·` = not tried yet). Location(s) lists each datacenter that connected, one per line, since protocols can land on different ones:
 
 ```
-╭────────────────────────────────────────────────────────────────────────╮
-│ Availability                                   2/3 countries reachable │
-├─────────────────────────┬──────────────────┬─────────┬───────────┬─────┤
-│ Country                 │ City             │ stealth │ wireguard │ tcp │
-├─────────────────────────┼──────────────────┼─────────┼───────────┼─────┤
-│ 🇩🇪 Germany              │ Frankfurt        │    ✓    │     ✓     │  ✓  │
-│ 🇳🇱 Netherlands          │ Amsterdam        │    ✓    │     ✓     │  ·  │
-│ 🇦🇪 United Arab Emirates │ Dubai            │    ✗    │     ✗     │  ✗  │
-╰─────────────────────────┴──────────────────┴─────────┴───────────┴─────╯
+╭──────────────────────────────────────────────────────────────────────────────╮
+│ Availability                                         2/3 countries reachable │
+├─────────────────────────┬────────────────────────┬─────────┬───────────┬─────┤
+│ Country                 │ Location(s)            │ stealth │ wireguard │ tcp │
+├─────────────────────────┼────────────────────────┼─────────┼───────────┼─────┤
+│ 🇩🇪 Germany              │ Frankfurt - Castle     │    ✓    │     ✓     │  ✓  │
+│                         │ Frankfurt - Wurst      │         │           │     │
+│ 🇳🇱 Netherlands          │ Amsterdam - Tulip      │    ✓    │     ✓     │  ·  │
+│ 🇦🇪 United Arab Emirates │ Dubai                  │    ✗    │     ✗     │  ✗  │
+╰─────────────────────────┴────────────────────────┴─────────┴───────────┴─────╯
 ```
 
 While scanning, press `tab` to switch between the availability grid and the speed or latency ranking. In connect-only mode the scan starts on the availability grid.
@@ -127,9 +131,10 @@ At the end, the results, a per-protocol summary and the best pick are printed to
 
 ## Notes
 
-- **Connecting by country picks a random datacenter.** A single run tests one per country. Pass city names or nicknames with `-c` to test specific datacenters.
+- **Connecting by country picks a random datacenter.** A single run tests one per country and protocol, so different protocols may land on different datacenters. Pass city names or nicknames with `-c` to test specific datacenters.
 - **The country list is built in.** On v2.24, `windscribe-cli locations` returns nothing, so WindScout uses a fixed list of country codes. Codes Windscribe doesn't serve are skipped quickly.
 - **A full scan takes a while.** The worst case is countries × protocols × timeout. Narrow it with `-c` and `-p`.
+- **No flags in macOS Terminal.** Terminal.app draws flag emoji wider than their space, which pushes table borders out of line, so WindScout leaves them out there (as on Windows). iTerm2 and other terminals show them.
 - **Your connection changes during the scan.** WindScout connects and disconnects the VPN repeatedly, so don't run it while you need a stable connection.
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windscout",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Find which Windscribe locations and protocols work from your network, ranked by speed (unofficial)",
   "type": "module",
   "bin": {
@@ -23,8 +23,19 @@
     "speedtest",
     "wireguard",
     "stealth",
-    "cli"
+    "cli",
+    "censorship",
+    "firewall",
+    "unblock",
+    "vpn-speed-test",
+    "server-finder"
   ],
   "author": "Dier Cohen <i.am.dier.cohen@gmail.com>",
-  "license": "MIT"
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Diercohen/windscout.git"
+  },
+  "homepage": "https://github.com/Diercohen/windscout#readme",
+  "bugs": "https://github.com/Diercohen/windscout/issues"
 }

package/windscout.js

@@ -41,8 +41,10 @@ const countryName = (code) => {
   try { return regionName.of(code); } catch { return code; } // city names / nicknames aren't region codes
 };
 // two regional-indicator letters render as the country's flag emoji (Windows has no flag glyphs: it would show
-// two boxed letters of unpredictable width and break the table borders, so leave the slot blank there)
-const flag = (code) => process.platform !== "win32" && /^[A-Z]{2}$/.test(code) ? String.fromCodePoint(...[...code].map((c) => 0x1f1a5 + c.charCodeAt(0))) : "  ";
+// two boxed letters of unpredictable width and break the table borders, so leave the slot blank there).
+// macOS Terminal draws flags ~half a column wider than the 2 it advances, nudging table borders right: blank there too
+const noFlags = process.platform === "win32" || process.env.TERM_PROGRAM === "Apple_Terminal";
+const flag = (code) => !noFlags && /^[A-Z]{2}$/.test(code) ? String.fromCodePoint(...[...code].map((c) => 0x1f1a5 + c.charCodeAt(0))) : "  ";
 let stop = 0;
 let speedTest = true; // false = connect-only mode: skip the download test, rank by latency
 
@@ -271,28 +273,31 @@ function matrix(results, protocols, { minWidth = 0, limit = Infinity } = {}) {
   const ranked = [...byCountry].map(([q, rs]) => ({ q, rs, good: rs.filter((r) => r.status === "ok").length }))
     .sort((a, b) => b.good - a.good); // stable: ties keep scan order
   const reachable = ranked.filter((c) => c.good).length;
-  const rows = ranked.slice(0, limit).map(({ q, rs }) => {
+  const rows = ranked.slice(0, limit).flatMap(({ q, rs }) => {
     const seen = rs.find((r) => r.status === "ok") ?? rs.find((r) => r.location);
-    // nickname = exact datacenter; protocols can land on different ones, so list each that connected
-    const nicks = [...new Set(rs.filter((r) => r.status === "ok").map((r) => r.location.split(" - ")[1]).filter(Boolean))];
+    // protocols can land on different datacenters (even cities), so list each one that connected, one per line
+    const places = [...new Set(rs.filter((r) => r.status === "ok").map((r) => r.location).filter(Boolean))];
+    const [first = seen?.location?.split(" - ")[0] || dim("-"), ...more] = places;
     return [
-      `${flag(q)} ${countryName(q)}`,
-      seen?.location?.split(" - ")[0] || dim("-"),
-      nicks.join(", ") || dim("-"),
-      ...protocols.map((p) => {
-        const r = rs.find((x) => x.protocol === p);
-        return !r ? dim("·") : r.status === "ok" ? green("✓") : red("✗");
-      }),
+      [
+        `${flag(q)} ${countryName(q)}`,
+        first,
+        ...protocols.map((p) => {
+          const r = rs.find((x) => x.protocol === p);
+          return !r ? dim("·") : r.status === "ok" ? green("✓") : red("✗");
+        }),
+      ],
+      ...more.map((place) => ["", place, ...protocols.map(() => "")]),
     ];
-  });
+  }).slice(0, limit);
   return grid(
-    [{ title: "Country" }, { title: "City" }, { title: "Location" }, ...protocols.map((p) => ({ title: p, align: "center" }))],
+    [{ title: "Country" }, { title: "Location(s)" }, ...protocols.map((p) => ({ title: p, align: "center" }))],
     rows,
     {
       caption: bold("Availability"),
       captionRight: dim(`${reachable}/${ranked.length} countries reachable${ranked.length > limit ? ` · top ${limit}` : ""}`),
       minWidth,
-      stretch: 2,
+      stretch: 1,
     },
   );
 }