chesspal 0.2.4 → 0.3.0

package/dist/server/page/page.js

@@ -4,40 +4,63 @@ import { watch } from "node:fs";
 import { createServer } from "node:http";
 import { join } from "node:path";
 import { positionIn, samePosition } from "../../commands/index.js";
+import { aiNameOf } from "../../core/index.js";
 import { gameStamp, tableTalkStamp } from "../../games/index.js";
 import { outdatedHostFiles } from "../../host-files/index.js";
 import { gameFolder } from "../../profiles/index.js";
 import { Bell, bellProbe, pagePorts } from "../bell.js";
 import { analysesOf, answerAnalyses } from "./analyses.js";
+import { answerChat } from "./attach.js";
+import { attachedSeen, chatSeenOf, pageContext } from "./chat.js";
+import { askNewGame, keepPosted, tellWatchers } from "./events.js";
 import { sendFile, sendHtml } from "./files.js";
 import { answerGame, chatCalls } from "./game.js";
 import { json, send } from "./http.js";
-import { answerProfiles } from "./profiles.js";
+import { answerProfiles, readRatingsOf } from "./profiles.js";
+import { answerTable } from "./table.js";
 /**
- * Serves the page of the context's folder on 127.0.0.1, on a port of its own when free, else on any free one, where the doorbell cannot find it. The page
- * names the opponent as the host does, once it has connected; the doorbell knows from the context what the chat has read of the player's words.
+ * Serves the page of the context's folder on 127.0.0.1, on a port of its own when free, else on any free one, where the doorbell cannot find it; the
+ * table's on its own ports alone, which keep two tables apart. The page reads the chat from the context in the chat's process, and on the table from
+ * what the chat attached to it tells it (D-104); it names the opponent as the chat's host does. The doorbell knows what the chat has read.
  */
-export async function startPage(context, opponent = () => undefined) {
+export async function startPage(context, options = {}) {
     const { folder } = context;
+    const { table } = options;
     const watchers = new Set();
-    const outdated = outdatedHostFiles(folder, context.platform).length > 0;
-    const served = { folder, context, opponent, bell: new Bell(() => hasNews(context), () => tellWatchers(served)), watchers, port: 0, outdated };
+    const chat = table === undefined ? chatSeenOf(context) : attachedSeen(() => served.attached);
+    const served = {
+        folder,
+        context: pageContext(context),
+        chat,
+        opponent: options.opponent ?? (() => aiNameOf(chat.host())),
+        bell: new Bell(() => hasNews(context, chat), () => tellWatchers(watchers)),
+        watchers,
+        port: 0,
+        outdated: outdatedHostFiles(folder, context.platform).length > 0,
+        ...(table === undefined ? {} : { table }),
+    };
     const server = createServer((request, response) => answer(request, response, served));
-    for (const port of [...pagePorts(folder), 0]) {
+    const ports = table === undefined ? [...pagePorts(folder), 0] : pagePorts(folder);
+    for (const port of ports) {
         if (await listened(server, port)) {
             server.unref();
             served.port = portOf(server);
             const stopWatching = watchGame(served);
             return {
                 url: `http://127.0.0.1:${served.port}/`,
-                heard: () => tellWatchers(served),
+                heard: () => tellWatchers(watchers),
                 chatCalls: () => chatCalls(served),
+                toolEnded: () => undefined,
                 open: () => watchers.size > 0,
-                askNewGame: () => askNewGame(served),
+                inUse: () => watchers.size > 0 || served.attached !== undefined,
+                askNewGame: () => askNewGame(watchers),
                 close: () => closed(server, stopWatching),
             };
         }
     }
+    if (table !== undefined) {
+        throw new Error(`The table's ports ${ports.join(", ")} on 127.0.0.1 are taken by other programs: close them, or play from a chat, which serves its own page.`);
+    }
     throw new Error("Chesspal could not open a port for the page on 127.0.0.1: check that a firewall does not block local servers, then try again.");
 }
 /**
@@ -46,20 +69,21 @@ export async function startPage(context, opponent = () => undefined) {
  */
 export function chatHasRead(context, showed) {
     context.seen = gameSeen(context);
-    if (!showed) {
-        return;
-    }
-    const before = context.positionSeen;
-    try {
-        context.positionSeen = positionIn(gameFolder(context.home()));
-    }
-    catch {
-        context.positionSeen = null;
-    }
-    // The chat on another position may now be thinking on its move: the page hears it, which no file tells when no bell woke the chat.
-    if (!sameSeen(before, context.positionSeen)) {
-        context.heard?.();
+    if (showed) {
+        const before = context.positionSeen;
+        try {
+            context.positionSeen = positionIn(gameFolder(context.home()));
+        }
+        catch {
+            context.positionSeen = null;
+        }
+        // The chat on another position may now be thinking on its move: the page hears it, which no file tells when no bell woke the chat.
+        if (!sameSeen(before, context.positionSeen)) {
+            context.heard?.();
+        }
     }
+    // The table the chat is attached to reads it from a copy (D-104).
+    context.toolEnded?.();
 }
 function sameSeen(one, other) {
     return one === other || (one !== undefined && one !== null && other !== undefined && other !== null && samePosition(one, other));
@@ -74,7 +98,13 @@ function answer(request, response, served) {
         send(response, 403, "text/plain; charset=utf-8", "Chesspal's page answers only at its own address on this machine.");
         return;
     }
-    if (answerProfiles(request, response, url, served) || answerGame(request, response, url, served) || answerAnalyses(request, response, url, served)) {
+    // A probe is no use of the table: a chat on its own page looks for it after each tool, and the hooks look for theirs.
+    if (!(path === "/api/bell" && url.searchParams.has("probe"))) {
+        served.table?.used();
+    }
+    const answered = answerProfiles(request, response, url, served) || answerGame(request, response, url, served) || answerAnalyses(request, response, url, served)
+        || answerChat(request, response, url, served) || answerTable(request, response, url, served);
+    if (answered) {
         return;
     }
     // The API answers GET alone: a HEAD at the doorbell would wait there as a hook does.
@@ -90,11 +120,13 @@ function answer(request, response, served) {
         send(response, 200, json, JSON.stringify(analysesOf(served.context.home())));
     }
     else if (path === "/api/events") {
-        keepPosted(request, response, served);
+        keepPosted(request, response, served.watchers);
+        // A page that opens reads the player's ratings again after a day (D-106).
+        readRatingsOf(served);
     }
     else if (path === "/api/bell") {
         if (url.searchParams.has("probe")) {
-            send(response, 200, json, JSON.stringify(bellProbe(served.folder, served.watchers.size > 0)));
+            send(response, 200, json, JSON.stringify(bellProbe(served.folder, served.watchers.size > 0, tableChat(served))));
         }
         else {
             served.bell.listen(request, response);
@@ -104,12 +136,20 @@ function answer(request, response, served) {
         sendFile(response, path);
     }
 }
+/** The chat at the table, as its probe says it: none on a page a chat serves itself. */
+function tableChat(served) {
+    if (served.table === undefined) {
+        return undefined;
+    }
+    const chat = served.attached?.chat;
+    return chat === undefined ? { session: null } : { session: chat.session, chat: chat.folder };
+}
 /**
  * Whether the chat has news from the page: a game changed since the chat's last tool, by the player's move, words, draw or resignation, a new game or a
  * flag that fell, or another profile in use, which wakes the chat at the next ring (D-66). The player's words the chat was given change nothing it has not read.
  */
-function hasNews(context) {
-    return gameSeen(context) !== context.seen;
+function hasNews(context, chat) {
+    return gameSeen(context) !== chat.seen;
 }
 // The game the chat sees: the profile's folder, and the stamps of its game.json and of the talk with no game, where the player's words go in analysis
 // before any game was played here (Priya); none while the data folder cannot be made.
@@ -124,25 +164,6 @@ ${tableTalkStamp(folder) ?? ""}`;
         return "";
     }
 }
-/** A page that waits to hear the game has changed: a stream of events, one "changed" for each change, after which the page reads the game again. */
-function keepPosted(request, response, served) {
-    response.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
-    response.write(": posted\n\n");
-    served.watchers.add(response);
-    request.on("close", () => served.watchers.delete(response));
-}
-/** The pages open now open their New game window; whether there was one. */
-function askNewGame(served) {
-    for (const watcher of served.watchers) {
-        watcher.write("data: new-game\n\n");
-    }
-    return served.watchers.size > 0;
-}
-function tellWatchers(served) {
-    for (const watcher of served.watchers) {
-        watcher.write("data: changed\n\n");
-    }
-}
 /**
  * Watches the data folder, its profiles and the profile in use for changes to the game and the profiles, whoever makes them (the AI's tools, another chat,
  * the CLI, a hand edit): the pages hear of them. Each folder is watched on its own, never its whole tree, and watched again after each change, since the
@@ -161,7 +182,7 @@ function watchGame(served) {
             waiting = setTimeout(() => {
                 waiting = undefined;
                 watchAll();
-                tellWatchers(served);
+                tellWatchers(served.watchers);
             }, 30);
         }
     };
@@ -195,7 +216,7 @@ function watchFolder(folder, heard) {
 }
 // The current game, what the coach wrote on it, whether the AI thinks on the player's time, the talk before the first, the game in analysis, the profile
 // in use, and what a profile keeps (who plays, their picture, their settings); a folder's name, for a profile made or gone.
-const watched = /^(?:game\.json|coach\.json|thoughts\.json|talk\.json|analysis\.json|active\.json|profile\.md|settings\.json|avatar\.\w+|[a-z0-9-]+)$/;
+const watched = /^(?:game\.json|coach\.json|thoughts\.json|talk\.json|analysis\.json|active\.json|profile\.md|settings\.json|ratings\.json|avatar\.\w+|[a-z0-9-]+)$/;
 function fromHere(request, port, api) {
     const hosts = [`127.0.0.1:${port}`, `localhost:${port}`];
     const origin = request.headers.origin;

package/dist/server/page/profiles.d.ts

@@ -17,3 +17,8 @@ export interface ProfilesShown {
 export declare function profilesShown(root: string, userFolder?: string): ProfilesShown;
 /** Answers the page's requests about profiles: true when the request was one. A file that cannot be written is told to the page, and the server goes on. */
 export declare function answerProfiles(request: IncomingMessage, response: ServerResponse, url: URL, served: Served): boolean;
+/**
+ * Reads the ratings of a profile, the one in use unless named, again a day after the last reading, while the page goes on: the pages hear of them from the
+ * watcher (D-106).
+ */
+export declare function readRatingsOf(served: Served, id?: string): void;

package/dist/server/page/profiles.js

@@ -1,6 +1,6 @@
 import { homedir } from "node:os";
 import { isAbsolute, relative, sep } from "node:path";
-import { chooseDrawnAvatar, GameGoingOn, inputProblems, newProfile, setAccounts, useProfile } from "../../commands/index.js";
+import { chooseDrawnAvatar, editProfile, GameGoingOn, inputProblems, newProfile, ratingsAge, refreshRatings, useProfile } from "../../commands/index.js";
 import { activeProfile, drawnAvatars, imageTypes, listProfiles, ownImage, ownImageStamp, profileFolder, profileSettings, saveOwnImage, saveProfileSettings, sentImageLimit, settingsOf, } from "../../profiles/index.js";
 import { bodyOf, bytesOf, isJson, jsonOf, runRoute, send, sendJson } from "./http.js";
 /** The profiles of the data folder, as the page shows them. */
@@ -25,7 +25,7 @@ const routes = {
     "POST /api/profile/new": newProfileFromPage,
     "POST /api/profile/use": useProfileFromPage,
     "POST /api/profile/avatar": drawnAvatarFromPage,
-    "POST /api/profile/accounts": accountsFromPage,
+    "POST /api/profile/edit": editFromPage,
     "POST /api/profile/image": imageFromPage,
     "GET /api/profile/image": sendImage,
     "POST /api/settings": settingsFromPage,
@@ -48,7 +48,7 @@ async function newProfileFromPage(request, response, served) {
         sendJson(response, 409, refusalOf(error));
     }
 }
-/** Another profile put in use from the menu, once the game going on has ended: the chat is not woken for it (D-66). */
+/** Another profile put in use from the menu, once the game going on has ended: the chat is not woken for it (D-66); its ratings are read again after a day (D-106). */
 async function useProfileFromPage(request, response, served) {
     const profile = isJson(request) ? jsonOf(await bodyOf(request))?.profile : undefined;
     if (typeof profile !== "string") {
@@ -63,6 +63,7 @@ async function useProfileFromPage(request, response, served) {
         return;
     }
     sendJson(response, 200, { profile });
+    readRatingsOf(served, profile);
 }
 /** A drawn avatar for the profile the page shows, in place of the player's own image. */
 async function drawnAvatarFromPage(request, response, served, url) {
@@ -79,21 +80,24 @@ async function drawnAvatarFromPage(request, response, served, url) {
     chooseDrawnAvatar(served.context, profile.id, drawn);
     sendJson(response, 200, { avatar: drawn });
 }
-/** The player's names on Lichess and chess.com for the profile the page shows (D-93), in a game or in analysis too: they change only which side is theirs. */
-async function accountsFromPage(request, response, served, url) {
+/**
+ * What the player changes in the profile window for the profile the page shows, in a game or in analysis too: their name, how they play, their names on
+ * Lichess and chess.com (D-93), each saved once changed; the profile keeps its folder (D-106).
+ */
+async function editFromPage(request, response, served, url) {
     const body = isJson(request) ? jsonOf(await bodyOf(request)) : undefined;
-    const input = setAccounts.input.safeParse(body ?? {});
+    const input = editProfile.input.safeParse(body ?? {});
     const profile = profileInUse(served, url, response);
     if (profile === undefined) {
         return;
     }
     if (body === undefined || !input.success) {
-        const problems = input.success ? "" : ` ${inputProblems("set_accounts", input.error.issues, body ?? {}, (name) => name)}`;
-        sendJson(response, 400, { error: `Send the names as JSON, {"lichess": "…", "chesscom": "…"}.${problems}` });
+        const problems = input.success ? "" : ` ${inputProblems("edit_profile", input.error.issues, body ?? {}, (name) => name)}`;
+        sendJson(response, 400, { error: `Send the changes as JSON, {"name": "…", "level": "regular", "lichess": "…", "chesscom": "…", "fide": 1650}.${problems}` });
         return;
     }
-    const { accounts } = await setAccounts.run(input.data, served.context);
-    sendJson(response, 200, { accounts: accounts ?? {} });
+    const edited = await editProfile.run(input.data, served.context);
+    sendJson(response, 200, { profile: shown(served.context.home(), edited) });
 }
 /**
  * The player's own image for a profile, as the page made it from their photo: a PNG, JPEG or WebP of 1 MB at most. The one in use, or one just added while a
@@ -168,6 +172,18 @@ async function openDataFolder(request, response, served) {
     }
     sendJson(response, 200, { opened: true });
 }
+/**
+ * Reads the ratings of a profile, the one in use unless named, again a day after the last reading, while the page goes on: the pages hear of them from the
+ * watcher (D-106).
+ */
+export function readRatingsOf(served, id) {
+    try {
+        void refreshRatings(served.context, id ?? activeProfile(served.context.home()).id, ratingsAge).catch(() => false);
+    }
+    catch {
+        // No data folder yet: the page says why as it loads.
+    }
+}
 /**
  * The profile in use, when it is the one the page shows (?profile=): a page that has not yet heard of another put in use elsewhere is refused, so that its
  * choices never go to the wrong player.

package/dist/server/page/table.d.ts

@@ -0,0 +1,39 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Served } from "./page.ts";
+/** A host the table offers a chat in: whether it is installed, the models and efforts the player may choose, and the command to open one by hand. */
+export interface ChatHost {
+    readonly name: string;
+    readonly installed: boolean;
+    readonly models: readonly string[];
+    readonly efforts: readonly string[];
+    readonly command: string;
+}
+/**
+ * How the table opens a chat: the hosts it offers, and a terminal with one of them, whether one opened; whether `chesspal play` holds the chat of a folder,
+ * and how it is asked to start it again.
+ */
+export interface TableChats {
+    hosts(): readonly ChatHost[];
+    open(host: string): Promise<boolean>;
+    holds(folder: string): boolean;
+    relaunch(folder: string): boolean;
+}
+/** A chat opening at the table: one the page asked for, or the one started again for a new game. */
+export type Opening = "chat" | "again";
+/** What the table's page shows of its chat: whether one is at the table, the hosts it can open one in, and one opening. */
+export declare function tableShown(served: Served): {
+    table?: {
+        chat: boolean;
+        hosts: readonly ChatHost[];
+        opening?: Opening;
+    };
+};
+/** Answers the table's own routes, under /api/table/; false for any other, and for every request to a page a chat serves itself. */
+export declare function answerTable(request: IncomingMessage, response: ServerResponse, url: URL, served: Served): boolean;
+/**
+ * Whether a new game starts the chat at the table again, clean (D-57): `chesspal play` holds it, it waits for the bell, no analyst of it is at work, and it
+ * has seen a game; one that only greeted the player stays.
+ */
+export declare function chatToRelaunch(served: Served): boolean;
+/** Asks `chesspal play` to start the chat at the table again, once the new game has started: whether it was asked; the pages then show it opening. */
+export declare function relaunchChat(served: Served): boolean;

package/dist/server/page/table.js

@@ -0,0 +1,102 @@
+import { gameInAnalysis } from "../../games/index.js";
+import { gameFolder } from "../../profiles/index.js";
+import { tellWatchers } from "./events.js";
+import { bodyOf, isJson, jsonOf, runRoute, sendJson } from "./http.js";
+/** What the table's page shows of its chat: whether one is at the table, the hosts it can open one in, and one opening. */
+export function tableShown(served) {
+    const { table } = served;
+    if (table === undefined) {
+        return {};
+    }
+    const now = opening(served);
+    return { table: { chat: served.attached !== undefined, hosts: table.chats?.hosts() ?? [], ...(now === undefined ? {} : { opening: now }) } };
+}
+/** Answers the table's own routes, under /api/table/; false for any other, and for every request to a page a chat serves itself. */
+export function answerTable(request, response, url, served) {
+    const path = url.pathname;
+    if (served.table === undefined || request.method !== "POST" || !path.startsWith("/api/table/") || !isJson(request)) {
+        return false;
+    }
+    if (path === "/api/table/quit") {
+        // Another Chesspal version asks the table to quit, to start its own in its place.
+        sendJson(response, 200, { quitting: true });
+        served.table.quit();
+    }
+    else if (path === "/api/table/chat") {
+        runRoute(response, () => openChat(request, response, served));
+    }
+    else {
+        sendJson(response, 404, { error: `${path} is no route of the table's: it answers POST /api/table/chat and /api/table/quit.` });
+    }
+    return true;
+}
+/**
+ * Whether a new game starts the chat at the table again, clean (D-57): `chesspal play` holds it, it waits for the bell, no analyst of it is at work, and it
+ * has seen a game; one that only greeted the player stays.
+ */
+export function chatToRelaunch(served) {
+    const { attached, bell } = served;
+    const stopped = bell.listening && !bell.inTurn;
+    const analysing = gameInAnalysis(gameFolder(served.context.home()))?.analyst !== undefined;
+    return attached !== undefined && stopped && !analysing && served.chat.positionSeen?.started !== undefined && served.table?.chats?.holds(attached.chat.folder) === true;
+}
+/** Asks `chesspal play` to start the chat at the table again, once the new game has started: whether it was asked; the pages then show it opening. */
+export function relaunchChat(served) {
+    const folder = served.attached?.chat.folder;
+    if (folder === undefined || served.table?.chats?.relaunch(folder) !== true) {
+        return false;
+    }
+    noteOpening(served, "again");
+    return true;
+}
+// A terminal takes a few seconds to open and its chat to attach: a second click meanwhile would open a second chat, which serves a page of its own.
+const openingFor = 30_000;
+/**
+ * Opens a chat in a terminal, asked by the table's own page alone, which a browser marks with its origin: never while a chat is at the table, or one is
+ * opening. Whether it opened; else the page shows the command to type.
+ */
+async function openChat(request, response, served) {
+    const host = jsonOf(await bodyOf(request))?.host;
+    const offered = served.table?.chats?.hosts().find((one) => one.name === host && one.installed);
+    if (request.headers.origin !== `http://127.0.0.1:${served.port}` && request.headers.origin !== `http://localhost:${served.port}`) {
+        sendJson(response, 403, { error: "Only the table's own page opens a chat." });
+    }
+    else if (offered === undefined || served.table?.chats === undefined) {
+        sendJson(response, 400, { error: `Name a host the table offers and this computer has: ${served.table?.chats?.hosts().filter((one) => one.installed).map((one) => one.name).join(", ") || "none"}.` });
+    }
+    else if (served.attached !== undefined || opening(served) !== undefined) {
+        sendJson(response, 409, { error: "A chat is at the table, or opening: play there." });
+    }
+    else {
+        const opened = noteOpening(served, "chat");
+        const started = await served.table.chats.open(offered.name);
+        if (!started && served.chatOpened === opened) {
+            served.chatOpened = undefined;
+        }
+        sendJson(response, 200, { opened: started });
+        tellWatchers(served.watchers);
+    }
+}
+// The pages show a chat opening from now until it attaches; one that has not by then lets them open another. The opening noted.
+function noteOpening(served, how) {
+    const opened = { at: served.context.now().getTime(), how };
+    served.chatOpened = opened;
+    tellWatchers(served.watchers);
+    setTimeout(() => {
+        if (served.chatOpened === opened) {
+            tellWatchers(served.watchers);
+        }
+    }, openingFor).unref();
+    return opened;
+}
+// A chat opening, with none at the table: one noted lately, or one chesspal play holds the seat for, as at a trust prompt longer than the wait.
+function opening(served) {
+    const { attached, chatOpened, context } = served;
+    if (attached !== undefined) {
+        return undefined;
+    }
+    if (chatOpened !== undefined && context.now().getTime() - chatOpened.at < openingFor) {
+        return chatOpened.how;
+    }
+    return served.table?.chats?.holds(context.folder) === true ? "chat" : undefined;
+}

package/dist/server/table/browser.d.ts

@@ -0,0 +1,6 @@
+/** Opens an address in a window of its own, else in a tab of the default browser, without waiting for it: whether a browser started. */
+export declare function openInBrowser(url: string, platform: string): Promise<boolean>;
+/** The address of the window the table opens, marked so that the page sizes it the first time (page/layout/window.ts). */
+export declare function openedAddress(url: string): string;
+/** Chrome or Edge, where each system installs them: the first there is; none when neither is. */
+export declare function appBrowser(platform: string, env: NodeJS.ProcessEnv, exists?: (path: string) => boolean): string | undefined;

package/dist/server/table/browser.js

@@ -0,0 +1,48 @@
+// The table's page opened in the player's browser (D-104): in a window of its own, as an application, when Chrome or Edge is installed, which open one with
+// --app; else in a tab of the system's default browser.
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { posix, win32 } from "node:path";
+import { openFolder } from "../../home/index.js";
+/** Opens an address in a window of its own, else in a tab of the default browser, without waiting for it: whether a browser started. */
+export async function openInBrowser(url, platform) {
+    const browser = appBrowser(platform, process.env);
+    // Explorer, open and xdg-open take an address as they take a folder, and hand it to the default browser.
+    return (browser !== undefined && await started(browser, [`--app=${openedAddress(url)}`])) || openFolder(url, platform);
+}
+/** The address of the window the table opens, marked so that the page sizes it the first time (page/layout/window.ts). */
+export function openedAddress(url) {
+    const address = new URL(url);
+    address.searchParams.set("opened", "");
+    return address.href;
+}
+/** Chrome or Edge, where each system installs them: the first there is; none when neither is. */
+export function appBrowser(platform, env, exists = existsSync) {
+    return browserPaths(platform, env).find(exists);
+}
+// Chrome before Edge: Chrome is the one tried, and Edge may be missing even on Windows.
+function browserPaths(platform, env) {
+    if (platform === "win32") {
+        const roots = [env.ProgramFiles, env["ProgramFiles(x86)"], env.LOCALAPPDATA].filter((root) => root !== undefined && root !== "");
+        const programs = [["Google", "Chrome", "Application", "chrome.exe"], ["Microsoft", "Edge", "Application", "msedge.exe"]];
+        return programs.flatMap((program) => roots.map((root) => win32.join(root, ...program)));
+    }
+    if (platform === "darwin") {
+        const roots = ["/Applications", ...(env.HOME === undefined ? [] : [posix.join(env.HOME, "Applications")])];
+        return ["Google Chrome", "Microsoft Edge"].flatMap((name) => roots.map((root) => posix.join(root, `${name}.app`, "Contents", "MacOS", name)));
+    }
+    const folders = (env.PATH ?? "").split(":").filter((folder) => folder !== "");
+    const names = ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "microsoft-edge", "microsoft-edge-stable"];
+    return names.flatMap((name) => folders.map((folder) => posix.join(folder, name)));
+}
+// A browser started apart from this process, which it outlives: whether it started.
+function started(browser, args) {
+    return new Promise((done) => {
+        const opened = spawn(browser, args, { detached: true, stdio: "ignore" });
+        opened.once("spawn", () => {
+            opened.unref();
+            done(true);
+        });
+        opened.once("error", () => done(false));
+    });
+}

package/dist/server/table/hosts/chats.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from "../../../commands/index.ts";
+import type { TableChats } from "../../page/table.ts";
+/**
+ * The chats of a real table: the hosts installed, looked for again once a while has passed, since the player may install one with the page open; a
+ * terminal opened with `chesspal play`, run by `chesspal`, the same Node and script as the table's.
+ */
+export declare function terminalChats(context: Context, chesspal?: readonly string[], env?: NodeJS.ProcessEnv): TableChats;

package/dist/server/table/hosts/chats.js

@@ -0,0 +1,31 @@
+import { tableFolder } from "../../../home/index.js";
+import { samePath } from "../../bell.js";
+import { programPath } from "./find.js";
+import { hostChoices, hostNames, isHostName } from "./hosts.js";
+import { askAgain, seatTaken } from "./seat.js";
+import { openTerminal } from "./terminal.js";
+/**
+ * The chats of a real table: the hosts installed, looked for again once a while has passed, since the player may install one with the page open; a
+ * terminal opened with `chesspal play`, run by `chesspal`, the same Node and script as the table's.
+ */
+export function terminalChats(context, chesspal = [process.execPath, ...process.execArgv, process.argv[1] ?? ""], env = process.env) {
+    let found;
+    return {
+        hosts: () => {
+            const now = context.now().getTime();
+            if (found === undefined || now - found.at >= lookAgain) {
+                found = { hosts: hostNames.map((name) => chatHost(name, context.platform, env)), at: now };
+            }
+            return found.hosts;
+        },
+        open: async (host) => isHostName(host) && await openTerminal(tableFolder(context.home()), [...chesspal, "play", host], context.platform, env),
+        // Only a chat in the table's folder can be the one chesspal play holds.
+        holds: (folder) => samePath(folder, tableFolder(context.home())) && seatTaken(folder, context.now()),
+        relaunch: (folder) => samePath(folder, tableFolder(context.home())) && askAgain(folder, context.now()),
+    };
+}
+// Looking on the PATH takes a few milliseconds, and the page asks at every change of the game.
+const lookAgain = 10_000;
+function chatHost(name, platform, env) {
+    return { name, installed: programPath(name, platform, env) !== undefined, ...hostChoices[name], command: `chesspal play ${name}` };
+}

package/dist/server/table/hosts/find.d.ts

@@ -0,0 +1,2 @@
+/** The program's path on the PATH of `env`, the first found; none when it is not installed there. */
+export declare function programPath(name: string, platform: string, env: NodeJS.ProcessEnv, exists?: (path: string) => boolean): string | undefined;

package/dist/server/table/hosts/find.js

@@ -0,0 +1,20 @@
+// A program found on the PATH, as a shell would find it: on Windows with the extensions of PATHEXT, which npm's shims (.cmd) and installers (.exe) use.
+import { existsSync, lstatSync } from "node:fs";
+import { posix, win32 } from "node:path";
+/** The program's path on the PATH of `env`, the first found; none when it is not installed there. */
+export function programPath(name, platform, env, exists = present) {
+    const windows = platform === "win32";
+    const path = windows ? win32 : posix;
+    const folders = (env.PATH ?? env.Path ?? "").split(windows ? ";" : ":").filter((folder) => folder.trim() !== "");
+    const extensions = windows ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter((extension) => extension !== "").map((extension) => extension.toLowerCase()) : [""];
+    return folders.flatMap((folder) => extensions.map((extension) => path.join(folder.trim(), `${name}${extension}`))).find(exists);
+}
+// Windows' app execution aliases, such as wt.exe in WindowsApps, are links that stat cannot follow: existsSync calls them missing, lstat finds them.
+function present(path) {
+    try {
+        return existsSync(path) || lstatSync(path, { throwIfNoEntry: false }) !== undefined;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/server/table/hosts/hosts.d.ts

@@ -0,0 +1,34 @@
+/** The hosts the page offers, by their command's name. */
+export declare const hostNames: readonly ["claude", "codex"];
+export type HostName = typeof hostNames[number];
+/** The models and efforts the player may choose for a host, as its command line names them: aliases, which follow the host's newest models. */
+export interface HostChoices {
+    readonly models: readonly string[];
+    readonly efforts: readonly string[];
+}
+/** What the player chose for a host on the page: none of either keeps the host's own. */
+export interface HostChoice {
+    readonly model?: string | undefined;
+    readonly effort?: string | undefined;
+}
+/**
+ * Each host's choices, as tried in each (Priya): a value outside them would fail only at the chat's first turn. Claude Code's are its aliases; Codex's, the
+ * models a ChatGPT account lists, which change with its releases.
+ */
+export declare const hostChoices: Readonly<Record<HostName, HostChoices>>;
+/** Whether a word names a host the page offers. */
+export declare function isHostName(name: unknown): name is HostName;
+/** The message a chat opened by the table starts with, in the player's language: the AI answers it by calling status, as every chat does. */
+export declare function startMessage(language: string | undefined): string;
+/**
+ * The start message and the choices the host knows: first for Claude Code, whose options may take the word after; last for Codex, where "resume" is no
+ * subcommand, kept from its update screen, which an Enter would accept.
+ */
+export declare function hostArgs(host: HostName, message: string, choice?: HostChoice): string[];
+/** The settings' keys that keep a host's choice in the profile: claudeModel, claudeEffort, codexModel, codexEffort. */
+export declare function choiceKeys(host: HostName): {
+    model: string;
+    effort: string;
+};
+/** A host's choice as the profile's settings keep it: the values the host offers alone, the rest is the host's own. */
+export declare function choiceIn(settings: Readonly<Record<string, unknown>> | undefined, host: HostName): HostChoice;