chesspal 0.3.6 → 0.4.0

package/dist/server/table/browser.js

@@ -1,40 +1,118 @@
-// 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";
+// The table's page opened in the player's browser (D-104): in a window of its own, as an application, in the default browser when it opens one with --app,
+// else in Chrome or Edge when either is installed; else in a tab of the system's default browser.
+import { execFile, 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);
+/**
+ * Opens an address in a window of its own, marked with the table's opening, else in a tab of the default browser, without waiting for it: how it opened.
+ * A tab is not marked: a page cannot close a tab it did not open.
+ */
+export async function openInBrowser(url, platform, opening) {
+    const browser = await appBrowser(platform, process.env);
+    if (browser !== undefined && await started(browser, [`--app=${openedAddress(url, opening)}`])) {
+        return "window";
+    }
     // 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);
+    return await openFolder(url, platform) ? "tab" : "none";
 }
-/** 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) {
+/**
+ * The address of the window the table opens, marked so that the page sizes it as it opens, with its opening, so that it closes once a newer window has
+ * opened (page/layout/window.ts).
+ */
+export function openedAddress(url, opening) {
     const address = new URL(url);
-    address.searchParams.set("opened", "");
+    address.searchParams.set("opened", opening === undefined ? "" : String(opening));
     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);
+/**
+ * The browser that opens the table's window: the default one when it is a Chromium that takes --app and is where it installs itself, so that the window
+ * opens in the browser the player uses; else Chrome or Edge, the first there is; none when neither is.
+ */
+export async function appBrowser(platform, env, system = realSystem) {
+    const chosen = await defaultBrowser(platform, system);
+    const tried = platform === "linux" ? [chrome, chromium, edge] : [chrome, edge];
+    const browsers = chosen === undefined ? tried : [chosen, ...tried];
+    return browsers.flatMap((browser) => browserPaths(browser, platform, env)).find(system.exists);
+}
+const chrome = {
+    windows: ["Google", "Chrome", "Application", "chrome.exe"],
+    progId: "ChromeHTML",
+    mac: "Google Chrome",
+    linux: ["google-chrome", "google-chrome-stable"],
+    desktop: ["google-chrome"],
+};
+const edge = {
+    windows: ["Microsoft", "Edge", "Application", "msedge.exe"],
+    progId: "MSEdgeHTM",
+    mac: "Microsoft Edge",
+    linux: ["microsoft-edge", "microsoft-edge-stable"],
+    desktop: ["microsoft-edge"],
+};
+const brave = {
+    windows: ["BraveSoftware", "Brave-Browser", "Application", "brave.exe"],
+    progId: "BraveHTML",
+    mac: "Brave Browser",
+    linux: ["brave-browser", "brave-browser-stable", "brave"],
+    desktop: ["brave-browser", "brave_brave"],
+};
+const chromium = {
+    windows: ["Chromium", "Application", "chrome.exe"],
+    progId: "ChromiumHTM",
+    mac: "Chromium",
+    linux: ["chromium", "chromium-browser"],
+    desktop: ["chromium", "chromium-browser", "chromium_chromium"],
+};
+const chromiums = [chrome, edge, brave, chromium];
+// Windows keeps the default browser for http in UserChoiceLatest when it has one, which it then reads in place of UserChoice; macOS is not asked.
+async function defaultBrowser(platform, system) {
+    if (platform === "win32") {
+        const choices = await system.output("reg", ["query", String.raw `HKCU\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http`, "/s"]);
+        const progId = progIdIn(choices, String.raw `\UserChoiceLatest\ProgId`) ?? progIdIn(choices, String.raw `\UserChoice`);
+        return chromiums.find((browser) => progId === browser.progId || progId?.startsWith(`${browser.progId}.`) === true);
+    }
+    if (platform === "linux") {
+        const desktop = (await system.output("xdg-settings", ["get", "default-web-browser"])).trim().replace(/\.desktop$/, "");
+        return chromiums.find((browser) => browser.desktop.includes(desktop));
+    }
+    return undefined;
+}
+// The ProgId under the key of reg's answer that ends so.
+function progIdIn(choices, key) {
+    let inKey = false;
+    for (const line of choices.split(/\r?\n/)) {
+        if (line.startsWith("HKEY_")) {
+            inKey = line.trimEnd().endsWith(key);
+        }
+        else if (inKey) {
+            const value = /^\s+ProgId\s+REG_SZ\s+(\S+)/.exec(line);
+            if (value !== null) {
+                return value[1];
+            }
+        }
+    }
+    return undefined;
 }
-// Chrome before Edge: Chrome is the one tried, and Edge may be missing even on Windows.
-function browserPaths(platform, env) {
+// Where each system installs a browser: Program Files and the user's AppData, the Applications of macOS, the PATH of Linux.
+function browserPaths(browser, 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)));
+        return roots.map((root) => win32.join(root, ...browser.windows));
     }
     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)));
+        return roots.map((root) => posix.join(root, `${browser.mac}.app`, "Contents", "MacOS", browser.mac));
     }
     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)));
+    return browser.linux.flatMap((name) => folders.map((folder) => posix.join(folder, name)));
 }
+const realSystem = {
+    exists: existsSync,
+    output: (command, args) => new Promise((done) => {
+        // A second at most: the window would rather open in Chrome or Edge than wait on a registry or a desktop that does not answer.
+        execFile(command, args, { windowsHide: true, timeout: 1000 }, (error, output) => done(error === null ? output : ""));
+    }),
+};
 // A browser started apart from this process, which it outlives: whether it started.
 function started(browser, args) {
     return new Promise((done) => {

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

@@ -0,0 +1,6 @@
+/** Codex's hooks as Chesspal last wrote them, which Codex asks the player to trust: the first time, or changed over ones trusted before. */
+export type HooksNews = "new" | "changed";
+/** Sets the table's folder up as init does, noting when Chesspal wrote Codex's hooks: Codex then asks the player to trust them. */
+export declare function setUpTable(folder: string, platform: string): void;
+/** What Chesspal wrote of Codex's hooks since the player last heard it; the note is taken. One that cannot be read is no note. */
+export declare function takeHooksNews(folder: string): HooksNews | undefined;

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

@@ -0,0 +1,38 @@
+// The table's folder set up as init does, for the table and for `chesspal play` alike: when Chesspal writes Codex's hooks, the first time or again over
+// older ones, a note says so, which the next `chesspal play codex` takes, for the player to hear it whichever of the two wrote them.
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { writeAtomically } from "../../../games/index.js";
+import { codexHooksPath, setUpHosts } from "../../../host-files/index.js";
+/** Sets the table's folder up as init does, noting when Chesspal wrote Codex's hooks: Codex then asks the player to trust them. */
+export function setUpTable(folder, platform) {
+    const hooks = codexHooksPath(folder);
+    const hadHooks = existsSync(hooks);
+    if (setUpHosts(folder, platform).includes(hooks)) {
+        // Hooks never trusted stay new, whatever Chesspal wrote over them before Codex asked.
+        const news = hadHooks && readNote(folder) !== "new" ? "changed" : "new";
+        writeAtomically(join(folder, hooksNoteFile), `${JSON.stringify({ hooks: news })}\n`);
+    }
+}
+/** What Chesspal wrote of Codex's hooks since the player last heard it; the note is taken. One that cannot be read is no note. */
+export function takeHooksNews(folder) {
+    const news = readNote(folder);
+    try {
+        rmSync(join(folder, hooksNoteFile), { force: true });
+    }
+    catch {
+        // A note that cannot go now (the table rewrites it) is said again at the next play, which is harmless.
+    }
+    return news;
+}
+const hooksNoteFile = "codex-hooks-note.json";
+// The note's news, none when there is no note or it cannot be read.
+function readNote(folder) {
+    try {
+        const hooks = JSON.parse(readFileSync(join(folder, hooksNoteFile), "utf8"))?.hooks;
+        return hooks === "new" || hooks === "changed" ? hooks : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -1,12 +1,17 @@
 /** 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. */
+/**
+ * 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; and the
+ * `model` and `effort` a chat starts with until the player chooses, the middle ones.
+ */
 export interface HostChoices {
     readonly models: readonly string[];
     readonly efforts: readonly string[];
+    readonly model: string;
+    readonly effort: string;
 }
-/** What the player chose for a host on the page: none of either keeps the host's own. */
+/** What the player chose for a host on the page: none of either, or one the host does not offer, is the host's middle one. */
 export interface HostChoice {
     readonly model?: string | undefined;
     readonly effort?: string | undefined;
@@ -18,8 +23,11 @@ export interface HostChoice {
 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 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. A chat opened
+ * `toAnalyse` the game the page shows is asked for that: told to play, it opened the New game window over the analysis it had just started.
+ */
+export declare function startMessage(language: string | undefined, toAnalyse?: boolean): 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.
@@ -30,5 +38,5 @@ 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. */
+/** A host's choice as the profile's settings keep it: the values the host offers alone, the rest is its middle one. */
 export declare function choiceIn(settings: Readonly<Record<string, unknown>> | undefined, host: HostName): HostChoice;

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

@@ -1,5 +1,5 @@
 // The AI hosts the table opens a chat in (D-104): Claude Code and Codex, each with the start message, and the model and effort the player chose on the page
-// for the profile in use; "as the host" passes nothing, and the host's own settings stand.
+// for the profile in use, or each host's middle ones until they choose: the chat never starts with whatever the host was left at.
 import { speaksItalian } from "../../../commands/index.js";
 /** The hosts the page offers, by their command's name. */
 export const hostNames = ["claude", "codex"];
@@ -8,15 +8,21 @@ export const hostNames = ["claude", "codex"];
  * models a ChatGPT account lists, which change with its releases.
  */
 export const hostChoices = {
-    claude: { models: ["fable", "opus", "sonnet", "haiku"], efforts: ["low", "medium", "high", "xhigh", "max"] },
-    codex: { models: ["gpt-6.1-sol", "gpt-6-astra", "gpt-6.1-terra", "gpt-6-luna"], efforts: ["low", "medium", "high", "xhigh", "max"] },
+    claude: { models: ["fable", "opus", "sonnet", "haiku"], efforts: ["low", "medium", "high", "xhigh", "max"], model: "sonnet", effort: "medium" },
+    codex: { models: ["gpt-6.1-sol", "gpt-6-astra", "gpt-6.1-terra", "gpt-6-luna"], efforts: ["low", "medium", "high", "xhigh", "max"], model: "gpt-6.1-terra", effort: "medium" },
 };
 /** Whether a word names a host the page offers. */
 export function isHostName(name) {
     return hostNames.includes(name);
 }
-/** 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 function startMessage(language) {
+/**
+ * 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. A chat opened
+ * `toAnalyse` the game the page shows is asked for that: told to play, it opened the New game window over the analysis it had just started.
+ */
+export function startMessage(language, toAnalyse = false) {
+    if (toAnalyse) {
+        return speaksItalian(language) ? "Analizziamo la partita!" : "Let's analyse the game!";
+    }
     return speaksItalian(language) ? "Giochiamo!" : "Let's play!";
 }
 /**
@@ -34,16 +40,16 @@ export function hostArgs(host, message, choice = {}) {
 export function choiceKeys(host) {
     return { model: `${host}Model`, effort: `${host}Effort` };
 }
-/** A host's choice as the profile's settings keep it: the values the host offers alone, the rest is the host's own. */
+/** A host's choice as the profile's settings keep it: the values the host offers alone, the rest is its middle one. */
 export function choiceIn(settings, host) {
     const keys = choiceKeys(host);
     const text = (value) => (typeof value === "string" ? value : undefined);
     return offered(host, { model: text(settings?.[keys.model]), effort: text(settings?.[keys.effort]) });
 }
-// The choice kept to the values the host offers.
+// The choice kept to the values the host offers: its middle model and effort where none is chosen, or one it does not offer.
 function offered(host, choice) {
-    const { models, efforts } = hostChoices[host];
-    const model = choice.model !== undefined && models.includes(choice.model) ? choice.model : undefined;
-    const effort = choice.effort !== undefined && efforts.includes(choice.effort) ? choice.effort : undefined;
+    const choices = hostChoices[host];
+    const model = choice.model !== undefined && choices.models.includes(choice.model) ? choice.model : choices.model;
+    const effort = choice.effort !== undefined && choices.efforts.includes(choice.effort) ? choice.effort : choices.effort;
     return { model, effort };
 }

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

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

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

@@ -1,4 +1,5 @@
 // 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 { setUpTable } from "./hooks.js";
 export { isHostName } from "./hosts.js";
 export { endTree, hostLaunch, playHost } from "./play.js";

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

@@ -1,5 +1,6 @@
 import { type ChildProcess } from "node:child_process";
 import { type Context } from "../../../commands/index.ts";
+import { type HooksNews } from "./hooks.ts";
 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
@@ -12,13 +13,14 @@ export interface HostLaunch {
     readonly env: NodeJS.ProcessEnv;
     readonly shell: boolean;
     readonly choice: HostChoice;
-    /** Codex's hooks were there and Chesspal wrote them again: Codex runs them only once the player trusts them again. */
-    readonly hooksChanged?: true;
+    /** Chesspal wrote Codex's hooks, the first time or again: Codex runs them only once the player trusts them. */
+    readonly hooks?: HooksNews;
 }
 /**
  * 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.
+ * or for another model or host, which then takes its place (D-107); after an update, by the Chesspal installed (D-108). Claude Code closed at its
+ * start with an error, as when the player keeps No at its question on the folder, is told how to answer and started once more. 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>;
 /**

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

@@ -4,17 +4,19 @@ import { spawn, spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { win32 } from "node:path";
 import { speaksItalian } from "../../../commands/index.js";
+import { endOf, gameInAnalysis, loadGame } from "../../../games/index.js";
 import { tableFolder } from "../../../home/index.js";
-import { codexHooksPath, setUpHosts } from "../../../host-files/index.js";
 import { activeProfile, gameFolder, languageIn, profileSettings } from "../../../profiles/index.js";
 import { programPath } from "./find.js";
+import { setUpTable, takeHooksNews } from "./hooks.js";
 import { choiceIn, hostArgs, isHostName, startMessage } from "./hosts.js";
 import { askedAgain, leaveSeat, refreshSeat, seatTimes, takeSeat } from "./seat.js";
 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); 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.
+ * or for another model or host, which then takes its place (D-107); after an update, by the Chesspal installed (D-108). Claude Code closed at its
+ * start with an error, as when the player keeps No at its question on the folder, is told how to answer and started once more. 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());
@@ -33,6 +35,8 @@ export async function playHost(context, host) {
     let refreshed = Date.now();
     // Chesspal was updated under this process (D-108): the new one plays on.
     let updated = false;
+    // Claude Code was started once more after it closed at its start.
+    let startedOnceMore = false;
     const asked = () => {
         if (Date.now() - refreshed >= seatTimes.refresh) {
             refreshed = Date.now();
@@ -47,6 +51,7 @@ export async function playHost(context, host) {
         for (;;) {
             // A request left from a second click while the host before was ending is not for this one.
             askedAgain(folder, process.pid);
+            const startedAt = context.now();
             const ran = await started(context, playing, asked).catch((error) => {
                 if (before === undefined) {
                     throw error;
@@ -61,7 +66,16 @@ export async function playHost(context, host) {
             }
             before = undefined;
             if (!ran.again) {
-                return ran.code;
+                if (playing !== "claude" || ran.code === 0 || context.now().getTime() - startedAt.getTime() >= closedAtStart) {
+                    return ran.code;
+                }
+                const words = speaksItalian(context.language) ? closedAtStartWords.italian : closedAtStartWords.english;
+                process.stdout.write(`\n${words.join("\n")}\n`);
+                if (startedOnceMore) {
+                    return ran.code;
+                }
+                startedOnceMore = true;
+                continue;
             }
             if (updated) {
                 terminal.restore();
@@ -121,33 +135,59 @@ export function hostLaunch(context, host, env = process.env, exists) {
     if (found === undefined) {
         throw new Error(`${hostTitle[host]} is not installed on this computer, or not on its PATH: install it (${installHint[host]}), then try again.`);
     }
-    const hooks = codexHooksPath(folder);
-    const hadHooks = host === "codex" && existsSync(hooks);
-    const hooksChanged = setUpHosts(folder, context.platform).includes(hooks) && hadHooks ? { hooksChanged: true } : {};
+    setUpTable(folder, context.platform);
+    // Codex's hooks written, by this play or by the table before it: the note is for Codex's chat, and waits for it.
+    const news = host === "codex" ? takeHooksNews(folder) : undefined;
+    const hooks = news === undefined ? {} : { hooks: news };
     const choice = choiceIn(profileSettings(home, activeProfile(home).id), host);
-    const args = hostArgs(host, startMessage(languageIn(gameFolder(home), context.language)), choice);
+    const games = gameFolder(home);
+    const args = hostArgs(host, startMessage(languageIn(games, context.language), analysisAsked(games)), choice);
     // An effort the player set for every chat would win over the one chosen on the page: spawn leaves out a variable that is undefined.
     const effort = host === "claude" && choice.effort !== undefined ? { CLAUDE_CODE_EFFORT_LEVEL: undefined } : {};
     // The seat this play holds, by which its chat's server tells the table it is the chat held, and not another opened in the same folder.
     const childEnv = { ...env, ...Object.fromEntries(sessionMarks.map((name) => [name, undefined])), ...effort, CHESSPAL_SEAT: String(process.pid) };
     const script = npmScript(host, found, context.platform, exists ?? existsSync);
     if (script !== undefined) {
-        return { program: process.execPath, args: [script, ...args], folder, env: childEnv, shell: false, choice, ...hooksChanged };
+        return { program: process.execPath, args: [script, ...args], folder, env: childEnv, shell: false, choice, ...hooks };
+    }
+    return { program: found, args, folder, env: childEnv, shell: context.platform === "win32" && /\.(cmd|bat)$/i.test(found), choice, ...hooks };
+}
+/** Whether the board page shows a game in analysis, none going on: the chat opened there is for that game, brought to review or to talk over, not for a new one. */
+function analysisAsked(folder) {
+    try {
+        const current = loadGame(folder);
+        return (current === undefined || endOf(current.game) !== undefined) && gameInAnalysis(folder) !== undefined;
+    }
+    catch {
+        // A game that cannot be read is status's to report.
+        return false;
     }
-    return { program: found, args, folder, env: childEnv, shell: context.platform === "win32" && /\.(cmd|bat)$/i.test(found), choice, ...hooksChanged };
 }
 const hostTitle = { claude: "Claude Code", codex: "Codex" };
-const hooksChangedWords = {
-    english: "Chesspal's hooks for Codex have changed: when Codex asks about them, choose Trust all again.",
-    italian: "Gli «hook» di Chesspal per Codex sono cambiati: quando Codex te lo chiede, scegli di nuovo Trust all.",
+// What the player is told before Codex asks about the hooks Chesspal wrote: the first time, and when they changed.
+const hooksWords = {
+    new: {
+        english: "Codex will ask about Chesspal's two hooks, small helpers that let it see your moves on the board: choose Trust all and continue.",
+        italian: "Codex ti chiederà dei due «hook» di Chesspal, piccoli aiuti che gli fanno vedere le tue mosse sulla scacchiera: scegli Trust all and continue.",
+    },
+    changed: {
+        english: "Chesspal's hooks for Codex have changed: when Codex asks about them, choose Trust all again.",
+        italian: "Gli «hook» di Chesspal per Codex sono cambiati: quando Codex te lo chiede, scegli di nuovo Trust all.",
+    },
+};
+// What the player is told when Claude Code closed at its start: its question on the folder starts on No.
+const closedAtStartWords = {
+    english: ["Claude Code closed as soon as it opened.", 'If it asks whether you trust this folder, go down to "Yes, I trust this folder" with the arrow keys, then press Enter.'],
+    italian: ["Claude Code si è chiuso appena aperto.", "Se ti chiede se ti fidi della cartella, scendi con le frecce su «Yes, I trust this folder», poi premi Invio."],
 };
 // Runs the host as runHost does, the seat noting the model and effort it is given; one not installed, or that could not start, fails saying so.
 async function started(context, host, again) {
     const launch = hostLaunch(context, host);
     takeSeat(launch.folder, { pid: process.pid, host, ...launch.choice });
-    // After an update the player is asked about the hooks again: said here, above the host's question, as init says it.
-    if (launch.hooksChanged === true) {
-        process.stdout.write(`${speaksItalian(context.language) ? hooksChangedWords.italian : hooksChangedWords.english}\n`);
+    // Codex asks the player to trust the hooks Chesspal wrote: said here, above its question, as init says it.
+    if (launch.hooks !== undefined) {
+        const words = hooksWords[launch.hooks];
+        process.stdout.write(`${speaksItalian(context.language) ? words.italian : words.english}\n`);
     }
     return runHost(launch, again, context.platform).catch((error) => {
         throw new Error(`${hostTitle[host]} did not start: ${error.message}`);
@@ -179,6 +219,8 @@ function playUpdated(host) {
 const killAfter = 3_000;
 // A play process that ends sooner never got to its host.
 const quickExit = 10_000;
+// Claude Code ends 1.5 s after No at its question on the folder, a chat the player ends ends with no error (Priya): a minute is the time to read it.
+const closedAtStart = 60_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";

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

@@ -1,4 +1,4 @@
-export { appBrowser, openedAddress } from "./browser.ts";
+export { appBrowser, type BrowserSystem, type Opened, openedAddress } from "./browser.ts";
 export { hostLaunch, isHostName, playHost, terminalChats } from "./hosts/index.ts";
 export { iconAsked, type IconCommand, iconCommand, type IconPlaces, iconToRemake, makeIcons, noteIconAsked, noteIconMade, removeIcons } from "./icon/index.ts";
 export { noteFailure, openTable, processLauncher, type TableLauncher } from "./launch.ts";

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

@@ -1,16 +1,17 @@
 import { type Context } from "../../commands/index.ts";
+import { type Opened } from "./browser.ts";
 /** What opening the table does outside this process: start the table apart, open the browser, wait. The tests give their own. */
 export interface TableLauncher {
     /** Starts `chesspal table` apart from this process, which it outlives, in the data folder. */
     start(home: string): void;
-    /** Opens the page in the browser: whether it could. */
-    open(url: string): Promise<boolean>;
+    /** Opens the page in the browser, its window marked with its opening when the table gave one: how it opened. */
+    open(url: string, opening?: number): Promise<Opened>;
     wait(milliseconds: number): Promise<void>;
 }
 /**
  * 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 declare function openTable(context: Context, launcher?: TableLauncher): Promise<string>;
 /**

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(),

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>;