chesspal 0.3.1 → 0.3.3

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

@@ -12,7 +12,8 @@ import { askedAgain, leaveSeat, refreshSeat, seatTimes, takeSeat } from "./seat.
 import { cmdQuoted } from "./terminal.js";
 /**
  * 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). Ctrl+C is the host's: this process ignores it, or the terminal would close with the chat.
+ * 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 async function playHost(context, host) {
     const folder = tableFolder(context.home());
@@ -29,6 +30,8 @@ export async function playHost(context, host) {
     // The host before one asked in its place, until that one has started: it goes on when the other does not start.
     let before;
     let refreshed = Date.now();
+    // Chesspal was updated under this process (D-108): the new one plays on.
+    let updated = false;
     const asked = () => {
         if (Date.now() - refreshed >= seatTimes.refresh) {
             refreshed = Date.now();
@@ -36,6 +39,7 @@ export async function playHost(context, host) {
         }
         const again = askedAgain(folder, process.pid);
         next = again?.host !== undefined && isHostName(again.host) ? again.host : playing;
+        updated ||= again?.updated === true;
         return again !== undefined;
     };
     try {
@@ -58,6 +62,12 @@ export async function playHost(context, host) {
             if (!ran.again) {
                 return ran.code;
             }
+            if (updated) {
+                terminal.restore();
+                process.stdout.write(cleanScreen);
+                leaveSeat(folder, process.pid);
+                return await playUpdated(playing);
+            }
             if (next !== playing) {
                 before = playing;
                 playing = next;
@@ -131,14 +141,40 @@ async function started(context, host, again) {
         throw new Error(`${hostTitle[host]} did not start: ${error.message}`);
     });
 }
+// The Chesspal just installed plays on in this terminal, in a process of its own with all its files new (D-108), which takes the seat; this one, with
+// the code it started with, waits for it to end.
+function playUpdated(host) {
+    return new Promise((done) => {
+        const startedAt = Date.now();
+        const play = spawn(process.execPath, [...process.execArgv, process.argv[1] ?? "", "play", host], { stdio: "inherit" });
+        const failed = (why) => {
+            process.stderr.write(`Chesspal did not start again after its update (${why}): run chesspal play ${host}.\n`);
+        };
+        play.once("error", (error) => {
+            failed(error.message);
+            done(1);
+        });
+        // One that ended at once, failing, never showed its host: the player is told how to start it (Priya).
+        play.once("exit", (code) => {
+            if (code !== 0 && Date.now() - startedAt < quickExit) {
+                failed(`exit code ${code ?? "none"}`);
+            }
+            done(code ?? 1);
+        });
+    });
+}
 // A host that has not ended this long after it was asked is killed.
 const killAfter = 3_000;
+// A play process that ends sooner never got to its host.
+const quickExit = 10_000;
 // A host ended in the middle leaves the modes it set: colours, scroll region, synchronized output, bracketed paste, focus and mouse reports, kitty's
 // keyboard flags, its own screen, a hidden cursor (Priya). All off, and the screen cleared, as a new chat.
 const cleanScreen = "\x1b[0m\x1b[r\x1b[?2026l\x1b[?2004l\x1b[?1004l\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[<99u\x1b[?1049l\x1b[?25h\x1b[2J\x1b[3J\x1b[H";
-// The host and what it started, its MCP server among them: on Windows its whole tree, which taskkill ends, never the console (Priya); else the host,
-// which ends its own. A taskkill that failed leaves it to the kill that follows.
-function endTree(chat, platform) {
+/**
+ * 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 function endTree(chat, platform) {
     if (platform !== "win32" || chat.pid === undefined) {
         chat.kill("SIGTERM");
         return;

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

@@ -20,9 +20,13 @@ export declare function seatTaken(folder: string, now?: Date): boolean;
 export declare function seatHeld(folder: string, now?: Date): Seat | undefined;
 /** Asks the play process in the seat to start its host again, or `again.host` in its place: whether one holds it, and was asked. */
 export declare function askAgain(folder: string, now?: Date, again?: Again): boolean;
-/** What the table asks the play process in the seat: to start its host again, or the host named in its place (D-107). */
+/**
+ * What the table asks the play process in the seat: to start its host again, or the host named in its place (D-107); `updated`, from the Chesspal just
+ * installed, whose `chesspal play` then takes the seat (D-108).
+ */
 export interface Again {
     readonly host?: string;
+    readonly updated?: true;
 }
 /** What the table asked this play process, when it asked it to start its host again; the request is taken. */
 export declare function askedAgain(folder: string, pid: number): Again | undefined;

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

@@ -56,7 +56,7 @@ export function askedAgain(folder, pid) {
         return undefined;
     }
     rmSync(join(folder, againFile), { force: true });
-    return typeof asked.host === "string" ? { host: asked.host } : {};
+    return { ...(typeof asked.host === "string" ? { host: asked.host } : {}), ...(asked.updated === true ? { updated: true } : {}) };
 }
 /** How often a play process refreshes its seat, and how long the seat stays held without it. */
 export const seatTimes = { refresh: 5_000, heldFor: 15_000 };

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

@@ -1,6 +1,7 @@
 export { appBrowser, openedAddress } from "./browser.ts";
 export { hostLaunch, isHostName, playHost, terminalChats } from "./hosts/index.ts";
 export { iconAsked, type IconCommand, iconCommand, type IconPlaces, iconToRemake, makeIcons, noteIconAsked, noteIconMade } from "./icon/index.ts";
-export { noteOpenFailed, openTable, processLauncher, type TableLauncher } from "./launch.ts";
+export { noteFailure, openTable, processLauncher, type TableLauncher } from "./launch.ts";
 export { attachTable, tableToJoin } from "./link.ts";
-export { isOlder, startTable, type Table, type TableTimes, tableTimes } from "./table.ts";
+export { startTable, type Table, type TableTimes, tableTimes } from "./table.ts";
+export { npmInstall, npmUpdater, type TableUpdater } from "./update.ts";

package/dist/server/table/index.js

@@ -2,6 +2,7 @@
 export { appBrowser, openedAddress } from "./browser.js";
 export { hostLaunch, isHostName, playHost, terminalChats } from "./hosts/index.js";
 export { iconAsked, iconCommand, iconToRemake, makeIcons, noteIconAsked, noteIconMade } from "./icon/index.js";
-export { noteOpenFailed, openTable, processLauncher } from "./launch.js";
+export { noteFailure, openTable, processLauncher } from "./launch.js";
 export { attachTable, tableToJoin } from "./link.js";
-export { isOlder, startTable, tableTimes } from "./table.js";
+export { startTable, tableTimes } from "./table.js";
+export { npmInstall, npmUpdater } from "./update.js";

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

@@ -13,7 +13,10 @@ export interface TableLauncher {
  * within ten seconds throws.
  */
 export declare function openTable(context: Context, launcher?: TableLauncher): Promise<string>;
-/** Notes why the icon could not open the table, whose console nobody sees, in open.log of the table's folder: the last of them. */
-export declare function noteOpenFailed(context: Context, message: string): void;
+/**
+ * Notes what went wrong where nobody reads a console, in a log of the table's folder, the last time alone: open.log, why the icon could not open the table;
+ * update.log, why npm did not update Chesspal (D-108).
+ */
+export declare function noteFailure(context: Context, log: "open.log" | "update.log", message: string): void;
 /** The launcher of a real `chesspal`: the table started with the same Node and script, the page opened in the default browser. */
 export declare function processLauncher(platform: string, command?: string[]): TableLauncher;

package/dist/server/table/launch.js

@@ -39,12 +39,15 @@ export async function openTable(context, launcher = processLauncher(context.plat
         await launcher.wait(every);
     }
 }
-/** Notes why the icon could not open the table, whose console nobody sees, in open.log of the table's folder: the last of them. */
-export function noteOpenFailed(context, message) {
+/**
+ * Notes what went wrong where nobody reads a console, in a log of the table's folder, the last time alone: open.log, why the icon could not open the table;
+ * update.log, why npm did not update Chesspal (D-108).
+ */
+export function noteFailure(context, log, message) {
     try {
         const folder = tableFolder(context.home());
         mkdirSync(folder, { recursive: true });
-        writeFileSync(join(folder, "open.log"), `${context.now().toISOString()} ${message}\n`);
+        writeFileSync(join(folder, log), `${context.now().toISOString()} ${message}\n`);
     }
     catch {
         // A data folder that cannot be written has no other place for it.

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

@@ -1,5 +1,5 @@
 import type { Context } from "../../commands/index.ts";
-import type { Page } from "../page/page.ts";
+import { type Page } from "../page/index.ts";
 /**
  * Attaches the chat to the table of its data folder, when one of its version answers and no other chat is at it: the page the chat then uses, whose `lost`
  * is told once the table is gone or no longer knows the chat. An older table is asked to quit; with none, a newer one or another chat at it, none, and

package/dist/server/table/link.js

@@ -5,9 +5,9 @@ import { aiHostOf, aiModelOf } from "../../games/index.js";
 import { tableFolder } from "../../home/index.js";
 import { outdatedHostFiles } from "../../host-files/index.js";
 import { gameFolder } from "../../profiles/index.js";
-import { version } from "../../version.js";
-import { jsonOf } from "../page/http.js";
-import { askToQuit, isOlder, tableAt } from "./table.js";
+import { isOlder, version } from "../../version.js";
+import { jsonOf } from "../page/index.js";
+import { askToQuit, tableAt } from "./table.js";
 /**
  * Attaches the chat to the table of its data folder, when one of its version answers and no other chat is at it: the page the chat then uses, whose `lost`
  * is told once the table is gone or no longer knows the chat. An older table is asked to quit; with none, a newer one or another chat at it, none, and

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

@@ -1,5 +1,6 @@
 import type { Context } from "../../commands/index.ts";
-import type { TableChats } from "../page/table.ts";
+import { type TableChats } from "../page/index.ts";
+import type { TableUpdater } from "./update.ts";
 /** A table served: its address, and how to close it. */
 export interface Table {
     readonly url: string;
@@ -24,12 +25,10 @@ export interface TableFound {
 /**
  * Starts the table on the context's data folder, its folder set up as init does, its page opening chats through `chats`: undefined when another table
  * started at the same time took a lower port, since a table's ports are its lock. It closes once no page has been open, no chat attached and no request
- * come, for `times.idle`.
+ * come, for `times.idle`; with `updater`, its page updates Chesspal, and a new table starts from it once this one has closed (D-108).
  */
-export declare function startTable(context: Context, times?: TableTimes, chats?: TableChats): Promise<Table | undefined>;
+export declare function startTable(context: Context, times?: TableTimes, chats?: TableChats, updater?: TableUpdater): Promise<Table | undefined>;
 /** The table of a folder that answers on its ports, the lowest of them; its ports are asked together. */
 export declare function tableAt(folder: string): Promise<TableFound | undefined>;
 /** Asks the table at a port to quit; it answers before it goes, and a table that cannot be reached, or does not answer within a second or so, is let be. */
 export declare function askToQuit(port: number): Promise<void>;
-/** Whether a version is older than another, part by part: 0.2.4 is older than 0.10.0. */
-export declare function isOlder(one: string, other: string): boolean;

package/dist/server/table/table.js

@@ -3,16 +3,16 @@
 import { request } from "node:http";
 import { tableFolder } from "../../home/index.js";
 import { setUpHosts } from "../../host-files/index.js";
-import { pageAt, pagePorts, samePath } from "../bell.js";
-import { startPage } from "../page/page.js";
+import { pageAt, pagePorts, samePath } from "../bell/index.js";
+import { startPage } from "../page/index.js";
 /** Five minutes with no browser and no chat, looked at every fifteen seconds (D-104). */
 export const tableTimes = { idle: 5 * 60_000, every: 15_000 };
 /**
  * Starts the table on the context's data folder, its folder set up as init does, its page opening chats through `chats`: undefined when another table
  * started at the same time took a lower port, since a table's ports are its lock. It closes once no page has been open, no chat attached and no request
- * come, for `times.idle`.
+ * come, for `times.idle`; with `updater`, its page updates Chesspal, and a new table starts from it once this one has closed (D-108).
  */
-export async function startTable(context, times = tableTimes, chats) {
+export async function startTable(context, times = tableTimes, chats, updater) {
     const folder = tableFolder(context.home());
     setUpHosts(folder, context.platform);
     let quit = () => undefined;
@@ -20,10 +20,16 @@ export async function startTable(context, times = tableTimes, chats) {
         quit = done;
     });
     let lastUsed = context.now().getTime();
+    let startAgain = false;
     const used = () => {
         lastUsed = context.now().getTime();
     };
-    const page = await startPage({ ...context, folder }, { table: { used, quit, chats } });
+    const restart = () => {
+        startAgain = true;
+        quit();
+    };
+    const update = updater === undefined ? undefined : { install: (version) => updater.install(version), restart };
+    const page = await startPage({ ...context, folder }, { table: { used, quit, chats, update } });
     if (await lostTo(page.url, folder)) {
         await page.close();
         return undefined;
@@ -31,7 +37,11 @@ export async function startTable(context, times = tableTimes, chats) {
     const watch = closeWhenIdle(page, () => context.now().getTime() - lastUsed, used, times, quit);
     const closed = quitting.then(async () => {
         clearInterval(watch);
+        // Its ports free, the new table takes the first of them, where the pages open look for it.
         await page.close();
+        if (startAgain) {
+            updater?.startAgain();
+        }
     });
     return {
         url: page.url,
@@ -64,13 +74,6 @@ export function askToQuit(port) {
 }
 // A table answers at once: one stuck must not hold the chat's first tool, nor `chesspal`.
 const quitWait = 1_500;
-/** Whether a version is older than another, part by part: 0.2.4 is older than 0.10.0. */
-export function isOlder(one, other) {
-    const parts = (version) => version.split(/[.+-]/).slice(0, 3).map((part) => Number.parseInt(part, 10) || 0);
-    const [mine, theirs] = [parts(one), parts(other)];
-    const differs = mine.findIndex((part, index) => part !== theirs[index]);
-    return differs !== -1 && mine[differs] < theirs[differs];
-}
 /** Whether a table of the same folder answers on a lower port than this one's: the other won, and this one goes. */
 async function lostTo(url, folder) {
     const port = Number(new URL(url).port);

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

@@ -0,0 +1,17 @@
+import type { Context } from "../../commands/index.ts";
+import { type TableLauncher } from "./launch.ts";
+/** How a table updates Chesspal: npm installs a version, whether it did, and once the table has closed a new one starts from it. */
+export interface TableUpdater {
+    install(version: string): Promise<boolean>;
+    startAgain(): void;
+}
+/**
+ * A real table's updater: npm on the PATH, and `chesspal table` started apart, as `chesspal` starts it. A Chesspal npm did not install, run from its
+ * source or linked to it, npm leaves alone: it would put another in its place for the whole computer.
+ */
+export declare function npmUpdater(context: Context, launcher?: TableLauncher): TableUpdater;
+/**
+ * Installs a version of Chesspal for the whole computer with the npm on the PATH: whether it is now the one on disk where this one runs from, which an npm
+ * of another Node does not reach. What npm said when it failed goes in update.log of the table's folder.
+ */
+export declare function npmInstall(context: Context, onDisk?: () => string, env?: NodeJS.ProcessEnv): (version: string) => Promise<boolean>;

package/dist/server/table/update.js

@@ -0,0 +1,77 @@
+// The table updates Chesspal (D-108): the npm on the PATH installs the version, as the player would type it, and a new table starts from it once this one
+// has closed; what npm said when it failed goes in update.log of the table's folder.
+import { spawn } from "node:child_process";
+import { basename, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { installedVersion } from "../../version.js";
+import { endTree } from "./hosts/index.js";
+import { noteFailure, processLauncher } from "./launch.js";
+/**
+ * A real table's updater: npm on the PATH, and `chesspal table` started apart, as `chesspal` starts it. A Chesspal npm did not install, run from its
+ * source or linked to it, npm leaves alone: it would put another in its place for the whole computer.
+ */
+export function npmUpdater(context, launcher = processLauncher(context.platform)) {
+    const root = fileURLToPath(new URL("../../../", import.meta.url));
+    const fromNpm = basename(root) === "chesspal" && basename(dirname(root)) === "node_modules";
+    const install = fromNpm ? npmInstall(context) : () => {
+        noteFailure(context, "update.log", `Chesspal runs from ${root}, which npm did not install: update it the way it was installed.`);
+        return Promise.resolve(false);
+    };
+    return { install, startAgain: () => launcher.start(context.home()) };
+}
+/**
+ * Installs a version of Chesspal for the whole computer with the npm on the PATH: whether it is now the one on disk where this one runs from, which an npm
+ * of another Node does not reach. What npm said when it failed goes in update.log of the table's folder.
+ */
+export function npmInstall(context, onDisk = installedVersion, env = process.env) {
+    const { platform } = context;
+    return (version) => new Promise((done) => {
+        // A plain release alone: on Windows the version goes through cmd.
+        if (!/^\d+\.\d+\.\d+$/.test(version)) {
+            done(false);
+            return;
+        }
+        const words = ["install", "--global", `chesspal@${version}`];
+        // cmd would look for npm in the table's folder first, where anything may lie (Federico).
+        const options = { stdio: ["ignore", "ignore", "pipe"], windowsHide: true, env: { ...env, NoDefaultCurrentDirectoryInExePath: "1" } };
+        // npm is a .cmd shim on Windows, which only cmd runs.
+        const npm = platform === "win32" ? spawn(`npm ${words.join(" ")}`, { ...options, shell: true }) : spawn("npm", words, options);
+        let said = "";
+        let settled = false;
+        const end = (installed, why) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            if (!installed) {
+                noteFailure(context, "update.log", `npm ${words.join(" ")}: ${why}\n${said}`);
+            }
+            done(installed);
+        };
+        // On Windows killing cmd leaves npm running under it: its whole tree goes (Federico).
+        const timer = setTimeout(() => {
+            endTree(npm, platform);
+            end(false, `no answer in ${installWait / 60_000} minutes`);
+        }, installWait);
+        npm.stderr.on("data", (chunk) => {
+            said = (said + chunk.toString()).slice(-logLength);
+        });
+        npm.once("error", (error) => end(false, error.message));
+        npm.once("close", (code) => {
+            const now = code === 0 ? versionOnDisk(onDisk) : undefined;
+            end(now === version, code === 0 ? `Chesspal ${now ?? "unreadable"} is on disk where this table runs from` : `exit code ${code ?? "none"}`);
+        });
+    });
+}
+// npm downloads and installs in a few seconds, or a minute on a slow line; one that takes longer is stuck.
+const installWait = 5 * 60_000;
+const logLength = 4000;
+function versionOnDisk(onDisk) {
+    try {
+        return onDisk();
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/sites/index.d.ts

@@ -1,2 +1,2 @@
-export { type Fetch } from "./request.ts";
+export { answerTime, askSite, type Fetch } from "./request.ts";
 export { readingsStale, readSites } from "./sites.ts";

package/dist/sites/index.js

@@ -1,4 +1,4 @@
 // The sites the player plays on (D-24, D-105): their public ratings on Lichess and chess.com, read from the names in their profile, without a key. Below
-// the commands, beside the profiles, whose types it fills; never asked by a tool of the AI's (D-106).
-export {} from "./request.js";
+// the commands, beside the profiles, whose types it fills; never asked by a tool of the AI's (D-106). Its request asks npm too, for a newer Chesspal (D-108).
+export { answerTime, askSite } from "./request.js";
 export { readingsStale, readSites } from "./sites.js";

package/dist/version.d.ts

@@ -1,2 +1,6 @@
 /** The version of the package that runs, read from its package.json: one folder above both src/ and dist/, so this module stays at their root. */
 export declare const version: string;
+/** The version of the package on disk now, which an update installs under the one that runs (D-108). */
+export declare function installedVersion(): string;
+/** Whether a version is older than another, part by part: 0.2.4 is older than 0.10.0. */
+export declare function isOlder(one: string, other: string): boolean;

package/dist/version.js

@@ -1,3 +1,14 @@
 import { readFileSync } from "node:fs";
 /** The version of the package that runs, read from its package.json: one folder above both src/ and dist/, so this module stays at their root. */
-export const version = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+export const version = installedVersion();
+/** The version of the package on disk now, which an update installs under the one that runs (D-108). */
+export function installedVersion() {
+    return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+}
+/** Whether a version is older than another, part by part: 0.2.4 is older than 0.10.0. */
+export function isOlder(one, other) {
+    const parts = (version) => version.split(/[.+-]/).slice(0, 3).map((part) => Number.parseInt(part, 10) || 0);
+    const [mine, theirs] = [parts(one), parts(other)];
+    const differs = mine.findIndex((part, index) => part !== theirs[index]);
+    return differs !== -1 && mine[differs] < theirs[differs];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chesspal",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Play chess against an AI with a character, and learn with an AI coach: Chesspal keeps the rules, the board, the games and the memory; the AI plays, reasons and talks.",
   "type": "module",
   "bin": {