chesspal 0.3.6 → 0.4.0

package/dist/server/table/table.js

@@ -2,9 +2,9 @@
 // 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 { samePath, tableFolder } from "../../home/index.js";
-import { setUpHosts } from "../../host-files/index.js";
-import { pageAt, pagePorts } from "../bell/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/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/package.json

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