chesspal 0.1.0 → 0.2.0

package/dist/server/mcp.js

@@ -1,17 +1,15 @@
+// The MCP server an AI host starts: every command as a tool (D-5), and the board page served for as long as the chat lasts (D-47).
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { aiMove } from "../commands/ai-move.js";
-import { defaultContext } from "../commands/context.js";
-import { commands } from "../commands/index.js";
-import { PositionChanged } from "../commands/play-move.js";
-import { inputProblems, isBoolean } from "../commands/registry.js";
-import { noteAiModel } from "../games/index.js";
+import { aiMove, commands, defaultContext, inputProblems, isBoolean, PositionChanged } from "../commands/index.js";
+import { endOf, loadGame, noteAiModel } from "../games/index.js";
+import { hasAgent } from "../host-files/index.js";
 import { gameFolder } from "../profiles/index.js";
 import { version } from "../version.js";
 import { pagePorts } from "./bell.js";
-import { callerOf } from "./caller.js";
-import { chatHasRead, startPage } from "./page.js";
+import { allowedCaller, callerOf, callingAgent } from "./caller.js";
+import { chatHasRead, startPage } from "./page/page.js";
 /** What the host reads as the server starts, before any tool: where to begin, and the rule of every move (D-27). Short, since hosts may cut it. */
 export const serverInstructions = "Chesspal keeps the chess for you: the rules, the board, the clock, the games and the player's memory. Call `status` at the start of every "
     + "chat. Every move goes through Chesspal's tools: never keep the board in your head or invent a position.";
@@ -24,9 +22,14 @@ export function createMcpServer(context = defaultContext(), list = commands) {
     const forOneHost = [];
     for (const command of list.filter((each) => each.cliOnly !== true)) {
         const tool = server.registerTool(command.name, toolConfig(command), async (input, extra) => {
+            // An agent's tool called by the chat, or by another agent, would give what only that agent may see (Priya).
+            if (command.byAgents !== undefined && !allowedCaller(await callingAgent(extra._meta, context.folder), command.byAgents)) {
+                // It names no agent to start: the chat that asked would start one itself (Priya).
+                return { content: [{ type: "text", text: `${command.name} is not yours to call: the player reads what it gives on the board page. Nothing changed.` }], isError: true };
+            }
             // Each call knows who makes it, for the commands that write it down (D-81).
             const caller = () => callerOf(extra._meta, server.server.getClientVersion(), context.folder);
-            const result = await track(runTool(command, input, context, caller));
+            const result = await track(runTool(command, input, context, caller, extra._meta));
             if (command === aiMove && result.isError !== true) {
                 noteTheAi(context, caller);
             }
@@ -71,10 +74,11 @@ export function opponentOf(host) {
 /** The board page of the player's folder, served by this process for as long as the chat lasts (D-47); without it the game goes on in the chat. */
 async function pageOf(context, opponent) {
     try {
-        const { url, heard, chatCalls, open, askNewGame } = await startPage(context, opponent);
+        const { url, heard, chatCalls, ponders, open, askNewGame } = await startPage(context, opponent);
         // Words the AI is given change no file: the pages hear of them from the commands.
         context.heard = heard;
         context.calls = chatCalls;
+        context.ponders = ponders;
         context.pageOpen = open;
         context.askNewGame = askNewGame;
         if (!pagePorts(context.folder).includes(Number(new URL(url).port))) {
@@ -121,13 +125,15 @@ function toolConfig(command) {
     // The SDK writes the draft's address in every schema: it says nothing to an AI, and costs tokens in every tool.
     return { description: command.description, inputSchema: z.looseObject({}).meta({ ...shownInput(command), $schema: undefined }), annotations, _meta: meta };
 }
-async function runTool(command, input, context, caller) {
+async function runTool(command, input, context, caller, meta) {
+    const agent = await sharingAgent(command, meta, context);
+    const chat = command.byAgents === undefined && agent === undefined;
     let refused = false;
     try {
-        if (command.byAgent !== true) {
+        if (chat) {
             context.calls?.();
         }
-        const result = await command.run(checkedInput(command, input), { ...context, caller });
+        const result = await command.run(checkedInput(command, input), { ...context, caller, ...(agent === undefined ? {} : { agent }) });
         return { content: [{ type: "text", text: command.format(result, context) }] };
     }
     catch (error) {
@@ -137,11 +143,33 @@ async function runTool(command, input, context, caller) {
     finally {
         // What the tool read or wrote, the chat has seen: the doorbell rings it only for what changes after, and it may move on the game a tool showed it,
         // unless that tool was refused for a position it had not seen. An agent's call is not the chat's.
-        if (command.byAgent !== true) {
+        if (chat) {
             chatHasRead(context, command.showsGame === true && !refused);
         }
     }
 }
+/**
+ * The agent that calls a tool it shares with the chat, as the analyst (D-89), by its type: looked up only in a folder where one may run and while no game
+ * goes on, so that no call of the chat's waits for it while it plays; none for the chat, or when it cannot be told.
+ */
+async function sharingAgent(command, meta, context) {
+    const agents = command.sharedWith?.filter((agent) => hasAgent(context.folder, agent)) ?? [];
+    if (agents.length === 0 || gameGoingOn(context)) {
+        return undefined;
+    }
+    const caller = await callingAgent(meta, context.folder);
+    return caller !== undefined && "agent" in caller && agents.includes(caller.agent) ? caller.agent : undefined;
+}
+/** Whether a game goes on, or may: a game that cannot be read is the command's to report, as the chat's call (Federico). */
+function gameGoingOn(context) {
+    try {
+        const current = loadGame(gameFolder(context.home()));
+        return current !== undefined && endOf(current.game) === undefined;
+    }
+    catch {
+        return true;
+    }
+}
 // The JSON schema of each command's input, as the SDK would write it from the strict schema: the tool takes any object, and the command checks it, so that
 // what is wrong comes back in words an AI can act on.
 const shownInputs = new WeakMap();

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

@@ -0,0 +1,23 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type AiModel } from "../../core/index.ts";
+import type { Served } from "./page.ts";
+/** An analysis as the page lists it: who played, with the AI's model (D-82), when, how it ended, its opening, how long, and whether the AI has reviewed it. */
+export interface AnalysisItem {
+    readonly name: string;
+    readonly white: string;
+    readonly black: string;
+    readonly aiModel?: AiModel;
+    readonly date?: string;
+    readonly result: string;
+    readonly opening?: string;
+    readonly moves: number;
+    readonly reviewed: boolean;
+    /** Who reviewed it (D-81). */
+    readonly annotator?: AiModel;
+    /** Where a game loaded from elsewhere was played, as its Site tag says: the player's name there makes it theirs (D-93). */
+    readonly site?: string;
+}
+/** The games to analyse in the profile in use, the latest first, all of them for the page's search: those kept to study and those played, reviewed or not. */
+export declare function analysesOf(home: string): AnalysisItem[];
+/** Answers the page's deletions, of a game or of its review alone, done as the command line does them: true when the request was one. */
+export declare function answerAnalyses(request: IncomingMessage, response: ServerResponse, url: URL, served: Served): boolean;

package/dist/server/page/analyses.js

@@ -0,0 +1,65 @@
+import { bookOpening, deleteGame, deleteReview } from "../../commands/index.js";
+import { aiModelIn, annotatorOf, isReviewed } from "../../core/index.js";
+import { archivedGame, archivedGames, gameStemOf, keptGame, keptGames } from "../../games/index.js";
+import { gameFolder } from "../../profiles/index.js";
+import { bodyOf, isJson, jsonOf, runRoute, sendJson, textOf } from "./http.js";
+/** The games to analyse in the profile in use, the latest first, all of them for the page's search: those kept to study and those played, reviewed or not. */
+export function analysesOf(home) {
+    const folder = gameFolder(home);
+    // By the time in their names, which orders kept and played games together.
+    const stamp = (name) => gameStemOf(name) ?? "";
+    const names = [...keptGames(folder), ...archivedGames(folder)].sort((one, other) => stamp(other).localeCompare(stamp(one)));
+    return names.flatMap((name) => itemOf(name, () => name.startsWith("study/") ? keptGame(folder, name) : archivedGame(folder, name)));
+}
+/** Answers the page's deletions, of a game or of its review alone, done as the command line does them: true when the request was one. */
+export function answerAnalyses(request, response, url, served) {
+    const command = request.method === "POST" ? deletions[url.pathname] : undefined;
+    if (command === undefined) {
+        return false;
+    }
+    runRoute(response, async () => {
+        const game = textOf(jsonOf(isJson(request) ? await bodyOf(request) : undefined)?.game);
+        if (game === undefined) {
+            sendJson(response, 400, { error: 'Send the game as JSON: {"game": "games/2026-11-02-153012.pgn"}.' });
+            return;
+        }
+        try {
+            sendJson(response, 200, await command.run({ game }, served.context));
+        }
+        catch (error) {
+            sendJson(response, 409, { error: error.message });
+        }
+    });
+    return true;
+}
+const deletions = { "/api/delete-game": deleteGame, "/api/delete-review": deleteReview };
+function itemOf(name, read) {
+    let record;
+    try {
+        record = read();
+    }
+    catch {
+        // A game that cannot be read stays out of the list.
+        return [];
+    }
+    const { tags } = record;
+    const date = tags.Date === undefined || tags.Date.includes("?") ? undefined : tags.Date;
+    const opening = bookOpening(record)?.name;
+    const aiModel = aiModelIn(record);
+    const site = tags.Site === undefined || /^[?\-\s]*$/.test(tags.Site) ? undefined : tags.Site;
+    const signed = annotatorOf(record);
+    const annotator = signed === undefined ? undefined : { model: signed.annotator, ...(signed.effort === undefined ? {} : { effort: signed.effort }) };
+    return [{
+            name,
+            white: tags.White ?? "?",
+            black: tags.Black ?? "?",
+            ...(aiModel === undefined ? {} : { aiModel }),
+            ...(date === undefined ? {} : { date }),
+            result: tags.Result ?? "*",
+            ...(opening === undefined ? {} : { opening }),
+            moves: Math.ceil(record.moves.length / 2),
+            reviewed: isReviewed(record),
+            ...(annotator === undefined ? {} : { annotator }),
+            ...(site === undefined ? {} : { site }),
+        }];
+}

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

@@ -0,0 +1,5 @@
+import type { ServerResponse } from "node:http";
+/** The page's HTML, which runs only its own files and its import map. */
+export declare function sendHtml(response: ServerResponse): void;
+/** A script, style, picture or sound of the page, a module of the core, or a package's module: only from their folders, and only of the types the page uses. */
+export declare function sendFile(response: ServerResponse, path: string): void;

package/dist/server/page/files.js

@@ -0,0 +1,92 @@
+// The page's files: its HTML with the import map, its scripts, styles, pictures and sounds, the chess core and the packages they import, each only from its
+// folder and of the types the page uses.
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { extname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { send } from "./http.js";
+/** The page's HTML, which runs only its own files and its import map. */
+export function sendHtml(response) {
+    send(response, 200, "text/html; charset=utf-8", html, { "Content-Security-Policy": policy });
+}
+/** A script, style, picture or sound of the page, a module of the core, or a package's module: only from their folders, and only of the types the page uses. */
+export function sendFile(response, path) {
+    const file = path.startsWith("/vendor/") ? vendorModule(path.slice("/vendor/".length)) : builtFile(path);
+    const type = file === undefined ? undefined : types[extname(file)];
+    let bytes;
+    try {
+        bytes = file === undefined || type === undefined ? undefined : readFileSync(file);
+    }
+    catch {
+        bytes = undefined;
+    }
+    if (bytes === undefined || type === undefined) {
+        send(response, 404, "text/plain; charset=utf-8", `Nothing at ${path}.`);
+        return;
+    }
+    // A pieces' set loaded again for each piece that moves blanks the pieces drawn from it, at times until the next move: the browser keeps it an hour,
+    // and the drawn avatars too, all at once in the profile's dialog.
+    const kept = type === types[".svg"] || type === types[".webp"];
+    send(response, 200, type, bytes, kept ? { "Cache-Control": "max-age=3600" } : {});
+}
+// The built page and core: dist/, from src/server/page and from dist/server/page alike.
+const built = fileURLToPath(new URL("../../../dist/", import.meta.url));
+// The modules the page imports from packages, by the names the import map gives them: a package, and its file.
+const vendorModules = {
+    "preact.js": ["preact", "dist/preact.module.js"],
+    "hooks.js": ["preact", "hooks/dist/hooks.module.js"],
+    "jsx-runtime.js": ["preact", "jsx-runtime/dist/jsxRuntime.module.js"],
+    "chess.js": ["chess.js", "dist/esm/chess.js"],
+};
+const importMap = JSON.stringify({
+    imports: { "preact": "/vendor/preact.js", "preact/hooks": "/vendor/hooks.js", "preact/jsx-runtime": "/vendor/jsx-runtime.js", "chess.js": "/vendor/chess.js" },
+});
+// The page runs only its own files and the import map written in it, known by its hash.
+const policy = `default-src 'self'; script-src 'self' 'sha256-${createHash("sha256").update(importMap).digest("base64")}'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; `
+    + "base-uri 'none'; form-action 'none'; frame-ancestors 'none'";
+const html = [
+    "<!doctype html>",
+    '<html lang="en">',
+    '<meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width, initial-scale=1">',
+    '<meta name="color-scheme" content="light dark">',
+    "<title>Chesspal</title>",
+    '<link rel="stylesheet" href="/page/style.css">',
+    `<script type="importmap">${importMap}</script>`,
+    '<script type="module" src="/page/main.js"></script>',
+    '<div id="app"></div>',
+    "",
+].join("\n");
+const types = { ".js": "text/javascript; charset=utf-8", ".css": "text/css; charset=utf-8", ".svg": "image/svg+xml", ".webp": "image/webp", ".json": "application/json; charset=utf-8", ".ogg": "audio/ogg" };
+function builtFile(path) {
+    const area = /^\/(page|core)\//.exec(path)?.[1];
+    if (area === undefined) {
+        return undefined;
+    }
+    try {
+        const root = join(built, area);
+        const file = resolve(built, `.${decodeURIComponent(path)}`);
+        const inside = relative(root, file);
+        return inside === "" || inside.startsWith("..") || isAbsolute(inside) ? undefined : file;
+    }
+    catch {
+        // An address that does not decode.
+        return undefined;
+    }
+}
+function vendorModule(name) {
+    const module = vendorModules[name];
+    if (module === undefined) {
+        return undefined;
+    }
+    try {
+        // The package's folder, from where its main file is: node_modules/<package>.
+        const main = createRequire(import.meta.url).resolve(module[0]);
+        const marker = join("node_modules", module[0]);
+        return join(main.slice(0, main.lastIndexOf(marker) + marker.length), module[1]);
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Served } from "./page.ts";
+/** Answers the page's requests about the game: true when the request was one. */
+export declare function answerGame(request: IncomingMessage, response: ServerResponse, url: URL, served: Served): boolean;
+/** The chat calls a tool: when nobody heard the player before, the AI's clock, held since, starts now, with the time it was held given back. */
+export declare function chatCalls(served: Served): void;