seekmux 0.0.1 → 0.0.2

package/README.md

@@ -0,0 +1,36 @@
+# seekmux
+
+The worker of a [SeekMux](https://github.com/fl0w1nd/seekmux) self-hosted
+fetcher. It reads pages for the gateway in a Chrome where you are signed in,
+through [OpenCLI](https://github.com/jackwener/opencli): X and Reddit posts
+through OpenCLI's site adapters, other pages as they render.
+
+## Use
+
+1. On the gateway's console, open **自托管抓取器** (Self-hosted fetchers),
+   create a fetcher or add a worker to one, and copy the worker's token.
+2. Install the OpenCLI
+   [Browser Bridge extension](https://github.com/jackwener/opencli#2-install-the-browser-bridge-extension)
+   in the Chrome profile to read with, and keep that Chrome open.
+3. Run the worker (Node.js 22.4 or later):
+
+   ```bash
+   npx seekmux --server https://your-gateway --token <worker token>
+   ```
+
+The worker connects to the gateway's `/worker` endpoint over a WebSocket and
+reconnects when the connection drops, so the machine needs no open port. It
+stops when the gateway refuses its token (the token was changed or the worker
+removed), or when another worker connects with the same token.
+
+| Option | Environment | |
+| --- | --- | --- |
+| `--server` | `SEEKMUX_SERVER` | The gateway's address |
+| `--token` | `SEEKMUX_WORKER_TOKEN` | The worker's token |
+| `--slots` | | Pages read at once, 1 or 2 (default 1) |
+
+OpenCLI is a dependency of this package, so nothing else needs installing.
+
+## License
+
+MIT

package/dist/diagnose.js

@@ -0,0 +1,54 @@
+// Says why a connection to the gateway could not be opened. The WebSocket
+// API reports a failed handshake only as code 1006, so the handshake is
+// tried again over plain HTTP to see what answered it.
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { randomBytes } from "node:crypto";
+/** Returns why the handshake fails, or undefined when it succeeds now. */
+export function diagnose(wsURL, timeoutMs = 10_000) {
+    const url = new URL(wsURL);
+    url.protocol = url.protocol === "ws:" ? "http:" : "https:";
+    const request = url.protocol === "http:" ? httpRequest : httpsRequest;
+    return new Promise((resolve) => {
+        const req = request(url, {
+            timeout: timeoutMs,
+            headers: {
+                Connection: "Upgrade",
+                Upgrade: "websocket",
+                "Sec-WebSocket-Version": "13",
+                "Sec-WebSocket-Key": randomBytes(16).toString("base64"),
+            },
+        });
+        req.on("upgrade", (_res, socket) => {
+            socket.destroy();
+            resolve(undefined);
+        });
+        req.on("response", (res) => {
+            let body = "";
+            res.setEncoding("utf8");
+            res.on("data", (chunk) => {
+                if (body.length < 2048)
+                    body += chunk;
+            });
+            res.on("end", () => resolve(explain(url, res.statusCode ?? 0, String(res.headers["content-type"] ?? ""), body)));
+            res.on("error", () => resolve(`the gateway answered HTTP ${res.statusCode}`));
+        });
+        req.on("timeout", () => req.destroy(new Error(`no answer within ${timeoutMs / 1000}s`)));
+        req.on("error", (err) => resolve(`could not reach ${url.host}: ${err.message}`));
+        req.end();
+    });
+}
+function explain(url, status, type, body) {
+    if (status === 426 && /upgrade/i.test(body)) {
+        return `the request reached the gateway without its WebSocket upgrade: the reverse proxy in front of it must pass the Upgrade and Connection headers on ${url.pathname}`;
+    }
+    if (status === 200 && type.includes("text/html")) {
+        return `${url.host} answered ${url.pathname} with a web page: the gateway is older than 0.7.0, or the address is not the gateway's`;
+    }
+    if (status === 404)
+        return `${url.host} has no ${url.pathname}: the gateway is older than 0.7.0, or the address is not the gateway's`;
+    if (status === 502 || status === 503 || status === 504)
+        return `the reverse proxy answered HTTP ${status}: the gateway behind it is not reachable`;
+    const said = body.trim().split("\n")[0]?.slice(0, 200);
+    return `the gateway answered HTTP ${status}${said ? `: ${said}` : ""}`;
+}

package/dist/worker.js

@@ -1,5 +1,6 @@
 // The connection to the gateway: says hello, reports the browser's state,
 // runs the fetches it is handed and reconnects when the connection drops.
+import { diagnose } from "./diagnose.js";
 import { Canceled, readState } from "./opencli.js";
 import { CloseCode, FetchError, PROTOCOL_VERSION } from "./protocol.js";
 import { read } from "./sites.js";
@@ -20,8 +21,10 @@ export async function run(opts) {
     let state = await readState();
     logState(opts, state);
     let delay = 1000;
+    // Why the last connection could not be opened, said again only when it changes.
+    let problem;
     for (;;) {
-        const { code, reason, welcomed } = await session(opts, state, (next) => (state = next));
+        const { code, reason, opened, welcomed } = await session(opts, state, (next) => (state = next));
         if (code === CloseCode.Unauthorized || code === CloseCode.Protocol) {
             throw new Error(`the gateway refused this worker: ${reason || code}`);
         }
@@ -30,7 +33,15 @@ export async function run(opts) {
         }
         if (welcomed)
             delay = 1000;
-        opts.log(`disconnected (${reason || code}); reconnecting in ${delay / 1000}s`);
+        if (opened) {
+            problem = undefined;
+            opts.log(`disconnected (${reason || code}); reconnecting in ${delay / 1000}s`);
+        }
+        else {
+            const why = await diagnose(opts.url);
+            opts.log(why && why === problem ? `could not connect, as before; retrying in ${delay / 1000}s` : `could not connect to ${opts.url}${why ? `: ${why}` : ""}; retrying in ${delay / 1000}s`);
+            problem = why;
+        }
         await new Promise((resolve) => setTimeout(resolve, delay));
         delay = Math.min(delay * 2, 30_000);
     }
@@ -42,6 +53,7 @@ function logState(opts, state) {
 function session(opts, initial, setState) {
     return new Promise((resolve) => {
         let state = initial;
+        let opened = false;
         let welcomed = false;
         const running = new Map();
         const ws = new WebSocket(opts.url);
@@ -72,6 +84,7 @@ function session(opts, initial, setState) {
         };
         const timer = setInterval(check, STATE_INTERVAL);
         ws.addEventListener("open", () => {
+            opened = true;
             send({ type: "hello", protocol: PROTOCOL_VERSION, token: opts.token, version: opts.version, slots: opts.slots, state });
         });
         ws.addEventListener("message", async (event) => {
@@ -128,7 +141,7 @@ function session(opts, initial, setState) {
             clearInterval(timer);
             for (const controller of running.values())
                 controller.abort();
-            resolve({ code: event.code, reason: event.reason, welcomed });
+            resolve({ code: event.code, reason: event.reason, opened, welcomed });
         });
         // An error is followed by a close event, which ends the session.
         ws.addEventListener("error", () => { });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "seekmux",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "SeekMux worker: reads pages for a SeekMux gateway in your logged-in Chrome, through OpenCLI",
   "license": "MIT",
   "repository": {