libroadcast-cli 2.4.2 → 2.6.0

package/.dockerignore

@@ -0,0 +1,5 @@
+.git
+.github
+
+dist
+node_modules

package/README.md

@@ -6,12 +6,6 @@ npm install -g libroadcast-cli
 
 ## Usage
 
-```bash
-libroadcast login
-
-libroadcast <command> [options]
-```
-
 ```bash
 Usage: <command> [options]
 
@@ -82,11 +76,12 @@ Commands:
      Options:
        --loop <intervalInSeconds>   Continuously push the PGN file at the specified interval in seconds.
 
-  pushFilterID <roundId> <PGNFromPathOrUrl> <FideIds...> [--loop <intervalInSeconds>]
+  pushFilterID <roundId> <PGNFromPathOrUrl> <FideIds...> [--loop <intervalInSeconds>] [--firstOngoing]
      Upload a PGN file from a local path or URL to the specified broadcast round, filtering games by FIDE ID.
      Note: The PGN file must be accessible from the provided path or URL.
      Options:
        --loop <intervalInSeconds>   Continuously push the PGN file at the specified interval in seconds.
+       --firstOngoing               Push the first ongoing games in each round.
 
 
 Examples:
@@ -117,3 +112,12 @@ Examples:
    # Push a PGN file from URL filtering by FIDE IDs in loop mode every 120 seconds
      $ pushFilterID round456 https://example.com/games.pgn 12345 67890 --loop 120
 ```
+
+### Test Docker Build Locally
+
+```bash
+docker build -t broadcast-cli .
+
+docker run --rm -it broadcast-cli bash
+  > libroadcast
+```

package/dist/cmd/push.js

@@ -1,67 +1,16 @@
 import { exit } from "node:process";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { client, msgCommonErrorHelp, sleep, checkTokenScopes, packageJson, } from "../utils/commandHandler.js";
+import { msgCommonErrorHelp, sleep, checkTokenScopes, } from "../utils/commandHandler.js";
 import { getBroadcastRound } from "../utils/getInfoBroadcast.js";
 import cl from "../utils/colors.js";
-const pushPGN = async (round, pgn) => {
-    try {
-        const res = await client
-            .POST("/api/broadcast/round/{broadcastRoundId}/push", {
-            params: {
-                path: { broadcastRoundId: round.id },
-            },
-            body: pgn,
-            bodySerializer: (body) => body,
-        })
-            .then((response) => response.data);
-        console.log(cl.green(`✓ Successfully pushed PGN for round ${cl.whiteBold(round.id)}.`));
-        console.table(res?.games.map((game, i) => {
-            return {
-                "Game #": i + 1,
-                "White Player": game.tags["White"] || "Unknown",
-                "Black Player": game.tags["Black"] || "Unknown",
-                Result: game.tags["Result"] || "Unknown",
-                "Ply Count": game.moves || "Unknown",
-                Error: game.error || "None",
-            };
-        }));
-    }
-    catch (error) {
-        console.error(cl.red(`Error pushing PGN for round ${cl.whiteBold(round.id)}:`), error);
-    }
-};
-const readPGNFromURL = async (pgnURL) => {
-    if (pgnURL.startsWith("http://") || pgnURL.startsWith("https://")) {
-        const response = await fetch(pgnURL, {
-            method: "GET",
-            headers: {
-                "User-Agent": packageJson.name + "/" + packageJson.version,
-            },
-        });
-        if (!response.ok) {
-            console.error(cl.red(`Failed to fetch PGN from URL: ${response.statusText}`));
-            return undefined;
-        }
-        const pgnText = await response.text();
-        return pgnText;
-    }
-    else {
-        const resolvedPath = path.resolve(pgnURL);
-        const stats = await readFile(resolvedPath, { encoding: "utf-8" }).catch((err) => {
-            console.error(cl.red(`Failed to read PGN file: ${err.message}`));
-            return undefined;
-        });
-        if (!stats)
-            return undefined;
-        return stats.toString();
-    }
-};
+import { pushPGN, readPGNFromURL, loopChecker } from "../utils/pushTools.js";
+let lastPGN = "";
 const loop = async (roundInfo, pgnPath, loopTimer) => {
     while (true) {
         const pgnContent = await readPGNFromURL(pgnPath);
-        if (pgnContent)
+        if (pgnContent && pgnContent !== lastPGN) {
             await pushPGN(roundInfo, pgnContent);
+            lastPGN = pgnContent;
+        }
         await sleep(loopTimer * 1000);
     }
 };
@@ -77,16 +26,7 @@ export const pushCommand = async (args) => {
         console.error(cl.red("Round not found."));
         exit(1);
     }
-    const loopArgIndex = args.findIndex((arg) => arg === "--loop");
-    let loopTimer = undefined;
-    if (loopArgIndex !== -1 && loopArgIndex + 1 < args.length) {
-        const loopTimerStr = args[loopArgIndex + 1];
-        loopTimer = parseInt(loopTimerStr, 10);
-        if (isNaN(loopTimer) || loopTimer <= 0) {
-            console.error(cl.red("Loop timer must be a positive integer."));
-            exit(1);
-        }
-    }
+    const loopTimer = loopChecker(args);
     if (loopTimer) {
         console.log(cl.green(`Starting loop to push PGN every ${cl.whiteBold(loopTimer.toString())} seconds...`));
         console.log(cl.blue("Press Ctrl+C to stop."));

package/dist/cmd/pushFilterID.js

@@ -1,40 +1,12 @@
 import { exit } from "node:process";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { client, msgCommonErrorHelp, sleep, checkTokenScopes, packageJson, } from "../utils/commandHandler.js";
+import { msgCommonErrorHelp, sleep, checkTokenScopes, } from "../utils/commandHandler.js";
 import { parsePgn, makePgn } from "chessops/pgn";
 import { getBroadcastRound } from "../utils/getInfoBroadcast.js";
 import cl from "../utils/colors.js";
-const pushPGN = async (round, pgn) => {
-    try {
-        const res = await client
-            .POST("/api/broadcast/round/{broadcastRoundId}/push", {
-            params: {
-                path: { broadcastRoundId: round.id },
-            },
-            body: pgn,
-            bodySerializer: (body) => body,
-        })
-            .then((response) => response.data);
-        console.log(cl.green(`✓ Successfully pushed PGN for round ${cl.whiteBold(round.id)}.`));
-        console.table(res?.games.map((game, i) => {
-            return {
-                "Game #": i + 1,
-                "White Player": game.tags["White"] || "Unknown",
-                "Black Player": game.tags["Black"] || "Unknown",
-                Result: game.tags["Result"] || "Unknown",
-                "Ply Count": game.moves ?? "Unknown",
-                Error: game.error || "None",
-            };
-        }));
-    }
-    catch (error) {
-        console.error(cl.red(`Error pushing PGN for round ${cl.whiteBold(round.id)}:`), error);
-    }
-};
-const filterPgnByIds = (pgn, filterIds) => {
+import { loopChecker, pushPGN, readPGNFromURL } from "../utils/pushTools.js";
+const filterPgnByIds = (pgn, filterIds, firstOngoing) => {
     const parsed = parsePgn(pgn);
-    const filteredGames = parsed.filter((game) => {
+    let filteredGames = parsed.filter((game) => {
         const whiteFideId = game.headers.get("WhiteFideId");
         const blackFideId = game.headers.get("BlackFideId");
         if (filterIds.length > 1) {
@@ -54,46 +26,32 @@ const filterPgnByIds = (pgn, filterIds) => {
                 filterIds.includes(parseInt(blackFideId || "", 10)));
         }
     });
-    return filteredGames.map((game) => makePgn(game)).join("\n\n");
-};
-const readPGNFromURL = async (pgnURL, filterIds) => {
-    if (pgnURL.startsWith("http://") || pgnURL.startsWith("https://")) {
-        const response = await fetch(pgnURL, {
-            method: "GET",
-            headers: {
-                "User-Agent": packageJson.name + "/" + packageJson.version,
-            },
+    if (firstOngoing) {
+        const ongoingGames = filteredGames.filter((game) => {
+            const result = game.headers.get("Result");
+            return !result || result === "*";
         });
-        if (!response.ok) {
-            console.error(cl.red(`Failed to fetch PGN from URL: ${response.statusText}`));
-            return undefined;
-        }
-        const pgnText = await response.text();
-        const filteredPgn = filterPgnByIds(pgnText, filterIds);
-        if (!filteredPgn) {
-            console.error(cl.red(`No games found matching the provided filter IDs.`));
-            return undefined;
-        }
-        return filteredPgn;
-    }
-    else {
-        const resolvedPath = path.resolve(pgnURL);
-        const stats = await readFile(resolvedPath, { encoding: "utf-8" }).catch((err) => {
-            console.error(cl.red(`Failed to read PGN file: ${err.message}`));
-            return undefined;
+        const gamesFinished = filteredGames.filter((game) => {
+            const result = game.headers.get("Result");
+            return result && result !== "*";
         });
-        if (!stats)
-            return undefined;
-        return stats.toString();
+        filteredGames = [...ongoingGames, ...gamesFinished];
     }
+    return filteredGames.map((game) => makePgn(game)).join("\n\n");
 };
 let lastPGN = "";
-const loop = async (roundInfo, pgnPath, loopTimer, filterIds) => {
+const loop = async (roundInfo, pgnPath, loopTimer, filterIds, firstOngoing) => {
     while (true) {
-        const pgnContent = await readPGNFromURL(pgnPath, filterIds);
-        if (pgnContent && pgnContent !== lastPGN) {
-            await pushPGN(roundInfo, pgnContent);
-            lastPGN = pgnContent;
+        const pgnContent = await readPGNFromURL(pgnPath);
+        if (!pgnContent) {
+            console.error(cl.red(`Failed to read PGN content. Retrying in ${loopTimer} seconds...`));
+            await sleep(loopTimer * 1000);
+            continue;
+        }
+        const filteredPgn = filterPgnByIds(pgnContent, filterIds, firstOngoing);
+        if (filteredPgn && filteredPgn !== lastPGN) {
+            await pushPGN(roundInfo, filteredPgn);
+            lastPGN = filteredPgn;
         }
         await sleep(loopTimer * 1000);
     }
@@ -114,24 +72,21 @@ export const pushFilterIDCommand = async (args) => {
         console.error(cl.red("Round not found."));
         exit(1);
     }
-    const loopArgIndex = args.findIndex((arg) => arg === "--loop");
-    let loopTimer = undefined;
-    if (loopArgIndex !== -1 && loopArgIndex + 1 < args.length) {
-        const loopTimerStr = args[loopArgIndex + 1];
-        loopTimer = parseInt(loopTimerStr, 10);
-        if (isNaN(loopTimer) || loopTimer <= 0) {
-            console.error(cl.red("Loop timer must be a positive integer."));
-            exit(1);
-        }
-    }
+    const firstOngoing = args.includes("--firstOngoing");
+    const loopTimer = loopChecker(args);
     if (loopTimer) {
         console.log(cl.green(`Starting loop to push PGN every ${cl.whiteBold(loopTimer.toString())} seconds...`));
         console.log(cl.blue("Press Ctrl+C to stop."));
-        await loop(roundInfo, pgnPath, loopTimer, filterIds);
+        await loop(roundInfo, pgnPath, loopTimer, filterIds, firstOngoing);
     }
     else {
-        const pgnContent = await readPGNFromURL(pgnPath, filterIds);
-        if (pgnContent)
-            await pushPGN(roundInfo, pgnContent);
+        const pgnContent = await readPGNFromURL(pgnPath);
+        if (!pgnContent) {
+            console.error(cl.red(`Failed to read PGN content.`));
+            exit(1);
+        }
+        const filteredPgn = filterPgnByIds(pgnContent, filterIds, firstOngoing);
+        if (filteredPgn)
+            await pushPGN(roundInfo, filteredPgn);
     }
 };

package/dist/utils/help.js

@@ -76,11 +76,12 @@ const helpPush = [
     `       --loop <intervalInSeconds>   ${cl.gray("Continuously push the PGN file at the specified interval in seconds.")}`,
 ].join("\n");
 const helpPushFilterID = [
-    `  ${cl.underItalic("pushFilterID <roundId> <PGNFromPathOrUrl> <FideIds...> [--loop <intervalInSeconds>]")}`,
+    `  ${cl.underItalic("pushFilterID <roundId> <PGNFromPathOrUrl> <FideIds...> [--loop <intervalInSeconds>] [--firstOngoing]")}`,
     `     ${cl.gray("Upload a PGN file from a local path or URL to the specified broadcast round, filtering games by FIDE ID.")}`,
     `     ${cl.bold("Note:")} ${cl.gray("The PGN file must be accessible from the provided path or URL.")}`,
     `     ${cl.bold("Options:")}`,
     `       --loop <intervalInSeconds>   ${cl.gray("Continuously push the PGN file at the specified interval in seconds.")}`,
+    `       --firstOngoing               ${cl.gray("Push the first ongoing games in each round.")}`,
 ].join("\n");
 const msg = [
     `${cl.boldYellow("Usage:")} ${cl.underItalic("<command> [options]")}`,

package/dist/utils/pushTools.js

@@ -0,0 +1,76 @@
+import { client, packageJson } from "./commandHandler.js";
+import cl from "./colors.js";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { exit } from "node:process";
+export const pushPGN = async (round, pgn) => {
+    try {
+        const res = await client
+            .POST("/api/broadcast/round/{broadcastRoundId}/push", {
+            params: {
+                path: { broadcastRoundId: round.id },
+            },
+            body: pgn,
+            bodySerializer: (body) => body,
+        })
+            .then((response) => response.data);
+        console.log(cl.green(`✓ Successfully pushed PGN for round ${cl.whiteBold(round.id)}.`));
+        console.table(res?.games
+            .map((game, i) => {
+            return {
+                id: i + 1,
+                "White Player": game.tags["White"] || "Unknown",
+                "Black Player": game.tags["Black"] || "Unknown",
+                Result: game.tags["Result"] || "Unknown",
+                "Ply Count": game.moves ?? "Unknown",
+                Error: game.error || "None",
+            };
+        })
+            .reduce((acc, { id, ...rest }) => {
+            acc[id] = rest;
+            return acc;
+        }, {}));
+    }
+    catch (error) {
+        console.error(cl.red(`Error pushing PGN for round ${cl.whiteBold(round.id)}:`), error);
+    }
+};
+export const readPGNFromURL = async (pgnURL) => {
+    if (pgnURL.startsWith("http://") || pgnURL.startsWith("https://")) {
+        const response = await fetch(pgnURL, {
+            method: "GET",
+            headers: {
+                "User-Agent": packageJson.name + "/" + packageJson.version,
+            },
+        });
+        if (!response.ok) {
+            console.error(cl.red(`Failed to fetch PGN from URL: ${response.statusText}`));
+            return undefined;
+        }
+        const pgnText = await response.text();
+        return pgnText;
+    }
+    else {
+        const resolvedPath = path.resolve(pgnURL);
+        const stats = await readFile(resolvedPath, { encoding: "utf-8" }).catch((err) => {
+            console.error(cl.red(`Failed to read PGN file: ${err.message}`));
+            return undefined;
+        });
+        if (!stats)
+            return undefined;
+        return stats.toString();
+    }
+};
+export const loopChecker = (args) => {
+    const loopArgIndex = args.findIndex((arg) => arg === "--loop");
+    let loopTimer = undefined;
+    if (loopArgIndex !== -1 && loopArgIndex + 1 < args.length) {
+        const loopTimerStr = args[loopArgIndex + 1];
+        loopTimer = parseInt(loopTimerStr, 10);
+        if (isNaN(loopTimer) || loopTimer <= 0) {
+            console.error(cl.red("Loop timer must be a positive integer."));
+            exit(1);
+        }
+    }
+    return loopTimer;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libroadcast-cli",
-  "version": "2.4.2",
+  "version": "2.6.0",
   "description": "CLI to help with broadcast maintenance on Lichess",
   "main": "dist/index.js",
   "keywords": [