chesspal 0.3.5 → 0.4.0

package/dist/server/table/launch.js

@@ -7,11 +7,11 @@ import { speaksItalian } from "../../commands/index.js";
 import { tableFolder } from "../../home/index.js";
 import { version } from "../../version.js";
 import { openInBrowser } from "./browser.js";
-import { askToQuit, tableAt } from "./table.js";
+import { askToOpen, askToQuit, askToRelease, tableAt } from "./table.js";
 /**
  * Opens the table's page in the browser, the table started first when none answers, or when the one that does is of another version, which is asked to
- * quit; a table of this version another `chesspal` started meanwhile is as good. What to tell the player, in their language; a table that does not start
- * within ten seconds throws.
+ * quit; a table of this version another `chesspal` started meanwhile is as good. The window opened last stays, the table's older ones close, and none opens
+ * while another is opening (D-104). What to tell the player, in their language; a table that does not start within ten seconds throws.
  */
 export async function openTable(context, launcher = processLauncher(context.platform)) {
     const home = context.home();
@@ -23,7 +23,7 @@ export async function openTable(context, launcher = processLauncher(context.plat
     for (;;) {
         const table = await tableAt(folder);
         if (table?.version === version) {
-            return styleText(["bold", "green"], `♜ ${(await launcher.open(table.url)) ? words.opened(table.url) : words.notOpened(table.url)}`);
+            return styleText(["bold", "green"], `♜ ${(await openWindow(table.url, table.port, launcher)) ? words.opened(table.url) : words.notOpened(table.url)}`);
         }
         if (table !== undefined && !asked.has(table.port)) {
             asked.add(table.port);
@@ -60,10 +60,23 @@ export function processLauncher(platform, command = [...process.execArgv, proces
             // Its own process group, with no console and nothing of this one's: the terminal can close, the table stays.
             spawn(process.execPath, [...command, "table"], { cwd: home, detached: true, stdio: "ignore", windowsHide: true }).unref();
         },
-        open: (url) => openInBrowser(url, platform),
+        open: (url, opening) => openInBrowser(url, platform, opening),
         wait: (milliseconds) => new Promise((done) => setTimeout(done, milliseconds)),
     };
 }
+// The table's window, opened unless another opening has not reached the table yet, as two clicks on the icon ask: then the one opening is as good. One
+// that will never reach it, as no browser started or only a tab with no opening did, is let go at once: the next chesspal opens its own.
+async function openWindow(url, port, launcher) {
+    const opening = await askToOpen(port);
+    if (opening === null) {
+        return true;
+    }
+    const opened = await launcher.open(url, opening);
+    if (opening !== undefined && opened !== "window") {
+        await askToRelease(port, opening);
+    }
+    return opened !== "none";
+}
 // A table answers within ten seconds of its start, an older one quitting first, looked for every tenth of a second.
 const startWait = 10_000;
 const every = 100;

package/dist/server/table/link.js

@@ -50,6 +50,7 @@ function tablePage(link, url) {
         heard: () => link.copy(true),
         chatCalls: () => link.calls(),
         toolEnded: () => link.copy(false),
+        findable: true,
         open: () => link.open,
         inUse: () => true,
         askNewGame: () => link.askNewGame(),
@@ -198,14 +199,16 @@ function answerOf(status, text) {
     }
     return status === 200 ? jsonOf(text) : undefined;
 }
-/** What the chat says of itself as it attaches:its version, session and folder, its host, and whether its folder needs init again. */
+/** What the chat says of itself as it attaches: its version, session and folder, its host, whether its folder needs init again, and the seat of its play. */
 function attachment(context) {
+    const seat = Number(process.env.CHESSPAL_SEAT);
     return {
         version,
         session: process.env.CLAUDE_CODE_SESSION_ID ?? null,
         folder: context.folder,
         host: context.host?.(),
         outdated: outdatedHostFiles(context.folder, context.platform).length > 0,
+        ...(Number.isInteger(seat) && seat > 0 ? { seat } : {}),
     };
 }
 /** What the chat saw, for the table's copy: the game and the position, the words it was given, its host, and who played as the AI (D-82, D-97). */

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

@@ -32,3 +32,10 @@ export declare function startTable(context: Context, times?: TableTimes, chats?:
 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>;
+/**
+ * Asks the table at a port for an opening of its window: its number, which the window carries, null while another opening has not reached the table
+ * yet, so that no second window opens; undefined when the table did not answer.
+ */
+export declare function askToOpen(port: number): Promise<number | null | undefined>;
+/** Lets go of the opening the table at a port gave, whose window will never reach it: the next `chesspal` opens its own at once. */
+export declare function askToRelease(port: number, opening: number): Promise<void>;

package/dist/server/table/table.js

@@ -1,10 +1,10 @@
 // The table (D-104): the board page served in a process of its own, on a folder of the data folder that is one for every profile, which a chat attaches
 // to; it closes by itself once no browser has had the page open, and no chat been attached, for a while.
 import { request } from "node:http";
-import { tableFolder } from "../../home/index.js";
-import { setUpHosts } from "../../host-files/index.js";
-import { pageAt, pagePorts, samePath } from "../bell/index.js";
+import { samePath, tableFolder } from "../../home/index.js";
 import { startPage } from "../page/index.js";
+import { pageAt, pagePorts } from "../ports/index.js";
+import { setUpTable } from "./hosts/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 };
 /**
@@ -14,7 +14,7 @@ export const tableTimes = { idle: 5 * 60_000, every: 15_000 };
  */
 export async function startTable(context, times = tableTimes, chats, updater) {
     const folder = tableFolder(context.home());
-    setUpHosts(folder, context.platform);
+    setUpTable(folder, context.platform);
     let quit = () => undefined;
     const quitting = new Promise((done) => {
         quit = done;
@@ -61,19 +61,47 @@ export async function tableAt(folder) {
     return port === undefined ? undefined : { url: `http://127.0.0.1:${port}/`, port, version: said[index]?.version, chat: said[index]?.chat };
 }
 /** 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 function askToQuit(port) {
+export async function askToQuit(port) {
+    await askTable(port, "/api/table/quit");
+}
+/**
+ * Asks the table at a port for an opening of its window: its number, which the window carries, null while another opening has not reached the table
+ * yet, so that no second window opens; undefined when the table did not answer.
+ */
+export async function askToOpen(port) {
+    const answer = await askTable(port, "/api/table/open");
+    const opening = answer?.opening;
+    return typeof opening === "number" || opening === null ? opening : undefined;
+}
+/** Lets go of the opening the table at a port gave, whose window will never reach it: the next `chesspal` opens its own at once. */
+export async function askToRelease(port, opening) {
+    await askTable(port, "/api/table/open", { release: opening });
+}
+// A POST of JSON to a route of the table: its answer read as JSON, undefined when it could not be reached or read in time.
+function askTable(port, path, body = {}) {
     return new Promise((done) => {
-        const asked = request({ host: "127.0.0.1", port, path: "/api/table/quit", method: "POST", headers: { "Content-Type": "application/json" }, agent: false }, (response) => {
-            response.resume();
-            response.on("end", () => done());
+        const asked = request({ host: "127.0.0.1", port, path, method: "POST", headers: { "Content-Type": "application/json" }, agent: false }, (response) => {
+            let body = "";
+            response.setEncoding("utf8");
+            response.on("data", (chunk) => {
+                body += chunk;
+            });
+            response.on("end", () => {
+                try {
+                    done(JSON.parse(body));
+                }
+                catch {
+                    done(undefined);
+                }
+            });
         });
-        asked.setTimeout(quitWait, () => asked.destroy());
-        asked.on("error", () => done());
-        asked.end("{}");
+        asked.setTimeout(tableWait, () => asked.destroy());
+        asked.on("error", () => done(undefined));
+        asked.end(JSON.stringify(body));
     });
 }
 // A table answers at once: one stuck must not hold the chat's first tool, nor `chesspal`.
-const quitWait = 1_500;
+const tableWait = 1_500;
 /** 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/sites/index.d.ts

@@ -1,3 +1,3 @@
 export { isSiteGameName, pointsAtSite, readSiteGames, type SiteGame, siteGameName, type SiteGames, siteOfGameName } from "./games/index.ts";
+export { readingsStale, readSites } from "./ratings/index.ts";
 export { answerTime, askSite, type Fetch } from "./request/index.ts";
-export { readingsStale, readSites } from "./sites.ts";

package/dist/sites/index.js

@@ -2,5 +2,5 @@
 // asked by a tool of the AI's (D-106); and their latest games there, which a tool lists too, to study one (D-110). Below the commands, beside the profiles,
 // whose types it fills. Its request asks npm too, for a newer Chesspal (D-108).
 export { isSiteGameName, pointsAtSite, readSiteGames, siteGameName, siteOfGameName } from "./games/index.js";
+export { readingsStale, readSites } from "./ratings/index.js";
 export { answerTime, askSite } from "./request/index.js";
-export { readingsStale, readSites } from "./sites.js";

package/dist/sites/{chesscom.d.ts → ratings/chesscom.d.ts}

@@ -1,4 +1,4 @@
-import type { SiteReading } from "../profiles/index.ts";
-import { type Fetch } from "./request/index.ts";
+import type { SiteReading } from "../../profiles/index.ts";
+import { type Fetch } from "../request/index.ts";
 /** What Chess.com says of a name: undefined when it could not be reached. */
 export declare function chesscomReading(account: string, fetch: Fetch, signal: AbortSignal): Promise<SiteReading | undefined>;

package/dist/sites/{chesscom.js → ratings/chesscom.js}

@@ -1,5 +1,5 @@
+import { askSite } from "../request/index.js";
 import { counted } from "./choice.js";
-import { askSite } from "./request/index.js";
 /** What Chess.com says of a name: undefined when it could not be reached. */
 export async function chesscomReading(account, fetch, signal) {
     const statistics = await askSite(`https://api.chess.com/pub/player/${encodeURIComponent(account.toLowerCase())}/stats`, fetch, signal);

package/dist/sites/{choice.d.ts → ratings/choice.d.ts}

@@ -1,4 +1,4 @@
-import { type Speed } from "../profiles/index.ts";
+import { type Speed } from "../../profiles/index.ts";
 /** A site's rating at one speed, as it gives it: established once it is no longer provisional. */
 export interface Candidate {
     readonly value: number;

package/dist/sites/{choice.js → ratings/choice.js}

@@ -1,5 +1,5 @@
 // Which of a site's ratings counts (D-106): the rapid, and when it is missing or provisional the classical, then the blitz.
-import { speeds } from "../profiles/index.js";
+import { speeds } from "../../profiles/index.js";
 /** The first established rating in the order the speeds count: none when every one is missing or provisional. */
 export function counted(at) {
     for (const speed of speeds) {

package/dist/sites/ratings/index.d.ts

@@ -0,0 +1 @@
+export { readingsStale, readSites } from "./ratings.ts";

package/dist/sites/ratings/index.js

@@ -0,0 +1,2 @@
+// The player's public ratings on Lichess and Chess.com (D-105), read from the names in their profile, without a key; and which speed counts.
+export { readingsStale, readSites } from "./ratings.js";

package/dist/sites/{lichess.d.ts → ratings/lichess.d.ts}

@@ -1,4 +1,4 @@
-import type { SiteReading } from "../profiles/index.ts";
-import { type Fetch } from "./request/index.ts";
+import type { SiteReading } from "../../profiles/index.ts";
+import { type Fetch } from "../request/index.ts";
 /** What Lichess says of a name: undefined when it could not be reached. */
 export declare function lichessReading(account: string, fetch: Fetch, signal: AbortSignal): Promise<SiteReading | undefined>;

package/dist/sites/{lichess.js → ratings/lichess.js}

@@ -1,5 +1,5 @@
+import { askSite } from "../request/index.js";
 import { counted } from "./choice.js";
-import { askSite } from "./request/index.js";
 /** What Lichess says of a name: undefined when it could not be reached. */
 export async function lichessReading(account, fetch, signal) {
     const user = await askSite(`${address}/${encodeURIComponent(account)}`, fetch, signal);

package/dist/sites/{sites.d.ts → ratings/ratings.d.ts}

@@ -1,5 +1,5 @@
-import type { Accounts, SiteReadings } from "../profiles/index.ts";
-import { type Fetch } from "./request/index.ts";
+import type { Accounts, SiteReadings } from "../../profiles/index.ts";
+import { type Fetch } from "../request/index.ts";
 /** What Lichess and Chess.com say now of the player's names there, at `now`; a site that cannot be reached keeps what it said before of the same name. */
 export declare function readSites(accounts: Accounts, fetch: Fetch, before: SiteReadings | undefined, now: Date): Promise<SiteReadings>;
 /** Whether the readings are of other names than the profile's now, or a site did not answer a while ago: they are read again then, whatever their age. */

package/dist/sites/{sites.js → ratings/ratings.js}

@@ -1,6 +1,6 @@
+import { answerTime } from "../request/index.js";
 import { chesscomReading } from "./chesscom.js";
 import { lichessReading } from "./lichess.js";
-import { answerTime } from "./request/index.js";
 /** What Lichess and Chess.com say now of the player's names there, at `now`; a site that cannot be reached keeps what it said before of the same name. */
 export async function readSites(accounts, fetch, before, now) {
     const signal = AbortSignal.timeout(answerTime);

package/instructions/opponent.md

@@ -1,7 +1,7 @@
 You choose your moves, explain them briefly and talk with the player.
 
 - `status` says where the game stands and what to do next. The game is played on the board page, in the player's browser, and the chat is for talking: when `status` says nobody has it open, give them its address once. A move they write in the chat still counts: play it, and invite them to the page when `player_move` says so.
-- Every move goes through the tools: the player's with `player_move`, which answers with the position for your reply; yours with `ai_move`, with your plan. Never keep the board in your head, and never invent a position, a move or a result.
+- Every move goes through the tools: the player's with `player_move`, which answers with the position for your reply (a move they write alone in Claude Code may come already played by Chesspal, with that position); yours with `ai_move`, with your plan. Never keep the board in your head, and never invent a position, a move or a result.
 - When your level gives them (`status` and `new_game` say it), `look` gives the whole view of the position when the one you have is not enough; `position` gives the positional facts (pawns, files, outposts, king safety, phase) when you set or change your plan. Your level is how much you let yourself look, more as the level rises: when the player wonders why you missed something, say so in a few words, as a fact, never an excuse.
 - Speak only when there is something to say, as a player would at a tournament: a capture, a move of the player's worth a word, words of theirs to answer, and always at the moments that decide the game: a mate, given or taken, a danger you feel, a mate you hope for, a big lead. Chat freely, but never help the player: say how you feel, not the move; don't reveal your plans or threats, and give information only when you are very sure it cannot hurt you. Then write one short sentence in `ai_move`'s comment; otherwise leave it out. `ai_say` says a word once while the player is to move, to answer them or because there is something to say, and freely between games.
 - When the position you are given says "Helps on", the player has chosen to learn: tell your intentions, never their best move, which would play for them, and show what you say with a longer comment and arrows and squares; the coach on the page, you seeing it all, judges their moves, never you here. "Helps off now" brings back the tournament.

package/instructions/start.md

@@ -1 +1 @@
-This folder is the player's chess table, and you are their opponent; Chesspal keeps the rules, the board, the clock and the games. In every chat, before you write anything, even to a greeting, call `instructions` and `status`; again after the conversation is summarized. Every move goes through Chesspal's tools: never keep the board in your head or invent a position.
+This folder is the player's chess table, and you are their opponent; Chesspal keeps the rules, the board, the clock and the games. In every chat, before you write anything, even to a greeting, call `instructions` and `status`; again after the conversation is summarized. Every move goes through Chesspal's tools: never keep the board in your head or invent a position. Without them, tell the player plainly to reopen this chat in this folder and trust it; name no tool or setting.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chesspal",
-  "version": "0.3.5",
+  "version": "0.4.0",
   "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": {