windscout 0.7.1 → 0.9.0

package/dist/watch.js

@@ -0,0 +1,454 @@
+// Keeping you connected, for the results screen. It holds the list of working connections, best first. You can connect to one
+// (when it doesn't connect: back to the one you had, else the next ones), disconnect, or test them all again, which ranks them
+// by what it finds. The watch checks the connection every few seconds, and when it's down, connects again: to the same one or
+// the next best. While watching, a checker (background.ts) can try the others now and then without touching this computer's
+// VPN. One whose check fails goes to the end of the list, since it may work again later, unless they all fail: that's your
+// network, not them, so the list stays as it was. No terminal here: tui/results.ts shows it, and the tests drive it with a
+// fake app and clock (KeepIo).
+import { setTimeout as wait } from "node:timers/promises";
+import { latencyMs } from "./measure.js";
+import { attempt, disconnect, probe, target } from "./probe.js";
+import { duration, now } from "./time.js";
+import { appLogSize, connectStateOf, place, publicIpOf, toldToDisconnect, vpnIpOf, windscribe } from "./windscribe.js";
+export const WATCH_GAP = 3; // seconds between the checks
+export const WATCH_MISSES = 3; // checks in a row that find it down (not connected, or no internet through it) before acting
+export const WATCH_KEEP = 300; // seconds: one that lasted this long is tried again first when it drops; one that didn't, last
+export const WATCH_RETRY = 30; // seconds to wait when none connects, before trying them all again from the best
+export const CHECK_EVERY = 300; // seconds between the background checks, while watching
+const TRIPS = 20; // round trips kept for the view
+// what says a connection doesn't work from here; a container's key limit or missing port, or a stopped attempt, says nothing
+const FAILURES = ["timeout", "failed", "no internet", "no such location", "no such port", "key limit", "unreliable"];
+const CHECK_FAILURES = ["timeout", "failed", "no internet", "no such location", "unreliable"];
+/** "Frankfurt - Castle over stealth:443" */
+export const label = (r) => `${r.location || r.query} over ${r.protocol}`;
+const key = (r) => `${r.query} ${r.protocol}`;
+/** The working ones first, best first; then the ones whose last check failed, in the order they went there */
+export function ranked(entries, sort) {
+    const latency = (x, y) => (x.latencyMs ?? 1e9) - (y.latencyMs ?? 1e9);
+    const speed = (x, y) => (y.speedMbps ?? -1) - (x.speedMbps ?? -1);
+    const by = sort === "speed" ? (x, y) => speed(x, y) || latency(x, y) : (x, y) => latency(x, y) || speed(x, y);
+    return [...entries.filter((e) => !e.failed).sort(by), ...entries.filter((e) => e.failed)];
+}
+/** The app's side of KeepIo, connecting the way the scan does; save keeps the list */
+export const appIo = (timeout, save) => ({
+    status: async () => {
+        const s = await windscribe("status"), state = connectStateOf(s);
+        return { state, ip: state.startsWith("Connected") ? vpnIpOf(s) : publicIpOf(s) };
+    },
+    ping: () => latencyMs(1),
+    // nickname: the exact datacenter the list shows, as the connect command in the report does
+    attempt: (e, { stopped, onStep }) => attempt(target(e), e.protocol, { timeout, speedTest: false, stopped, onStep }),
+    probe: (e, speedTest, { stopped, onStep }) => probe(target(e), e.protocol, { timeout, speedTest, stopped, onStep }),
+    disconnect,
+    logSize: appLogSize,
+    told: toldToDisconnect,
+    sleep: (seconds, signal) => wait(seconds * 1000, undefined, { signal }),
+    now,
+    save,
+});
+const marks = () => ({ was: new Map() });
+/** Owns the VPN connection while the results screen is open; the view reads the fields and calls the methods */
+export class Keeper {
+    entries;
+    sort;
+    watch;
+    io;
+    phase = "idle";
+    current = null; // the one it connected you to, while it's yours
+    app = { state: "", ip: "" }; // what the app said at the last check
+    since = 0; // when current came up
+    ms = null; // the last round trip through it
+    trips = []; // the last round trips, oldest first; null: it didn't get through
+    misses = 0; // checks in a row that found it down
+    drops = 0; // times it connected you again
+    lost = null; // the one that dropped, while connecting again
+    trying = null; // the attempt running now
+    // the test running now; had: the connection it puts back afterwards
+    test = null;
+    retryAt = 0; // none connected: when it tries them all again
+    events = []; // what happened, last ones last
+    checker = null; // the background checks, while they run
+    checkAt = 0; // when the next background check is due
+    lastCheck = null; // the last background check's outcome
+    changed = false; // the list learned something since the screen opened
+    closed = false;
+    queued = null; // a command waiting for what's running to stop
+    action = new AbortController(); // the running action: a new command, or close(), ends it
+    nap = new AbortController(); // the running wait: anything new ends it early
+    napBackground = new AbortController();
+    backgroundRun = 0; // the background loop that's on: an older one ends
+    backgroundStop = Promise.resolve(); // the checker stopping
+    cancelled = false; // esc: stops what's running
+    finishing = false; // an attempt that close(true) lets finish
+    finishOnClose = false;
+    dirty = false; // the list changed since it was last saved
+    where = ""; // where the app said it connected to
+    logAt = 0; // the app log's size at the last check that found it up: a disconnect it's told to make lands after it
+    constructor(entries, sort, watch, io) {
+        this.entries = entries;
+        this.sort = sort;
+        this.watch = watch;
+        this.io = io;
+    }
+    ranked() {
+        return ranked(this.entries, this.sort);
+    }
+    connect(entry) {
+        this.command({ kind: "connect", entry });
+    }
+    disconnect() {
+        this.command({ kind: "disconnect" });
+    }
+    /** Tests them all again, one at a time on this computer, and ranks them by what it finds; then puts the VPN back */
+    retest(speed) {
+        this.command({ kind: "test", speed });
+    }
+    /** esc: stops a test (the VPN then goes back as it was), or the connecting */
+    cancel() {
+        this.cancelled = true;
+        this.nap.abort();
+    }
+    setWatch(on) {
+        this.watch = on;
+        if (!on && (this.phase === "reconnecting" || this.phase === "none"))
+            this.cancel(); // no connecting again by itself now
+        this.nap.abort();
+        this.napBackground.abort();
+    }
+    /** Ends run() and the background checks. finish (quitting): the connection you asked for still gets its attempt, and a test
+     * still puts back the connection you had; else (a new scan) everything stops right away */
+    close(finish = false) {
+        this.closed = true;
+        this.finishOnClose = finish;
+        if (!finish)
+            this.action.abort();
+        this.nap.abort();
+        this.napBackground.abort();
+    }
+    /** Until close(): runs the commands, one at a time, and checks the connection every WATCH_GAP s in between */
+    async run() {
+        if (!this.queued)
+            this.app = await this.io.status();
+        while (!this.closed) {
+            const c = this.queued;
+            this.queued = null;
+            this.action = new AbortController();
+            this.cancelled = false;
+            if (c)
+                await this.act(c, this.action.signal);
+            else {
+                await this.pause(WATCH_GAP);
+                if (!this.queued && !this.closed)
+                    await this.check(this.action.signal);
+            }
+            if (this.dirty)
+                this.save();
+        }
+    }
+    /** While watching: every CHECK_EVERY s (the first in firstIn s) the checker tries the others in the list (not the one you're
+     * on: the watch checks that one), and what it finds goes in the list, as a test's does. Until stopBackground() or close() */
+    async background(checker, firstIn = 0) {
+        const run = ++this.backgroundRun;
+        const on = () => !this.closed && this.backgroundRun === run;
+        const stopped = () => !on() || !this.watch;
+        const others = () => this.ranked().filter((e) => e !== this.current);
+        this.checker = checker;
+        this.checkAt = this.io.now() + firstIn;
+        if (checker.prepare)
+            await checker.prepare(others(), stopped);
+        while (on()) {
+            if (this.watch && !this.test && this.io.now() >= this.checkAt) {
+                const list = others();
+                const results = list.length ? await checker.check(list, stopped) : null;
+                if (results && !stopped() && !this.test)
+                    this.found(list, results); // a test that started meanwhile finds out itself
+                this.checkAt = this.io.now() + CHECK_EVERY;
+            }
+            this.napBackground = new AbortController();
+            await this.io.sleep(this.watch ? Math.max(1, this.checkAt - this.io.now()) : 3600, this.napBackground.signal).catch(() => { });
+        }
+    }
+    /** Ends the background checks; resolves once the checker has stopped what it was doing */
+    stopBackground() {
+        const checker = this.checker;
+        this.backgroundRun++;
+        this.checker = null;
+        this.napBackground.abort();
+        if (checker)
+            this.backgroundStop = this.backgroundStop.then(() => checker.stop()).catch(() => { });
+        return this.backgroundStop;
+    }
+    command(c) {
+        this.queued = c;
+        this.action.abort();
+        this.nap.abort();
+    }
+    stopped(signal) {
+        return signal.aborted || this.cancelled || (this.closed && !this.finishing);
+    }
+    /** An attempt that quitting lets finish: so you end up connected, as you asked */
+    async tryToFinish(e, signal, m) {
+        this.finishing = true;
+        try {
+            return await this.tryOne(e, signal, m);
+        }
+        finally {
+            this.finishing = false;
+        }
+    }
+    async act(c, signal) {
+        if (c.kind === "disconnect") {
+            Object.assign(this, { current: null, lost: null, phase: "idle" });
+            await this.io.disconnect();
+            this.app = await this.io.status();
+            this.event("disconnected");
+        }
+        else if (c.kind === "connect")
+            await this.switchTo(c.entry, signal);
+        else
+            await this.retestAll(c.speed, signal);
+    }
+    /** Connects to e. When it doesn't connect: back to the one you had, else the next ones after it, to get you online */
+    async switchTo(e, signal) {
+        const had = this.phase === "connected" ? this.current : null; // a working connection to go back to
+        const list = this.ranked(), at = list.indexOf(e);
+        const after = [...list.slice(at + 1), ...list.slice(0, Math.max(0, at))]; // around to the one before it
+        const m = marks();
+        Object.assign(this, { phase: "connecting", current: null, lost: null });
+        await this.io.disconnect(); // one still up would read as this one connecting
+        if (await this.tryToFinish(e, signal, m))
+            return;
+        if (this.stopped(signal))
+            return this.halt();
+        if (had && had !== e) {
+            if (await this.tryOne(had, signal, m))
+                return this.event(`${label(e)} didn't connect: back on ${label(had)}`);
+            if (this.stopped(signal))
+                return this.halt();
+        }
+        const next = after.filter((x) => x !== had);
+        if (next.length)
+            this.event(`${label(e)} didn't connect: trying the next ones`);
+        await this.tryAll(next, signal, m);
+    }
+    /** Tries each in turn until one connects. When none does, they all failed, which says more about your network than about
+     * them: the list goes back as it was (m). While watching, it then tries them all again from the best every WATCH_RETRY s */
+    async tryAll(order, signal, m) {
+        for (;;) {
+            for (const [k, e] of order.entries()) {
+                if (this.stopped(signal))
+                    return this.halt(), false;
+                if (await this.tryOne(e, signal, m, k + 1, order.length))
+                    return true;
+            }
+            if (this.stopped(signal))
+                return this.halt(), false;
+            this.undo(m);
+            this.phase = "none";
+            if (!this.watch) {
+                this.event(this.entries.length > 1 ? `none of the ${this.entries.length} connects now` : "it doesn't connect now");
+                return false;
+            }
+            this.event(`none of them connects now: trying them all again in ${duration(WATCH_RETRY)}`);
+            if (!(await this.waitRetry(signal)))
+                return this.halt(), false;
+            order = this.ranked();
+        }
+    }
+    /** WATCH_RETRY s, watching the app: false when it's stopped meanwhile, or you connected in the app yourself */
+    async waitRetry(signal) {
+        this.retryAt = this.io.now() + WATCH_RETRY;
+        while (this.io.now() < this.retryAt) {
+            await this.pause(Math.min(WATCH_GAP, this.retryAt - this.io.now()));
+            if (this.stopped(signal))
+                return false;
+            this.app = await this.io.status();
+            if (/^Connect(ed|ing)/.test(this.app.state)) {
+                this.event("you're connecting in the app: windscout leaves it to you");
+                return false;
+            }
+        }
+        return true;
+    }
+    /** One attempt at e: true once it's up; a failure goes to the end of the list (m keeps what it was) */
+    async tryOne(e, signal, m, n = 1, of = 1) {
+        this.trying = { entry: e, step: "connecting", start: this.io.now(), n, of };
+        const r = await this.io.attempt(e, { stopped: () => this.stopped(signal), onStep: (s) => this.trying && (this.trying.step = s) });
+        this.trying = null;
+        if (r.status === "ok") {
+            this.learn(e, r, false);
+            Object.assign(this, { current: e, phase: "connected", lost: null, since: this.io.now(), misses: 0, ms: r.latencyMs,
+                trips: [r.latencyMs], where: r.location, logAt: this.io.logSize() });
+            this.app = await this.io.status(); // the VPN's IP now, not the one from before
+            return true;
+        }
+        await this.io.disconnect(); // so the next connect isn't swallowed
+        if (FAILURES.includes(r.status))
+            this.demote(e, r.status, m);
+        return false;
+    }
+    /** Stopped while connecting: disconnected, unless it got through */
+    halt() {
+        this.trying = null;
+        if (!this.current)
+            this.phase = "idle";
+    }
+    /** A check of the connection: still where it connected, with internet through it. When WATCH_MISSES checks in a row find it
+     * down, and watching, connects again. When the app was told to disconnect (or restarted), or is connected somewhere else,
+     * you're using it yourself: windscout lets it be */
+    async check(signal) {
+        const logAt = this.io.logSize();
+        this.app = await this.io.status();
+        const { state } = this.app, connected = state.startsWith("Connected"), there = place(state);
+        if (!this.current) {
+            if (this.phase === "none" && /^Connect(ed|ing)/.test(state))
+                this.phase = "idle"; // you connected in the app
+            return;
+        }
+        if (connected && there && this.where && there !== this.where) {
+            this.event(`you connected to ${there} in the app: windscout leaves it to you`);
+            return void Object.assign(this, { current: null, phase: "idle" });
+        }
+        this.ms = connected ? await this.io.ping() : null;
+        this.trips = [...this.trips, this.ms].slice(-TRIPS);
+        if (this.ms !== null) {
+            Object.assign(this, { misses: 0, logAt, phase: "connected" });
+            return;
+        }
+        // you disconnected (or a script did, or the app was quit): yours to do, not a drop
+        if (this.io.told(this.logAt)) {
+            this.event("you disconnected in the app: windscout leaves it to you");
+            return void Object.assign(this, { current: null, phase: "idle" });
+        }
+        if (++this.misses < WATCH_MISSES || this.closed)
+            return;
+        if (this.watch)
+            await this.failover(connected ? "no internet through it" : state || "not connected", signal);
+        else
+            this.phase = "down"; // shows it; the app may still bring it back
+    }
+    /** It dropped: connects again, to the same one first if it lasted WATCH_KEEP s, else to the next ones first */
+    async failover(why, signal) {
+        const dropped = this.current, lasted = this.io.now() - this.since, m = marks();
+        this.event(`✗ ${label(dropped)}: ${why} · it lasted ${duration(lasted)}`);
+        Object.assign(this, { lost: { entry: dropped, why, lasted }, phase: "reconnecting", current: null });
+        await this.io.disconnect();
+        // a hiccup in one that lasted: the same again; one that dropped soon is likely blocked, so it goes to the end
+        if (lasted < WATCH_KEEP)
+            this.demote(dropped, `dropped after ${duration(lasted)}`, m);
+        const order = lasted >= WATCH_KEEP ? [dropped, ...this.ranked().filter((e) => e !== dropped)] : this.ranked();
+        if (await this.tryAll(order, signal, m)) {
+            this.drops++;
+            this.event(`✓ connected again: ${label(this.current)}`);
+        }
+    }
+    /** Each in the list, in its order, on this computer: connects, measures, disconnects. Then ranks them by what it found,
+     * the failed ones last, and connects you again: to the one you had if it still works, else the best */
+    async retestAll(speed, signal) {
+        const had = this.phase === "connected" || this.phase === "down" ? this.current : null;
+        const list = this.ranked(), m = marks();
+        let what = speed ? "speed test" : "latency test";
+        Object.assign(this, { phase: "testing", current: null, lost: null });
+        const test = this.test = { speed, entry: null, step: "", start: this.io.now(), done: 0, total: list.length, had };
+        await this.io.disconnect();
+        let worked = 0, failed = 0;
+        for (const e of list) {
+            if (this.stopped(signal))
+                break;
+            Object.assign(test, { entry: e, step: "connecting" });
+            const r = await this.io.probe(e, speed, { stopped: () => this.stopped(signal), onStep: (s) => (test.step = s) });
+            if (r.status === "interrupted")
+                break;
+            if (r.status === "ok")
+                worked++, this.learn(e, r, speed);
+            else if (FAILURES.includes(r.status))
+                failed++, this.demote(e, r.status, m);
+            test.done++;
+        }
+        Object.assign(this, { test: null, phase: "idle" });
+        if (test.done < list.length)
+            what += ` (stopped after ${test.done} of ${list.length})`;
+        if (!worked && failed > 1) {
+            this.undo(m);
+            this.event(`${what}: none of them connected · is your network down? The list stays as it was`);
+        }
+        else if (worked + failed) {
+            this.event(`${what}: ${worked} of ${worked + failed} work${failed ? ` · ${failed === 1 ? "the one that didn't" : `the ${failed} that didn't`} went to the end` : ""}`);
+        }
+        if (signal.aborted || !had)
+            return; // another command takes over, or there's nothing to go back to
+        this.phase = "connecting";
+        if (this.closed) { // quitting: back on the one you had (else the best), one attempt
+            const back = had.failed ? this.ranked().find((e) => !e.failed) : had;
+            if (!this.finishOnClose || !back)
+                return this.halt();
+            this.cancelled = false;
+            return void (await this.tryToFinish(back, signal, marks()), this.halt());
+        }
+        this.cancelled = false; // esc stopped the test: the VPN still goes back
+        await this.tryAll(had.failed ? this.ranked() : [had, ...this.ranked().filter((e) => e !== had)], signal, marks());
+    }
+    /** What the checker found: the ones that worked get its latency, the others go to the end, unless none worked. The one
+     * you're on gets the best of the watch's last round trips, as a scan measures the best of a few */
+    found(list, results) {
+        const by = new Map(results.map((r) => [key(r), r])), m = marks();
+        let worked = 0, failed = 0;
+        for (const e of list) {
+            const r = by.get(`${target(e)} ${e.protocol}`);
+            if (!r || e === this.current)
+                continue;
+            if (r.status === "ok")
+                worked++, this.learn(e, r, false);
+            else if (CHECK_FAILURES.includes(r.status))
+                failed++, this.demote(e, r.status, m);
+        }
+        if (!worked && failed > 1)
+            this.undo(m); // the containers couldn't get anywhere: that's no news about the list
+        const trips = this.trips.filter((t) => t !== null);
+        if (this.current && this.phase === "connected" && trips.length)
+            this.learn(this.current, { ...this.current, latencyMs: Math.min(...trips) }, false);
+        this.lastCheck = { at: Date.now(), worked, of: worked + failed };
+        if (this.dirty)
+            this.save();
+    }
+    /** It worked: what it measured (the speed only from a speed test) */
+    learn(e, r, speed) {
+        Object.assign(e, { location: r.location || e.location, connectS: r.connectS ?? e.connectS, latencyMs: r.latencyMs ?? e.latencyMs, checked: Date.now() });
+        if (speed)
+            e.speedMbps = r.speedMbps;
+        delete e.failed;
+        delete e.failedAt;
+        this.changed = this.dirty = true;
+    }
+    /** It didn't get through: to the end of the list, since it may work again later */
+    demote(e, why, m) {
+        m.order ??= [...this.entries];
+        if (!m.was.has(e))
+            m.was.set(e, { failed: e.failed, failedAt: e.failedAt });
+        Object.assign(e, { failed: why, failedAt: Date.now() });
+        this.entries = [...this.entries.filter((x) => x !== e), e];
+        this.changed = this.dirty = true;
+    }
+    /** Back as they were before a pass where everything failed */
+    undo(m) {
+        for (const [e, was] of m.was) {
+            if (was.failed)
+                Object.assign(e, was);
+            else
+                delete e.failed, delete e.failedAt;
+        }
+        if (m.order)
+            this.entries = m.order;
+    }
+    save() {
+        this.dirty = false;
+        this.io.save(this.ranked());
+    }
+    event(text) {
+        this.events = [...this.events, { at: new Date(), text }].slice(-20);
+    }
+    async pause(seconds) {
+        this.nap = new AbortController();
+        await this.io.sleep(seconds, this.nap.signal).catch(() => { }); // aborted: something new to do
+    }
+}

package/dist/windscribe.js

@@ -1,6 +1,6 @@
 // The Windscribe desktop app, driven through the windscribe-cli it ships with.
 import { execFileSync, spawn } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { sleep } from "./time.js";
@@ -65,20 +65,38 @@ export async function windscribe(...args) {
     // the CLI mixes JSON log lines into stdout
     return out.split("\n").filter((l) => !l.startsWith('{"tm"')).join("\n");
 }
-/** "Connected: Miami - Vice", "Connecting: …", "Disconnected", … */
-export async function connectState() {
-    // macOS marks the line with a leading "*" once connected: "*Connect state: Connected: Miami - Vice"
-    return (await windscribe("status")).match(/^\*?Connect state: (.*)$/m)?.[1].trim() ?? "";
-}
+// "Connected: Miami - Vice" → "Miami - Vice"
+export const place = (state) => state.split(":").slice(1).join(":").trim();
+// windscribe-cli status prints a "Label: value" line per item. The app's 2.25 renamed three of them, and older apps are still
+// out there, so either wording goes: 2.25 and newer say "Login", "Connection", "Firewall", older ones "Login state",
+// "Connect state", "Firewall state" (and mark the connect state with a "*" while they check the connection)
+const LABELS = { login: "Login(?: state)?", connection: "(?:Connection|Connect state)", firewall: "Firewall(?: state)?" };
+/** An item of windscribe-cli status, by its label in either wording; "" when it isn't there */
+export const statusValue = (status, item) => status.match(new RegExp(`^\\*?${LABELS[item]}:[ \\t]*(.*)$`, "m"))?.[1].trim() ?? "";
+/** The connect state in a status, as the apps before 2.25 word it, from either: "Connected: Miami - Vice", "Connecting: …",
+ * "Disconnecting", "Disconnected", "Error: …". 2.25 and newer say "Connected to Miami - Vice", and add "(checking the
+ * connection)" while they check it, or "(network interference detected)"; older ones add "[Network interference]" */
+export const connectStateOf = (status) => statusValue(status, "connection")
+    .replace(/\s*(\((checking the connection|network interference detected)\)|\[Network interference\])$/i, "")
+    .replace(/^(Connected|Connecting) to /, "$1: ");
+/** "Connected: Miami - Vice", "Connecting: …", "Disconnected", … whichever app version */
+export const connectState = async () => connectStateOf(await windscribe("status"));
+/** "Logged in", "Logging in", "Logged out" or "Error: …", whichever app version */
+export const loginState = (status) => statusValue(status, "login");
+/** The VPN's IP while connected (once the app has checked the connection): 2.25 and newer say "IP: 1.2.3.4 (VPN)", older
+ * ones "VPN IP: 1.2.3.4"; "" otherwise */
+export const vpnIpOf = (status) => status.match(/^(?:VPN IP:[ \t]*(\S+)|IP:[ \t]*(\S+)[ \t]+\(VPN\))/m)?.slice(1).find(Boolean) ?? "";
+/** This computer's own IP while disconnected: "IP: 1.2.3.4 (public)", or "Public IP: 1.2.3.4" before 2.25; "" otherwise */
+export const publicIpOf = (status) => status.match(/^(?:Public IP:[ \t]*(\S+)|IP:[ \t]*(\S+)[ \t]+\(public\))/m)?.slice(1).find(Boolean) ?? "";
 /** Waits for the app to run and be logged in; resolves to its status output */
 export async function waitForLogin() {
     // the first CLI call launches the app if it isn't running; give it a moment to start and restore the session
     let status = await windscribe("status");
-    for (let i = 0; i < 15 && !status.includes("Logged in"); i++) {
+    for (let i = 0; i < 15 && loginState(status) !== "Logged in"; i++) {
         await sleep(1000);
         status = await windscribe("status");
     }
-    if (!status.includes("Logged in"))
+    if (loginState(status) !== "Logged in")
         throw new Error("Windscribe is not logged in, or the app is not running. Open the Windscribe app and log in, then try again."
             + `\nDon't have it? ${DOWNLOAD_URL}`);
     return status;
@@ -128,11 +146,41 @@ export function session() {
     const authHash = setting("authHash");
     return authHash ? { userId: setting("userId"), authHash } : null;
 }
-export const isFirewallOn = (status) => /^Firewall state: On/m.test(status);
+// The app's own log, in Qt's app data folder. It notes each disconnect the app is told to make (its disconnect button, a switch
+// to another location, windscribe-cli disconnect) with this line, but not the one it makes itself after failing to reconnect
+const APP_LOG = join(process.platform === "darwin" ? join(homedir(), "Library", "Application Support")
+    : process.platform === "win32" ? process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local")
+        : process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), "Windscribe", "Windscribe2", "client.log");
+const TOLD = "ConnectionManager::clickDisconnect()";
+const STARTED = "=== Started ==="; // the first line of each log the app starts when it starts
+/** The app log's size now, for toldToDisconnect(); 0 when there's no log */
+export function appLogSize() {
+    try {
+        return statSync(APP_LOG).size;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Whether the app was told to disconnect since its log was size bytes long, or restarted (quit, which disconnects, then
+ * started again: by windscribe-cli, which starts it when it isn't running); false when it can't tell (no log, or another app
+ * version that words it differently) */
+export function toldToDisconnect(size) {
+    try {
+        const log = readFileSync(APP_LOG);
+        // shorter: a new log, which the app starts when it starts (or when one grows too long, without STARTED)
+        return log.length < size ? log.includes(TOLD) || log.includes(STARTED) : log.subarray(size).includes(TOLD);
+    }
+    catch {
+        return false;
+    }
+}
+// "On", "Off" or "Always On"
+export const isFirewallOn = (status) => /^(Always )?On$/.test(statusValue(status, "firewall"));
 let firewallChanged = false; // blockInternet() turned the firewall on, so restoreFirewall() turns it back off
 /** Turns on the app's firewall, so nothing goes online outside the VPN. False if it was on already (it then stays on) */
 export async function blockInternet() {
-    if (!/^Firewall state: Off/m.test(await windscribe("status")))
+    if (statusValue(await windscribe("status"), "firewall") !== "Off")
         return false;
     await windscribe("firewall", "on");
     return (firewallChanged = true);

package/dist/worker.js

@@ -4,9 +4,10 @@ import { spawn } from "node:child_process";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { createInterface } from "node:readline";
+import { outsideIp } from "./measure.js";
 import { probe } from "./probe.js";
 import { now, sleep } from "./time.js";
-import { SETTINGS, windscribe, withSession } from "./windscribe.js";
+import { loginState, SETTINGS, windscribe, withSession } from "./windscribe.js";
 const APP = "/opt/windscribe/Windscribe"; // as the image installs it
 const send = (m) => process.stdout.write(JSON.stringify(m) + "\n");
 export async function worker() {
@@ -43,15 +44,16 @@ export async function worker() {
     spawn(APP, { stdio: "ignore" }).on("error", () => { }); // not there: its CLI never answers below
     // its CLI answers once it's up, and says logged in once Windscribe accepts the session, or the error it got instead.
     // One container took 37 s in a test, 16 at once 38-75 s
-    let status = "";
-    for (const t = now(); now() - t < 180 && !/Login state: (Logged in|Error)/.test(status = await windscribe("status"));)
+    let login = "";
+    for (const t = now(); now() - t < 180 && !/^(Logged in|Error)/.test(login = loginState(await windscribe("status")));)
         await sleep(1000);
-    if (!status.includes("Logged in")) {
-        const state = status.match(/^Login state: (.*)$/m)?.[1].trim();
-        return void console.error(state ? `Windscribe's app didn't log in with this computer's session (${state})` : "Windscribe's app didn't start in the container");
+    if (login !== "Logged in") {
+        return void console.error(login ? `Windscribe's app didn't log in with this computer's session (${login})` : "Windscribe's app didn't start in the container");
     }
     send({ ready: true, wireguard: process.env.WS_WIREGUARD !== "0" }); // the image's CMD checked the kernel
     for (let m; (m = await next());) {
+        if (m.whoami)
+            send({ ip: await outsideIp() }); // its app is disconnected now: this is the container's own way out
         if (!m.probe)
             continue;
         stop = false;

package/package.json

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