chesspal 0.3.0 → 0.3.2

package/dist/server/page/page.js

@@ -8,7 +8,7 @@ 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 { Bell, bellProbe, pagePorts } from "../bell/index.js";
 import { analysesOf, answerAnalyses } from "./analyses.js";
 import { answerChat } from "./attach.js";
 import { attachedSeen, chatSeenOf, pageContext } from "./chat.js";
@@ -17,7 +17,8 @@ import { sendFile, sendHtml } from "./files.js";
 import { answerGame, chatCalls } from "./game.js";
 import { json, send } from "./http.js";
 import { answerProfiles, readRatingsOf } from "./profiles.js";
-import { answerTable } from "./table.js";
+import { answerTable, restartWhenAtRest, updateWhenAtRest } from "./table.js";
+import { watchForUpdates } from "./update.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
  * 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
@@ -33,7 +34,12 @@ export async function startPage(context, options = {}) {
         context: pageContext(context),
         chat,
         opponent: options.opponent ?? (() => aiNameOf(chat.host())),
-        bell: new Bell(() => hasNews(context, chat), () => tellWatchers(watchers)),
+        // A start again asked while the chat was at work comes once it has ended its answer (D-107), as an update installed meanwhile (D-108).
+        bell: new Bell(() => hasNews(context, chat), () => {
+            restartWhenAtRest(served);
+            updateWhenAtRest(served);
+            tellWatchers(watchers);
+        }),
         watchers,
         port: 0,
         outdated: outdatedHostFiles(folder, context.platform).length > 0,
@@ -45,7 +51,12 @@ export async function startPage(context, options = {}) {
         if (await listened(server, port)) {
             server.unref();
             served.port = portOf(server);
-            const stopWatching = watchGame(served);
+            const stopWatchingGame = watchGame(served);
+            const stopAskingNpm = watchForUpdates(served);
+            const stopWatching = () => {
+                stopWatchingGame();
+                stopAskingNpm();
+            };
             return {
                 url: `http://127.0.0.1:${served.port}/`,
                 heard: () => tellWatchers(watchers),
@@ -77,6 +88,7 @@ export function chatHasRead(context, showed) {
         catch {
             context.positionSeen = null;
         }
+        context.positionFirstSeen ??= context.positionSeen ?? undefined;
         // 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?.();
@@ -183,6 +195,8 @@ function watchGame(served) {
                 waiting = undefined;
                 watchAll();
                 tellWatchers(served.watchers);
+                // A game that has ended lets an update installed meanwhile start the table again (D-108).
+                updateWhenAtRest(served);
             }, 30);
         }
     };

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

@@ -9,31 +9,56 @@ export interface ChatHost {
     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.
+ * How the table opens a chat: the hosts it offers, and a terminal with one of them, whether one opened; the chat `chesspal play` holds in a folder, with
+ * the model and effort it started with, 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;
+    held(folder: string): HeldChat | undefined;
+    /** Asks for the chat again: with another host, or `updated`, from the Chesspal just installed (D-108). */
+    relaunch(folder: string, host?: string, updated?: boolean): 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. */
+/** The chat `chesspal play` holds: the model and effort its host started with, none for the host's own. */
+export interface HeldChat {
+    readonly model?: string | undefined;
+    readonly effort?: string | undefined;
+}
+/** A chat opening at the table: one the page asked for, the one started again for a new game, or with another model or host (D-107). */
+export type Opening = "chat" | "again" | "restart";
+/** What the table's page shows of its chat (D-104, D-107). */
+export interface TableShown {
+    /** Whether a chat is at the table, and its host among those offered, when it says one. */
+    readonly chat: boolean;
+    readonly host?: string;
+    /** Whether `chesspal play` holds the chat, which the page can then start again; one opened by hand it cannot. With the model and effort it started with. */
+    readonly held: boolean;
+    readonly started?: HeldChat;
+    readonly hosts: readonly ChatHost[];
+    readonly opening?: Opening;
+    /** A start again asked while the chat was at work, waiting for it to end its answer, or to be started at once or let go from the page. */
+    readonly waiting?: true;
+}
+/** What the table's page shows of its chat: whether one is at the table, with which host, the hosts it can open one in, and one opening. */
 export declare function tableShown(served: Served): {
-    table?: {
-        chat: boolean;
-        hosts: readonly ChatHost[];
-        opening?: Opening;
-    };
+    table?: TableShown;
 };
 /** 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.
+ * has seen a game move since it was first shown one; one that only greeted the player stays, as one opened from the chat's window before a new game.
  */
 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;
+/**
+ * Asks `chesspal play` to start the chat at the table again: once the new game has started, or with another model or host in its place (D-107). Whether
+ * it was asked; the pages then show it opening.
+ */
+export declare function relaunchChat(served: Served, how?: "again" | "restart", host?: string): boolean;
+/** Starts the chat again as the page asked while it was at work, now that it has ended its answer; a chat gone meanwhile takes the request with it. */
+export declare function restartWhenAtRest(served: Served): void;
+/**
+ * Once npm has installed the newer Chesspal (D-108), and no game goes on and the chat is at rest, as a game or a chat may have started while npm worked:
+ * the chat `chesspal play` holds starts again from it, clean, and once it has left the table, the table closes to start again from it too.
+ */
+export declare function updateWhenAtRest(served: Served): void;

package/dist/server/page/table.js

@@ -1,15 +1,29 @@
-import { gameInAnalysis } from "../../games/index.js";
+import { setTimeout as delay } from "node:timers/promises";
+import { gameAt, samePosition } from "../../commands/index.js";
+import { endOf, 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. */
+/** What the table's page shows of its chat: whether one is at the table, with which host, the hosts it can open one in, and one opening. */
 export function tableShown(served) {
-    const { table } = served;
+    const { table, attached } = served;
     if (table === undefined) {
         return {};
     }
+    const host = hostAtTable(served);
+    const held = heldChat(served);
     const now = opening(served);
-    return { table: { chat: served.attached !== undefined, hosts: table.chats?.hosts() ?? [], ...(now === undefined ? {} : { opening: now }) } };
+    return {
+        table: {
+            chat: attached !== undefined,
+            ...(host === undefined ? {} : { host }),
+            held: held !== undefined,
+            ...(held === undefined ? {} : { started: held }),
+            hosts: table.chats?.hosts() ?? [],
+            ...(now === undefined ? {} : { opening: now }),
+            ...(served.restartWanted === undefined ? {} : { waiting: true }),
+        },
+    };
 }
 /** 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) {
@@ -25,30 +39,59 @@ export function answerTable(request, response, url, served) {
     else if (path === "/api/table/chat") {
         runRoute(response, () => openChat(request, response, served));
     }
+    else if (path === "/api/table/restart") {
+        runRoute(response, () => restartChat(request, response, served));
+    }
+    else if (path === "/api/table/waiting") {
+        runRoute(response, () => endWaiting(request, response, served));
+    }
+    else if (path === "/api/table/update") {
+        runRoute(response, () => updateChesspal(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.` });
+        sendJson(response, 404, {
+            error: `${path} is no route of the table's: it answers POST /api/table/chat, /api/table/restart, /api/table/waiting, /api/table/update 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.
+ * has seen a game move since it was first shown one; one that only greeted the player stays, as one opened from the chat's window before a new game.
  */
 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;
+    const { positionSeen, positionFirstSeen } = served.chat;
+    const played = positionSeen?.started !== undefined && (positionFirstSeen === undefined || !samePosition(positionSeen, positionFirstSeen));
+    return played && heldChat(served) !== undefined && chatAtRest(served);
 }
-/** 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) {
+/**
+ * Asks `chesspal play` to start the chat at the table again: once the new game has started, or with another model or host in its place (D-107). Whether
+ * it was asked; the pages then show it opening.
+ */
+export function relaunchChat(served, how = "again", host) {
     const folder = served.attached?.chat.folder;
-    if (folder === undefined || served.table?.chats?.relaunch(folder) !== true) {
+    // Another host may first ask whether it trusts the table's folder: the pages say so, as for a chat opened.
+    const switching = how === "restart" && host !== undefined && host !== hostAtTable(served);
+    if (folder === undefined || served.table?.chats?.relaunch(folder, host) !== true) {
         return false;
     }
-    noteOpening(served, "again");
+    noteOpening(served, switching ? "chat" : how);
     return true;
 }
+/** Starts the chat again as the page asked while it was at work, now that it has ended its answer; a chat gone meanwhile takes the request with it. */
+export function restartWhenAtRest(served) {
+    const wanted = served.restartWanted;
+    if (wanted === undefined) {
+        return;
+    }
+    if (heldChat(served) === undefined) {
+        served.restartWanted = undefined;
+    }
+    else if (chatAtRest(served)) {
+        served.restartWanted = undefined;
+        relaunchChat(served, "restart", wanted.host);
+    }
+}
 // 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;
 /**
@@ -56,13 +99,12 @@ const openingFor = 30_000;
  * 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}`) {
+    const offered = hostOffered(served, jsonOf(await bodyOf(request))?.host);
+    if (!fromTablePage(request, served)) {
         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"}.` });
+        sendJson(response, 400, { error: hostsOffered(served) });
     }
     else if (served.attached !== undefined || opening(served) !== undefined) {
         sendJson(response, 409, { error: "A chat is at the table, or opening: play there." });
@@ -77,6 +119,148 @@ async function openChat(request, response, served) {
         tellWatchers(served.watchers);
     }
 }
+/**
+ * Starts the chat `chesspal play` holds again, clean, with the host the page names and the model and effort it keeps for it (D-107): at once when it is at
+ * rest, else once it has ended its answer. Asked by the table's own page alone; a chat opened by hand changes its model with /model.
+ */
+async function restartChat(request, response, served) {
+    const offered = hostOffered(served, jsonOf(await bodyOf(request))?.host);
+    if (!fromTablePage(request, served)) {
+        sendJson(response, 403, { error: "Only the table's own page starts the chat again." });
+    }
+    else if (offered === undefined) {
+        sendJson(response, 400, { error: hostsOffered(served) });
+    }
+    else if (heldChat(served) === undefined) {
+        sendJson(response, 409, { error: "No chat the table opened is at it: open one from the page, or change the model with /model in a chat opened by hand." });
+    }
+    else if (chatAtRest(served)) {
+        sendJson(response, 200, { restarting: relaunchChat(served, "restart", offered.name) });
+    }
+    else {
+        served.restartWanted = { host: offered.name };
+        tellWatchers(served.watchers);
+        sendJson(response, 200, { waiting: true });
+    }
+}
+/**
+ * Ends a start again the page asked while the chat was at work (D-107): `now` starts it at once, cutting the answer it gives, as after an Esc, when it would
+ * never end; else the request is let go. Asked by the table's own page alone.
+ */
+async function endWaiting(request, response, served) {
+    const now = jsonOf(await bodyOf(request))?.now;
+    const wanted = served.restartWanted;
+    if (!fromTablePage(request, served)) {
+        sendJson(response, 403, { error: "Only the table's own page ends a start again that waits." });
+    }
+    else if (typeof now !== "boolean") {
+        sendJson(response, 400, { error: "Say now: true to start the chat again at once, cutting its answer, or now: false to let the request go." });
+    }
+    else if (wanted === undefined) {
+        sendJson(response, 409, { error: "No start again waits: ask for one from the chat's window." });
+    }
+    else {
+        served.restartWanted = undefined;
+        const restarting = now && heldChat(served) !== undefined && relaunchChat(served, "restart", wanted.host);
+        tellWatchers(served.watchers);
+        sendJson(response, 200, now ? { restarting } : { waiting: false });
+    }
+}
+/**
+ * Once npm has installed the newer Chesspal (D-108), and no game goes on and the chat is at rest, as a game or a chat may have started while npm worked:
+ * the chat `chesspal play` holds starts again from it, clean, and once it has left the table, the table closes to start again from it too.
+ */
+export function updateWhenAtRest(served) {
+    if (served.updating !== "installed" || gameGoingOn(served) || !tableAtRest(served)) {
+        return;
+    }
+    served.updating = "restarting";
+    tellWatchers(served.watchers);
+    const relaunched = served.table?.chats?.relaunch(served.folder, undefined, true) === true;
+    void restartOnceLeft(served, relaunched);
+}
+/**
+ * Installs the newer Chesspal npm has (D-108), asked by the table's own page alone, never while a game goes on, the chat is at work or one is opening;
+ * the table then starts again from it as soon as it is at rest. Whether npm installed it; when it did not, the page gives the command to type.
+ */
+async function updateChesspal(request, response, served) {
+    await bodyOf(request);
+    const { newer, table } = served;
+    if (!fromTablePage(request, served)) {
+        sendJson(response, 403, { error: "Only the table's own page updates Chesspal." });
+    }
+    else if (newer === undefined || table?.update === undefined) {
+        sendJson(response, 409, { error: "No newer Chesspal to install: this one is the latest npm has." });
+    }
+    else if (served.updating !== undefined) {
+        sendJson(response, 409, { error: "Chesspal is being updated already: wait for the table to start again." });
+    }
+    else if (gameGoingOn(served)) {
+        sendJson(response, 409, { error: "A game is going on: finish it, then update Chesspal.", refusal: "update-game" });
+    }
+    else if (!tableAtRest(served)) {
+        sendJson(response, 409, { error: "The chat is at work, or opening: update Chesspal once it is at rest.", refusal: "update-chat" });
+    }
+    else {
+        served.updating = "installing";
+        tellWatchers(served.watchers);
+        let installed = false;
+        try {
+            installed = await table.update.install(newer);
+        }
+        finally {
+            served.updating = installed ? "installed" : undefined;
+        }
+        // Starting again ends every connection: once this answer has gone, or the page that asked has.
+        response.once("close", () => updateWhenAtRest(served));
+        tellWatchers(served.watchers);
+        sendJson(response, 200, { installed });
+    }
+}
+// The chat started again leaves the table as `chesspal play` ends its host: a table closed before would leave its server to serve its own page on the
+// table's ports, where the new table would then find them taken (Priya). One that does not leave in time is left to it.
+async function restartOnceLeft(served, relaunched) {
+    for (let tries = 0; relaunched && served.attached !== undefined && tries < leaveTries; tries++) {
+        await delay(100);
+    }
+    served.table?.update?.restart();
+}
+// `chesspal play` sees the request within half a second and ends its host in a few more.
+const leaveTries = 100;
+// A game with moves still to come, a new one too: never an update meanwhile (D-108).
+function gameGoingOn(served) {
+    const current = gameAt(gameFolder(served.context.home()), served.context.now());
+    return current !== undefined && endOf(current.game) === undefined;
+}
+// No chat is at work at the table, and none is opening.
+function tableAtRest(served) {
+    return (served.attached === undefined || chatAtRest(served)) && opening(served) === undefined;
+}
+// The browser marks a request of the table's own page with its origin.
+function fromTablePage(request, served) {
+    return request.headers.origin === `http://127.0.0.1:${served.port}` || request.headers.origin === `http://localhost:${served.port}`;
+}
+function hostOffered(served, host) {
+    return served.table?.chats?.hosts().find((one) => one.name === host && one.installed);
+}
+function hostsOffered(served) {
+    return `Name a host the table offers and this computer has: ${served.table?.chats?.hosts().filter((one) => one.installed).map((one) => one.name).join(", ") || "none"}.`;
+}
+// The host of the chat at the table, among those offered: it says its name as its MCP client does, «claude-code» or «codex-mcp-client».
+function hostAtTable(served) {
+    const said = served.chat.host()?.toLowerCase() ?? "";
+    return served.attached === undefined ? undefined : served.table?.chats?.hosts().find((one) => said.includes(one.name))?.name;
+}
+// The chat at the table when `chesspal play` holds it, which the table can start again: the model and effort it started with.
+function heldChat(served) {
+    const { attached } = served;
+    return attached === undefined ? undefined : served.table?.chats?.held(attached.chat.folder);
+}
+// The chat waits for the doorbell, out of a turn, and no analyst of it is at work: starting it again loses nothing.
+function chatAtRest(served) {
+    const { bell } = served;
+    return bell.listening && !bell.inTurn && gameInAnalysis(gameFolder(served.context.home()))?.analyst === undefined;
+}
 // 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 };
@@ -98,5 +282,5 @@ function opening(served) {
     if (chatOpened !== undefined && context.now().getTime() - chatOpened.at < openingFor) {
         return chatOpened.how;
     }
-    return served.table?.chats?.holds(context.folder) === true ? "chat" : undefined;
+    return served.table?.chats?.held(context.folder) === undefined ? undefined : "chat";
 }

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

@@ -0,0 +1,18 @@
+import type { Served } from "./page.ts";
+/**
+ * What the page shows of a newer Chesspal: its version, and on the table whether it is being installed, or installed and waiting for the game to end and
+ * the chat to be at rest.
+ */
+export interface UpdateShown {
+    readonly version: string;
+    readonly installing?: true;
+    readonly installed?: true;
+}
+/** Asks npm for Chesspal's latest version now and once a day after, the pages told when it is newer than this one; how to stop. None in the tests. */
+export declare function watchForUpdates(served: Served, every?: number): () => void;
+/** The newer Chesspal the page shows, when npm has one. */
+export declare function updateShown(served: Served): {
+    update?: UpdateShown;
+};
+/** Chesspal's latest version on npm, none when npm cannot be reached in time or answers something else. */
+export declare function latestVersion(fetch: typeof globalThis.fetch): Promise<string | undefined>;

package/dist/server/page/update.js

@@ -0,0 +1,40 @@
+// A newer Chesspal on npm (D-108): the page's server asks as it starts and once a day after; the table's page offers to install it, a chat's own page says
+// the command to type.
+import { answerTime, askSite } from "../../sites/index.js";
+import { isOlder, version } from "../../version.js";
+import { tellWatchers } from "./events.js";
+/** Asks npm for Chesspal's latest version now and once a day after, the pages told when it is newer than this one; how to stop. None in the tests. */
+export function watchForUpdates(served, every = aDay) {
+    const fetch = served.context.fetch;
+    if (fetch === undefined) {
+        return () => undefined;
+    }
+    const ask = async () => {
+        const latest = await latestVersion(fetch);
+        if (latest !== undefined && isOlder(version, latest) && latest !== served.newer) {
+            served.newer = latest;
+            tellWatchers(served.watchers);
+        }
+    };
+    void ask();
+    const timer = setInterval(() => void ask(), every);
+    timer.unref();
+    return () => clearInterval(timer);
+}
+/** The newer Chesspal the page shows, when npm has one. */
+export function updateShown(served) {
+    const { newer, updating } = served;
+    if (newer === undefined) {
+        return {};
+    }
+    return { update: { version: newer, ...(updating === "installed" ? { installed: true } : updating === undefined ? {} : { installing: true }) } };
+}
+/** Chesspal's latest version on npm, none when npm cannot be reached in time or answers something else. */
+export async function latestVersion(fetch) {
+    const answer = await askSite(latestUrl, fetch, AbortSignal.timeout(answerTime));
+    const said = answer?.body?.version;
+    // Only a plain release: the version goes into npm's command line.
+    return answer?.status === 200 && typeof said === "string" && /^\d+\.\d+\.\d+$/.test(said) ? said : undefined;
+}
+const latestUrl = "https://registry.npmjs.org/chesspal/latest";
+const aDay = 24 * 60 * 60 * 1000;

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

@@ -1,6 +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). */
+/** The address of the window the table opens, marked so that the page sizes it as it opens (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

@@ -10,7 +10,7 @@ export async function openInBrowser(url, platform) {
     // 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). */
+/** The address of the window the table opens, marked so that the page sizes it as it opens (page/layout/window.ts). */
 export function openedAddress(url) {
     const address = new URL(url);
     address.searchParams.set("opened", "");

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

@@ -1,5 +1,5 @@
 import type { Context } from "../../../commands/index.ts";
-import type { TableChats } from "../../page/table.ts";
+import type { TableChats } from "../../page/index.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.

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

@@ -1,8 +1,8 @@
 import { tableFolder } from "../../../home/index.js";
-import { samePath } from "../../bell.js";
+import { samePath } from "../../bell/index.js";
 import { programPath } from "./find.js";
 import { hostChoices, hostNames, isHostName } from "./hosts.js";
-import { askAgain, seatTaken } from "./seat.js";
+import { askAgain, seatHeld } 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
@@ -20,8 +20,11 @@ export function terminalChats(context, chesspal = [process.execPath, ...process.
         },
         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()),
+        held: (folder) => {
+            const seat = samePath(folder, tableFolder(context.home())) ? seatHeld(folder, context.now()) : undefined;
+            return seat === undefined ? undefined : { model: seat.model, effort: seat.effort };
+        },
+        relaunch: (folder, host, updated) => samePath(folder, tableFolder(context.home())) && askAgain(folder, context.now(), { ...(host === undefined ? {} : { host }), ...(updated === true ? { updated } : {}) }),
     };
 }
 // Looking on the PATH takes a few milliseconds, and the page asks at every change of the game.

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

@@ -1,3 +1,3 @@
 export { terminalChats } from "./chats.ts";
 export { isHostName } from "./hosts.ts";
-export { hostLaunch, playHost } from "./play.ts";
+export { endTree, hostLaunch, playHost } from "./play.ts";

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

@@ -1,4 +1,4 @@
 // The AI hosts a table opens a chat in (D-104): their choices, the terminal they open in, and `chesspal play`, which starts one there.
 export { terminalChats } from "./chats.js";
 export { isHostName } from "./hosts.js";
-export { hostLaunch, playHost } from "./play.js";
+export { endTree, hostLaunch, playHost } from "./play.js";

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

@@ -1,16 +1,22 @@
+import { type ChildProcess } from "node:child_process";
 import type { Context } from "../../../commands/index.ts";
-import { type HostName } from "./hosts.ts";
-/** What `chesspal play` starts: the host's program, its arguments, folder and environment, and whether it needs cmd, as a .cmd shim does on Windows. */
+import { type HostChoice, type HostName } from "./hosts.ts";
+/**
+ * What `chesspal play` starts: the host's program, its arguments, folder and environment, whether it needs cmd, as a .cmd shim does on Windows, and the
+ * model and effort it is given, which the seat notes for the page (D-107).
+ */
 export interface HostLaunch {
     readonly program: string;
     readonly args: readonly string[];
     readonly folder: string;
     readonly env: NodeJS.ProcessEnv;
     readonly shell: boolean;
+    readonly choice: HostChoice;
 }
 /**
- * Runs the host in the table's folder, in this terminal, until it ends: its exit code; started again, clean, when the table asks for a new game (D-57).
- * Ctrl+C is the host's: this process ignores it, or the terminal would close with the chat.
+ * Runs the host in the table's folder, in this terminal, until it ends: its exit code; started again, clean, when the table asks for a new game (D-57),
+ * or for another model or host, which then takes its place (D-107); after an update, by the Chesspal installed (D-108). Ctrl+C is the host's: this
+ * process ignores it, or the terminal would close with the chat.
  */
 export declare function playHost(context: Context, host: HostName): Promise<number>;
 /**
@@ -23,3 +29,8 @@ export declare function runHost(launch: HostLaunch, again: () => boolean, platfo
 }>;
 /** How the host starts for the profile in use: found on the PATH, with its choice; it throws, saying how to install it, when it is not there. */
 export declare function hostLaunch(context: Context, host: HostName, env?: NodeJS.ProcessEnv, exists?: (path: string) => boolean): HostLaunch;
+/**
+ * Ends a process and what it started, a host's MCP server among them: on Windows its whole tree, which taskkill ends, never the console (Priya); else the
+ * process, which ends its own. A taskkill that failed leaves it to a kill.
+ */
+export declare function endTree(chat: ChildProcess, platform: string): void;