@wirecat/max-cli 0.0.0 → 0.43.0

package/dist/server/server.js

@@ -0,0 +1,634 @@
+import { chmodSync, mkdirSync, rmSync } from "node:fs";
+import { connect, createServer } from "node:net";
+import { dirname } from "node:path";
+import { CliError } from "@wirecat/cli-core";
+import * as v from "valibot";
+import { FIRST_TAB_SYNC, isJoinRequest, MaxClient, } from "../client.js";
+import { resolveSettings } from "../config.js";
+import { Opcode } from "../generated/opcodes.generated.js";
+import { assertReadable } from "../permissions.js";
+import { Connection, ProtocolError } from "../protocol/connection.js";
+import { asId } from "../protocol/frame.js";
+import { maxRecord } from "../record.js";
+import { guardFor } from "../sends.js";
+import { objectOf } from "../spec/guards.js";
+import { VERSION } from "../version.js";
+import { fromLine, lineReader, toLine } from "./lines.js";
+import { serverReplies } from "./replies.js";
+import { forwardedOperation, OPERATIONS_FINGERPRINT, stopServer } from "./server-connection.js";
+/** The web client's keep-alive interval (web.max.ru bundle, 2026-09-24). A different one is a fingerprint. */
+const PING_EVERY_MS = 30_000;
+/**
+ * A hidden web tab sends its one telemetry event this long after it opened, and nothing after
+ * (frames captured 2026-09-25, `docs/dev/capture/2026-09-25-web-tab.md`).
+ */
+const TELEMETRY_AFTER_MS = 20_000;
+/** How long after its login answer the tab's chat list appeared in the same capture. */
+const CHAT_LIST_SHOWN_AFTER_MS = 500;
+/** A message arrived — what MAX pushes, and what a send through this server is handed on as. */
+const NEW_MESSAGE = 128;
+const CHAT_CHANGED = 135;
+const CONFIG_CHANGED = 134;
+/** A request is a command's payload; a message with its markup is a few kilobytes. */
+const MAX_REQUEST_LENGTH = 1024 * 1024;
+/** A login MAX counts; after one, the next background login waits at least this long. */
+const REFRESH_EVERY_MS = 60_000;
+/**
+ * **One logged-in connection per profile, kept open** (`MAX-16`), and a Unix socket beside the
+ * profile's state for local readers.
+ *
+ * It reopens REQUIREMENTS §3 and §18 on purpose and only here: every other command stays one-shot.
+ * What it does on the wire copies web.max.ru — a ping every 30 s, MAX's pings answered, each new
+ * message acknowledged (`Connection` with `live`). It never marks anything read. It sends on its own
+ * only what the owner's reply rules answer, to the people and chats their audience allows (`NEED-645`).
+ *
+ * The socket answers `{"subscribe": true}` with a stream of `ServerEvent` lines and
+ * `{"status": true}` with one. For a command reusing the connection (`ServerConnection`) it answers
+ * `{"id", "login": true}` with the login it holds, and `{"id", "opcode", "payload"}` by passing the
+ * request to MAX — sends included (`NEED-229`). **Every write goes through the send guard here**,
+ * and is journaled here (`NEED-269`): anything of the owner's can write to this socket, not only a
+ * command that checked first. An operation the specification does not declare is not passed on.
+ */
+export class MaxServer {
+    #options;
+    #record;
+    #subscribers = new Set();
+    #listener;
+    #client;
+    #ping;
+    #retry;
+    #attempt = 0;
+    #stopped = false;
+    /** Every client on the socket — a command, `max mcp`, `max watch`. Idle means none at all. */
+    #open = new Set();
+    /** Message ids already handed to watchers, newest last. */
+    #seen = new Set();
+    /** Settles when a connection is up; replaced while the server reconnects. */
+    #up;
+    #markUp = () => { };
+    #refresh;
+    #lastRefresh = 0;
+    #lastUse = Date.now();
+    #startedAt = new Date().toISOString();
+    #idle;
+    #telemetry;
+    /** What the last reads after login answered, sent back on the next login as the tab does (`MAX-52`). */
+    #tabSync = FIRST_TAB_SYNC;
+    /** The last connection's login, kept past a drop so the next login resumes it (`MAX-51`). */
+    #resume;
+    #handing = Promise.resolve();
+    #connecting = new Set();
+    #replies;
+    #members;
+    #finish;
+    /** Settles when the server stops — cleanly, or with the error that stopped it. */
+    done;
+    constructor(options) {
+        this.#options = options;
+        this.#members = options.members?.(() => (this.#stopped ? undefined : this.#client));
+        this.#record = maxRecord({ account: () => options.store.readState().viewerId });
+        this.#replies = serverReplies({
+            profile: options.store.profile,
+            since: Date.parse(this.#startedAt),
+            owner: () => options.store.readState().viewerId,
+            client: () => this.#client,
+            guard: () => options.guard?.() ??
+                // A rule has nobody to ask: a level of `ask` is not a yes.
+                guardFor(resolveSettings({ profile: options.store.profile }), options.note, async (key) => {
+                    throw new CliError("confirmation_required", `${key} asks before it acts — serve has nobody to ask`);
+                }),
+            note: options.note,
+        });
+        this.#up = new Promise((resolve) => {
+            this.#markUp = resolve;
+        });
+        this.done = new Promise((resolve, reject) => {
+            this.#finish = (error) => (error ? reject(error) : resolve());
+        });
+    }
+    get connected() {
+        return this.#client !== undefined;
+    }
+    /** Logs in first: a token that does not work should fail here, before anything listens. */
+    async start() {
+        // The socket first: whoever binds it is the profile's one server, and a second one learns it
+        // before it has logged in — not after, with a login MAX has already counted.
+        const sessionId = Date.now();
+        try {
+            await this.#listen();
+            await this.#connect();
+        }
+        catch (error) {
+            await this.stop();
+            throw error;
+        }
+        finally {
+            rmSync(startingPath(this.#options.store), { force: true });
+        }
+        if (this.#stopped)
+            return;
+        this.#reportChatList(sessionId, Date.now() + CHAT_LIST_SHOWN_AFTER_MS);
+        const { idleMs } = this.#options;
+        if (idleMs !== undefined) {
+            this.#idle = setInterval(() => {
+                if (this.#open.size === 0 && Date.now() - this.#lastUse >= idleMs) {
+                    this.#options.note(`nobody has used it for ${Math.round(idleMs / 60_000)} min — stopping`);
+                    void this.stop();
+                }
+            }, Math.min(idleMs, 30_000));
+        }
+    }
+    async stop(error) {
+        if (this.#stopped)
+            return;
+        this.#stopped = true;
+        // Anyone still waiting for a connection gets "not connected" rather than waiting forever.
+        this.#markUp();
+        clearInterval(this.#ping);
+        clearTimeout(this.#retry);
+        clearTimeout(this.#refresh);
+        clearInterval(this.#idle);
+        clearTimeout(this.#telemetry);
+        await Promise.all([...this.#connecting].map((client) => client.close()));
+        for (const socket of this.#open)
+            socket.destroy();
+        this.#subscribers.clear();
+        // Only the server that bound the socket removes it: one refused as "already running" would
+        // otherwise delete the running server's socket and let a third start beside it.
+        if (this.#listener) {
+            await new Promise((resolve) => this.#listener?.close(() => resolve()));
+            if (process.platform !== "win32")
+                rmSync(this.#options.store.socketPath(), { force: true });
+        }
+        try {
+            this.#replies.stop();
+            await this.#members?.stop().catch(() => this.#options.note("daily member fetching could not close its store"));
+            await this.#handing;
+            await this.#replies.settled();
+            await this.#client?.close();
+        }
+        finally {
+            this.#client = undefined;
+            await this.#replies.close();
+            await this.#record.close();
+            this.#finish?.(error);
+        }
+    }
+    /**
+     * Logs in on a new connection and, once that worked, makes it the server's — closing the one it
+     * replaces, if any. Pushes that arrive before the login finishes are held and replayed, not
+     * dropped: `Connection` has already acknowledged them, so MAX will not send them again.
+     */
+    async #connect() {
+        if (this.#stopped)
+            return;
+        const { store, timeoutMs, events } = this.#options;
+        let mine;
+        const early = [];
+        const connection = (this.#options.connection ??
+            ((hooks) => new Connection({ ...hooks, live: true, ...(timeoutMs ? { timeoutMs } : {}) })))({
+            onEvent: (frame) => {
+                if (mine)
+                    this.#pushed(mine, frame.opcode, frame.payload ?? {});
+                else
+                    early.push([frame.opcode, frame.payload ?? {}]);
+            },
+            onClose: (error) => {
+                if (mine && mine === this.#client)
+                    this.#lost(error);
+            },
+            onError: (error) => this.#options.note(`a pushed frame was dropped: ${error.message}`),
+        });
+        const resume = this.#client?.live.resumeFrom() ?? this.#resume;
+        const client = new MaxClient({
+            store,
+            connection,
+            // `#forward` guards every write a command hands this server, before this client sends it.
+            sends: "caller",
+            fullLogin: true,
+            ...(resume ? { resume } : {}),
+            warn: this.#options.note,
+            record: this.#record,
+            ...(events ? { events } : {}),
+        });
+        this.#connecting.add(client);
+        try {
+            await client.connect();
+        }
+        catch (error) {
+            // A socket left open after a refused login keeps the process alive after it said it failed.
+            await client.close();
+            throw error;
+        }
+        finally {
+            this.#connecting.delete(client);
+        }
+        const replaced = this.#client;
+        if (this.#stopped) {
+            await client.close();
+            return;
+        }
+        mine = client;
+        this.#client = client;
+        this.#members?.start();
+        this.#markUp();
+        this.#attempt = 0;
+        this.#lastRefresh = Date.now();
+        clearInterval(this.#ping);
+        this.#ping = setInterval(() => {
+            client.live.ping().catch(() => { });
+        }, this.#options.pingEveryMs ?? PING_EVERY_MS);
+        if (replaced)
+            await replaced.close().catch(() => { });
+        else
+            this.#broadcast({ event: "status", connected: true, at: new Date().toISOString() });
+        for (const [opcode, payload] of early)
+            this.#pushed(client, opcode, payload);
+        client.live
+            .readLikeTab(this.#tabSync)
+            .then((next) => {
+            this.#tabSync = next;
+        })
+            .catch((error) => this.#options.note(`the reads after login were not all answered: ${error.message}`));
+    }
+    /** Once per server, never again after a reconnect: the tab it copies keeps its session too. */
+    #reportChatList(sessionId, at) {
+        const wait = Math.max(0, sessionId + (this.#options.telemetryAfterMs ?? TELEMETRY_AFTER_MS) - Date.now());
+        this.#telemetry = setTimeout(() => {
+            this.#client?.live
+                .chatListShown({ at, sessionId })
+                .catch((error) => this.#options.note(`telemetry was not sent: ${error.message}`));
+        }, wait);
+    }
+    #pushed(client, opcode, payload) {
+        const whole = objectOf(payload.chat);
+        const news = whole.id === undefined || client.live.news(whole);
+        if (!client.live.patch(opcode, payload))
+            this.#goneStale();
+        // In arrival order: an edit waits on a name lookup, and must not reach a watcher after the deletion behind it.
+        this.#handing = this.#handing.then(async () => {
+            try {
+                const message = await client.live.message(opcode, payload);
+                if (message) {
+                    this.#replies.arrived(message);
+                    this.#broadcast({ event: "message", message });
+                }
+                const change = await client.live.change(opcode, payload);
+                if (change && (change.event !== "chat" || news))
+                    this.#broadcast({ event: "change", change });
+            }
+            catch (error) {
+                this.#options.note(`a pushed message could not be read: ${error.message}`);
+            }
+        });
+    }
+    /**
+     * The login can no longer be handed out. Rather than wait for a drop that may be hours away, log
+     * in again in the background — at most once a minute, since each is a login MAX counts.
+     */
+    #goneStale() {
+        if (this.#refresh || this.#stopped)
+            return;
+        const every = this.#options.refreshEveryMs ?? REFRESH_EVERY_MS;
+        const wait = Math.max(0, this.#lastRefresh + every - Date.now());
+        this.#refresh = setTimeout(() => {
+            this.#connect()
+                .catch((error) => {
+                if (refusedLogin(error))
+                    void this.stop(error);
+                else
+                    this.#options.note(`could not log in again: ${error.message}`);
+            })
+                .finally(() => {
+                this.#refresh = undefined;
+            });
+        }, wait);
+    }
+    #lost(error) {
+        clearInterval(this.#ping);
+        const client = this.#client;
+        this.#resume = client?.live.resumeFrom();
+        this.#client = undefined;
+        this.#up = new Promise((resolve) => {
+            this.#markUp = resolve;
+        });
+        client?.close().catch(() => { });
+        if (this.#stopped)
+            return;
+        this.#broadcast({ event: "status", connected: false, at: new Date().toISOString() });
+        this.#reconnectLater(error);
+    }
+    #reconnectLater(error) {
+        if (this.#stopped)
+            return;
+        const wait = (this.#options.retryAfterMs ?? backoff)(this.#attempt);
+        this.#attempt += 1;
+        this.#options.note(`${error.message} — connecting again in ${Math.round(wait / 1000)}s`);
+        this.#retry = setTimeout(() => {
+            this.#connect().catch((failure) => {
+                if (refusedLogin(failure))
+                    this.stop(failure);
+                else
+                    this.#reconnectLater(failure);
+            });
+        }, wait);
+    }
+    #broadcast(event) {
+        if (event.event !== "status") {
+            try {
+                assertReadable(resolveSettings({ profile: this.#options.store.profile }), "messages.watch");
+            }
+            catch {
+                for (const socket of this.#subscribers)
+                    socket.destroy();
+                this.#subscribers.clear();
+                return;
+            }
+        }
+        if (event.event === "message") {
+            // A retried send answers with the same message, and MAX repeats pushes after a hiccup.
+            if (this.#seen.has(event.message.id))
+                return;
+            this.#seen.add(event.message.id);
+            if (this.#seen.size > 500)
+                this.#seen.delete(this.#seen.values().next().value);
+        }
+        const line = toLine(event);
+        for (const socket of this.#subscribers)
+            socket.write(line);
+    }
+    async #listen() {
+        const path = this.#options.store.socketPath();
+        // A server a command started gives way to one started by hand; one started by hand does not.
+        if ((await answers(path)) && !(!this.#options.startedByCommand && (await stopServer(path)) === "stopped")) {
+            throw new CliError("validation_error", `a server is already running for profile "${this.#options.store.profile}"`);
+        }
+        if (this.#stopped)
+            return;
+        const pipe = process.platform === "win32";
+        // macOS takes 104 bytes with the terminator, Linux 108; past that `listen` says only EINVAL.
+        if (!pipe && Buffer.byteLength(path) > 103) {
+            throw new CliError("configuration_error", `the server's socket path is ${Buffer.byteLength(path)} bytes, more than this system allows (103): ${path} — ` +
+                "a shorter profile name or MAX_STATE_DIR fixes it");
+        }
+        if (!pipe) {
+            // Nobody answers on it, so it is what a crashed server left behind.
+            rmSync(path, { force: true });
+            mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+            // The socket is open to everyone between `listen` and its `chmod`; only the directory keeps
+            // others out then, and `mkdirSync` leaves an existing one as it found it.
+            chmodSync(dirname(path), 0o700);
+        }
+        const listener = createServer((socket) => this.#serve(socket));
+        await new Promise((resolve, reject) => {
+            listener.once("error", reject);
+            listener.listen(path, () => resolve());
+        });
+        if (this.#stopped) {
+            await new Promise((resolve) => listener.close(() => resolve()));
+            if (!pipe)
+                rmSync(path, { force: true });
+            return;
+        }
+        if (!pipe)
+            chmodSync(path, 0o600);
+        this.#listener = listener;
+    }
+    #serve(socket) {
+        this.#open.add(socket);
+        socket.on("error", () => this.#subscribers.delete(socket));
+        socket.on("close", () => {
+            this.#subscribers.delete(socket);
+            this.#open.delete(socket);
+            this.#lastUse = Date.now();
+        });
+        socket.on("data", lineReader((line) => {
+            this.#request(socket, line).catch(() => socket.destroy());
+        }, { maxLength: MAX_REQUEST_LENGTH, onTooLong: () => socket.destroy() }));
+    }
+    async #request(socket, line) {
+        let request;
+        try {
+            request = fromLine(line);
+        }
+        catch {
+            socket.write(toLine({ error: { code: "bad_request", message: "one JSON object per line" } }));
+            return;
+        }
+        const status = {
+            event: "status",
+            connected: this.connected,
+            at: new Date().toISOString(),
+            byHand: !this.#options.startedByCommand,
+            pid: process.pid,
+            version: VERSION,
+            operations: OPERATIONS_FINGERPRINT,
+            startedAt: this.#startedAt,
+        };
+        const { id } = request;
+        this.#lastUse = Date.now();
+        if (request.subscribe === true) {
+            try {
+                assertReadable(resolveSettings({ profile: this.#options.store.profile }), "messages.watch");
+            }
+            catch (error) {
+                socket.end(toLine({ id, ...refusal(error) }));
+                return;
+            }
+            this.#subscribers.add(socket);
+            socket.write(toLine(status));
+        }
+        else if (request.status === true) {
+            socket.write(toLine(status));
+        }
+        else if (request.stop === true) {
+            // Only the owner can reach this socket (mode 600). `max session end` asks, so a forgotten
+            // session is not kept alive by a server a command started — one started by hand stays.
+            if (!this.#options.startedByCommand && request.force !== true) {
+                socket.end(toLine({ id, stopped: false, reason: "started by hand; Ctrl-C, or `max serve --stop`" }));
+                return;
+            }
+            socket.end(toLine({ id, stopped: true }));
+            await this.stop();
+        }
+        else if (request.login === true) {
+            try {
+                const settings = resolveSettings({ profile: this.#options.store.profile });
+                for (const key of ["messages", "chats", "contacts", "account"])
+                    assertReadable(settings, key);
+            }
+            catch (error) {
+                socket.write(toLine({ id, ...refusal(error) }));
+                return;
+            }
+            // A request that arrives while the server logs in, or logs in again, waits for it: the
+            // command's own timeout is what gives up, not this. A login a deletion made stale is still
+            // handed out — only a deleted last message can be wrong in it — while a fresh one is fetched.
+            await this.#up;
+            const client = this.#client;
+            socket.write(toLine(client
+                ? { id, payload: client.live.snapshot() }
+                : { id, error: { code: "unavailable", message: "not connected" } }));
+        }
+        else if (typeof request.opcode === "number") {
+            const operationId = typeof request.operationId === "string" ? request.operationId : undefined;
+            socket.write(toLine({ id, ...(await this.#forward(request.opcode, request.payload, operationId, request.approvals)) }));
+        }
+        else {
+            socket.write(toLine({ id, error: { code: "bad_request", message: "subscribe, status, login or an opcode" } }));
+        }
+    }
+    async #forward(opcode, payload, operationId, approvals) {
+        await this.#up;
+        const client = this.#client;
+        const operation = forwardedOperation(opcode);
+        if (!operation) {
+            return { error: { code: "not_allowed", message: `opcode ${opcode} is not one the server passes on` } };
+        }
+        if (!client)
+            return { error: { code: "unavailable", message: "not connected" } };
+        const request = (payload ?? {});
+        // The shape the specification allows, checked here as `buildRequest` checks it in a command:
+        // an id crosses the socket as a `bigint`, and the schema reads the string it was built from.
+        if (!v.safeParse(operation.request, asStrings(request)).success) {
+            return refusal(new CliError("validation_error", `${operation.name}: not a request this version of max sends`));
+        }
+        if (!operation.guard) {
+            try {
+                assertReadable(resolveSettings({ profile: this.#options.store.profile }), operation.name === "chats.history" || operation.name.startsWith("attachments.")
+                    ? "messages"
+                    : operation.name.startsWith("folders.")
+                        ? `chats.${operation.name}`
+                        : operation.name);
+            }
+            catch (error) {
+                return refusal(error);
+            }
+            return this.#pass(client, opcode, request);
+        }
+        let entry;
+        let guard;
+        try {
+            entry = { ...operation.guard(request), ...(operationId === undefined ? {} : { operationId }) };
+            // Read again for every write, so `config set readOnly true` needs no restart.
+            guard =
+                this.#options.guard?.() ??
+                    guardFor(resolveSettings({ profile: this.#options.store.profile }), this.#options.note, async (key) => {
+                        if (!Array.isArray(approvals) || !approvals.includes(key))
+                            throw new CliError("confirmation_required", `${key} asks before it acts — this request has no explicit confirmation`);
+                    });
+        }
+        catch (error) {
+            return refusal(error);
+        }
+        try {
+            await guard.ask?.(entry);
+            guard.check(entry);
+        }
+        catch (error) {
+            guard.record({ ...entry, outcome: "refused", errorCode: asCliError(error).code });
+            return refusal(error);
+        }
+        return this.#sendJournaled(client, opcode, request, guard, entry);
+    }
+    async #sendJournaled(client, opcode, request, guard, entry) {
+        const answer = await this.#pass(client, opcode, request);
+        const error = answer.error;
+        if (!error) {
+            const reply = objectOf(answer.payload);
+            const messageId = asId(objectOf(reply.message).id);
+            const chatId = entry.chatId ?? asId(reply.chatId) ?? asId(objectOf(reply.chat).id) ?? null;
+            guard.record({ ...entry, chatId, ...(messageId ? { messageId } : {}), outcome: "sent" });
+        }
+        else if (error.code === "refused") {
+            // MAX's "not yet" while an upload is processed: the command asks again, and that is one message.
+            if (!error.message?.includes("attachment.not.ready")) {
+                guard.record({ ...entry, outcome: "failed", errorCode: "provider_error" });
+            }
+        }
+        else {
+            guard.record({ ...entry, outcome: "outcome_unknown", errorCode: "timeout" });
+        }
+        return answer;
+    }
+    async #pass(client, opcode, request) {
+        try {
+            const answer = await client.live.forward(opcode, request);
+            // MAX does not push a message back to the connection that sent it, and every send now comes
+            // through this one — so `max watch` would never see what `max` itself sent. The answer
+            // carries the message; hand it on as if it had been pushed. A scheduled one is not sent yet.
+            const scheduled = request.message?.delayedAttributes;
+            if (opcode === Opcode.MSG_SEND && answer.message && !scheduled) {
+                this.#pushed(client, NEW_MESSAGE, { chatId: request.chatId, message: answer.message });
+            }
+            // Nor a chat we changed: the answer carries it whole, as a 135 push would. Without this the
+            // owner's own rename showed the old title until something else touched the chat.
+            // Not a group looked at by its link, nor one the owner only asked to join: the owner is not in it.
+            const joinRequest = opcode === Opcode.CHAT_JOIN && isJoinRequest(objectOf(answer.chat));
+            if (answer.chat && opcode !== Opcode.LINK_INFO && !joinRequest)
+                this.#pushed(client, CHAT_CHANGED, { chat: answer.chat });
+            // The same for a contact we renamed: commands keep the login's contacts in the shared store.
+            if (objectOf(answer.contact).id !== undefined)
+                client.live.contact(objectOf(answer.contact));
+            // Nor our own settings change, which other sessions hear as 134 (measured 2026-10-08): without
+            // this, `account privacy show` after `set` read the setting from before it.
+            if (opcode === Opcode.CONFIG) {
+                const sent = objectOf(request.settings);
+                this.#pushed(client, CONFIG_CHANGED, {
+                    config: { hash: answer.hash, user: answer.user ?? sent.user, chats: sent.chats },
+                });
+            }
+            // Nor does it push our own deletion back; the chat's last message may be the one deleted.
+            if (opcode === Opcode.MSG_DELETE)
+                this.#goneStale();
+            return { payload: answer };
+        }
+        catch (error) {
+            if (error instanceof ProtocolError) {
+                return { error: { code: "refused", message: error.message, payload: error.payload } };
+            }
+            return { error: { code: "unavailable", message: error instanceof Error ? error.message : String(error) } };
+        }
+    }
+}
+const asStrings = (value) => {
+    if (typeof value === "bigint")
+        return value.toString();
+    if (Array.isArray(value))
+        return value.map(asStrings);
+    if (typeof value === "object" && value !== null) {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, asStrings(item)]));
+    }
+    return value;
+};
+const asCliError = (error) => error instanceof CliError
+    ? error
+    : new CliError("validation_error", error instanceof Error ? error.message : String(error));
+/** `guard` tells the command's `ServerConnection` to rethrow it as the same error, exit code included. */
+const refusal = (error) => {
+    const { code, message, details } = asCliError(error);
+    return { error: { code, message, details, guard: true } };
+};
+/**
+ * **MAX answered the login and said no** — as opposed to a network that dropped or a MAX that did
+ * not answer. Only those two are retried. A refusal is not: a token MAX no longer takes will not
+ * start working, and a login repeated after the limit error kept a PyMax account locked (PyMax
+ * #106). Any refusal counts, not only the recognised limit, because what that error says is a claim
+ * (`NEED-266`).
+ */
+export const refusedLogin = (error) => error instanceof CliError &&
+    (error.code === "authentication_error" || error.code === "rate_limited" || error.code === "provider_error");
+/** 1 s, 2 s, 4 s … a minute at most — a server that hammers MAX after a drop looks like nothing MAX knows. */
+const backoff = (attempt) => Math.min(60_000, 1000 * 2 ** attempt);
+/** Present while a server is being started in the background, so two commands do not start two. */
+export const startingPath = (store) => store.serverFile(".sock.starting");
+/** Whether something is listening on the socket — a live server, not a leftover file. */
+export const answers = (path) => new Promise((resolve) => {
+    const probe = connect(path);
+    probe.once("connect", () => {
+        probe.destroy();
+        resolve(true);
+    });
+    probe.once("error", () => resolve(false));
+});
+//# sourceMappingURL=server.js.map