libroadcast-cli 2.3.0 → 2.4.1

package/README.md

@@ -82,6 +82,12 @@ Commands:
      Options:
        --loop <intervalInSeconds>   Continuously push the PGN file at the specified interval in seconds.
 
+  pushFilterID <roundId> <PGNFromPathOrUrl> <FideIds...> [--loop <intervalInSeconds>]
+     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.
+
 
 Examples:
    # Login with your Lichess token (interactive)
@@ -108,4 +114,6 @@ Examples:
      $ score bcast123 1.0 0.5 1.0 0.5
    # Push a PGN file in loop mode every 60 seconds
      $ push round456 /path/to/localfile.pgn --loop 60
+   # 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
 ```

package/dist/cmd/delay.js

@@ -1,19 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.delayCommand = void 0;
-const node_process_1 = require("node:process");
-const commandHandler_1 = require("../utils/commandHandler");
-const getInfoBroadcast_1 = require("../utils/getInfoBroadcast");
-const colors_1 = __importDefault(require("../utils/colors"));
+import { exit } from "node:process";
+import { client, msgCommonErrorHelp, sleep, handleApiResponse, translateRoundsToFix, checkTokenScopes, } from "../utils/commandHandler.js";
+import { getBroadcast } from "../utils/getInfoBroadcast.js";
+import cl from "../utils/colors.js";
 const setDelayRounds = async (rounds, delay, onlyDelay, noDelay, roundsToFix) => {
     let filteredRounds = rounds.filter((_, i) => !roundsToFix?.length || roundsToFix.includes(i + 1));
     if (filteredRounds.length === 0)
         filteredRounds = rounds;
     for (const round of filteredRounds) {
-        await (0, commandHandler_1.handleApiResponse)(commandHandler_1.client.POST("/broadcast/round/{broadcastRoundId}/edit", {
+        await handleApiResponse(client.POST("/broadcast/round/{broadcastRoundId}/edit", {
             params: {
                 path: { broadcastRoundId: round.id },
                 query: { patch: 1 },
@@ -24,39 +18,38 @@ const setDelayRounds = async (rounds, delay, onlyDelay, noDelay, roundsToFix) =>
                     ? round.startsAt + delay * 1000
                     : undefined,
             },
-        }), `Successfully set delay for round ${colors_1.default.whiteBold(round.id)} to ${colors_1.default.whiteBold(delay.toString())} seconds.`, `Error setting delay for round ${colors_1.default.whiteBold(round.id)}`);
-        await (0, commandHandler_1.sleep)(200);
+        }), `Successfully set delay for round ${cl.whiteBold(round.id)} to ${cl.whiteBold(delay.toString())} seconds.`, `Error setting delay for round ${cl.whiteBold(round.id)}`);
+        await sleep(200);
     }
 };
-const delayCommand = async (args) => {
-    await (0, commandHandler_1.checkTokenScopes)();
+export const delayCommand = async (args) => {
+    await checkTokenScopes();
     const [broadcastId, delay] = args.slice(0, 2);
     if (!broadcastId || !delay) {
-        (0, commandHandler_1.msgCommonErrorHelp)("Broadcast ID and delay are required.");
-        (0, node_process_1.exit)(1);
+        msgCommonErrorHelp("Broadcast ID and delay are required.");
+        exit(1);
     }
     const delayNum = parseInt(delay, 10);
     if (isNaN(delayNum) || delayNum < 0 || delayNum > 3600) {
-        (0, commandHandler_1.msgCommonErrorHelp)("Delay must be a number between 0 and 3600 seconds.");
-        (0, node_process_1.exit)(1);
+        msgCommonErrorHelp("Delay must be a number between 0 and 3600 seconds.");
+        exit(1);
     }
     const onlyDelay = args.includes("--onlyDelay");
     const noDelay = args.includes("--noDelay");
     if (onlyDelay && noDelay) {
-        console.error(colors_1.default.red("Cannot use --onlyDelay and --noDelay together."));
-        (0, node_process_1.exit)(1);
+        console.error(cl.red("Cannot use --onlyDelay and --noDelay together."));
+        exit(1);
     }
     const roundsArgIndex = args.findIndex((arg) => arg === "--rounds");
     let roundsToFix = undefined;
     if (roundsArgIndex !== -1 && roundsArgIndex + 1 < args.length) {
         const roundsArg = args[roundsArgIndex + 1];
-        roundsToFix = roundsArg ? (0, commandHandler_1.translateRoundsToFix)(roundsArg) : undefined;
+        roundsToFix = roundsArg ? translateRoundsToFix(roundsArg) : undefined;
     }
-    const broadcast = await (0, getInfoBroadcast_1.getBroadcast)(broadcastId);
+    const broadcast = await getBroadcast(broadcastId);
     if (!broadcast?.rounds || broadcast.rounds.length === 0) {
-        console.error(colors_1.default.red("No rounds found for the specified broadcast."));
-        (0, node_process_1.exit)(1);
+        console.error(cl.red("No rounds found for the specified broadcast."));
+        exit(1);
     }
     await setDelayRounds(broadcast.rounds, delayNum, onlyDelay, noDelay, roundsToFix);
 };
-exports.delayCommand = delayCommand;

package/dist/cmd/fixSchedule.js

@@ -1,24 +1,18 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fixScheduleCommand = void 0;
-const node_process_1 = require("node:process");
-const commandHandler_1 = require("../utils/commandHandler");
-const getInfoBroadcast_1 = require("../utils/getInfoBroadcast");
-const colors_1 = __importDefault(require("../utils/colors"));
-const ms_1 = require("ms");
+import { exit } from "node:process";
+import { client, msgCommonErrorHelp, sleep, handleApiResponse, translateRoundsToFix, checkTokenScopes, } from "../utils/commandHandler.js";
+import { getBroadcast } from "../utils/getInfoBroadcast.js";
+import cl from "../utils/colors.js";
+import { parse as ms } from "ms";
 const fixScheduleRounds = async (rounds, timeDiff, roundsToFix) => {
     rounds = rounds
         .filter((_, i) => !roundsToFix?.length || roundsToFix.includes(i + 1))
         .filter((el) => el.startsAt !== undefined);
     if (rounds.length === 0) {
-        console.error(colors_1.default.red("No rounds to fix after applying filters."));
-        (0, node_process_1.exit)(1);
+        console.error(cl.red("No rounds to fix after applying filters."));
+        exit(1);
     }
     for (const round of rounds) {
-        await (0, commandHandler_1.handleApiResponse)(commandHandler_1.client.POST("/broadcast/round/{broadcastRoundId}/edit", {
+        await handleApiResponse(client.POST("/broadcast/round/{broadcastRoundId}/edit", {
             params: {
                 path: { broadcastRoundId: round.id },
                 query: { patch: 1 },
@@ -26,34 +20,33 @@ const fixScheduleRounds = async (rounds, timeDiff, roundsToFix) => {
             body: {
                 startsAt: round.startsAt + timeDiff,
             },
-        }), `Successfully fixed schedule for round ${colors_1.default.whiteBold(round.id)}.`, `Error fixing schedule for round ${colors_1.default.whiteBold(round.id)}`);
-        await (0, commandHandler_1.sleep)(200);
+        }), `Successfully fixed schedule for round ${cl.whiteBold(round.id)}.`, `Error fixing schedule for round ${cl.whiteBold(round.id)}`);
+        await sleep(200);
     }
 };
-const fixScheduleCommand = async (args) => {
-    await (0, commandHandler_1.checkTokenScopes)();
+export const fixScheduleCommand = async (args) => {
+    await checkTokenScopes();
     const [broadcastId, timeDiffStr] = args.slice(0, 2);
     if (!broadcastId || !timeDiffStr) {
-        (0, commandHandler_1.msgCommonErrorHelp)("Broadcast ID and time difference are required.");
-        (0, node_process_1.exit)(1);
+        msgCommonErrorHelp("Broadcast ID and time difference are required.");
+        exit(1);
     }
-    const timeDiff = (0, ms_1.parse)(timeDiffStr);
+    const timeDiff = ms(timeDiffStr);
     if (isNaN(timeDiff)) {
-        console.error(colors_1.default.red("Error: Time difference must be a valid duration string (e.g., '1h', '30m', '15s')."));
-        (0, node_process_1.exit)(1);
+        console.error(cl.red("Error: Time difference must be a valid duration string (e.g., '1h', '30m', '15s')."));
+        exit(1);
     }
-    console.log(`Applying time difference of ${colors_1.default.whiteBold(timeDiffStr)} (${colors_1.default.whiteBold(timeDiff.toString())} ms) to broadcast ${colors_1.default.whiteBold(broadcastId)}.`);
+    console.log(`Applying time difference of ${cl.whiteBold(timeDiffStr)} (${cl.whiteBold(timeDiff.toString())} ms) to broadcast ${cl.whiteBold(broadcastId)}.`);
     const roundsArgIndex = args.findIndex((arg) => arg === "--rounds");
     let roundsToFix = undefined;
     if (roundsArgIndex !== -1 && roundsArgIndex + 1 < args.length) {
         const roundsArg = args[roundsArgIndex + 1];
-        roundsToFix = roundsArg ? (0, commandHandler_1.translateRoundsToFix)(roundsArg) : undefined;
+        roundsToFix = roundsArg ? translateRoundsToFix(roundsArg) : undefined;
     }
-    const broadcast = await (0, getInfoBroadcast_1.getBroadcast)(broadcastId);
+    const broadcast = await getBroadcast(broadcastId);
     if (!broadcast?.rounds || broadcast.rounds.length === 0) {
-        console.error(colors_1.default.red(`Broadcast with ID ${colors_1.default.whiteBold(broadcastId)} not found or has no rounds.`));
-        (0, node_process_1.exit)(1);
+        console.error(cl.red(`Broadcast with ID ${cl.whiteBold(broadcastId)} not found or has no rounds.`));
+        exit(1);
     }
     await fixScheduleRounds(broadcast.rounds, timeDiff, roundsToFix);
 };
-exports.fixScheduleCommand = fixScheduleCommand;

package/dist/cmd/login.js

@@ -1,23 +1,17 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loginCommand = void 0;
-const node_process_1 = require("node:process");
-const node_readline_1 = require("node:readline");
-const credentials_1 = require("../utils/credentials");
-const colors_1 = __importDefault(require("../utils/colors"));
-const loginCommand = async (args) => {
+import { exit } from "node:process";
+import { createInterface } from "node:readline";
+import { saveCredentials, clearCredentials, fetchTokenScopes, } from "../utils/credentials.js";
+import cl from "../utils/colors.js";
+export const loginCommand = async (args) => {
     if (args.includes("--logout") || args.includes("-lo")) {
         try {
-            (0, credentials_1.clearCredentials)();
-            console.log(colors_1.default.green("✓ Credentials cleared successfully. You are now logged out."));
+            clearCredentials();
+            console.log(cl.green("✓ Credentials cleared successfully. You are now logged out."));
             return;
         }
         catch (error) {
-            console.error(colors_1.default.red("Error clearing credentials:"), error);
-            (0, node_process_1.exit)(1);
+            console.error(cl.red("Error clearing credentials:"), error);
+            exit(1);
         }
     }
     try {
@@ -25,7 +19,7 @@ const loginCommand = async (args) => {
         let token = positionalArgs[0];
         let domain = positionalArgs[1] || "https://lichess.org";
         if (!token) {
-            const readline = (0, node_readline_1.createInterface)({
+            const readline = createInterface({
                 input: process.stdin,
                 output: process.stdout,
             });
@@ -36,59 +30,58 @@ const loginCommand = async (args) => {
                     });
                 });
             };
-            console.log(colors_1.default.whiteBold("Lichess Token Login"));
-            console.log(colors_1.default.blue("Please enter your Lichess token \n" +
+            console.log(cl.whiteBold("Lichess Token Login"));
+            console.log(cl.blue("Please enter your Lichess token \n" +
                 "You can generate one at https://lichess.org/account/oauth/token/create?scopes[]=study:write&scopes[]=study:read&scopes[]=web:mod&description=Broadcast+CLI"));
             console.log("");
-            token = await question(colors_1.default.whiteBold("Lichess Token: "));
+            token = await question(cl.whiteBold("Lichess Token: "));
             if (!token?.trim()) {
-                console.error(colors_1.default.red("Error: Token cannot be empty."));
+                console.error(cl.red("Error: Token cannot be empty."));
                 readline.close();
-                (0, node_process_1.exit)(1);
+                exit(1);
             }
             if (!token.startsWith("lip_")) {
-                console.error(colors_1.default.red("Error: Invalid token format. Token must start with 'lip_'. Please check your token."));
+                console.error(cl.red("Error: Invalid token format. Token must start with 'lip_'. Please check your token."));
                 readline.close();
-                (0, node_process_1.exit)(1);
+                exit(1);
             }
             domain =
-                (await question(colors_1.default.whiteBold("Lichess Domain (default: https://lichess.org): "))) || "https://lichess.org";
+                (await question(cl.whiteBold("Lichess Domain (default: https://lichess.org): "))) || "https://lichess.org";
             readline.close();
         }
         else {
             if (!token.startsWith("lip_")) {
-                console.error(colors_1.default.red("Error: Invalid token format. Token must start with 'lip_'. Please check your token."));
-                (0, node_process_1.exit)(1);
+                console.error(cl.red("Error: Invalid token format. Token must start with 'lip_'. Please check your token."));
+                exit(1);
             }
         }
         domain = domain.replace(/\/$/, "");
         const skipValidation = args.includes("--skip-validation");
         let scopes = [];
         if (!skipValidation) {
-            console.log(colors_1.default.blue("Validating token and fetching scopes..."));
+            console.log(cl.blue("Validating token and fetching scopes..."));
             try {
-                scopes = await (0, credentials_1.fetchTokenScopes)(token, domain);
-                console.log(colors_1.default.green(`✓ Token valid with scopes: ${scopes.join(", ")}`));
+                scopes = await fetchTokenScopes(token, domain);
+                console.log(cl.green(`✓ Token valid with scopes: ${scopes.join(", ")}`));
             }
             catch (error) {
-                console.error(colors_1.default.red(`Error: Failed to validate token: ${error instanceof Error ? error.message : String(error)}`));
-                (0, node_process_1.exit)(1);
+                console.error(cl.red(`Error: Failed to validate token: ${error instanceof Error ? error.message : String(error)}`));
+                exit(1);
             }
         }
         else {
-            console.log(colors_1.default.blue("Skipping token validation..."));
+            console.log(cl.blue("Skipping token validation..."));
         }
-        (0, credentials_1.saveCredentials)({
+        saveCredentials({
             lichessToken: token,
             lichessDomain: domain,
             scopes: scopes,
         });
         console.log("");
-        console.log(colors_1.default.green("✓ Credentials saved successfully! You can now use the CLI without setting environment variables."));
+        console.log(cl.green("✓ Credentials saved successfully! You can now use the CLI without setting environment variables."));
     }
     catch (error) {
-        console.error(colors_1.default.red("Error during login:"), error);
-        (0, node_process_1.exit)(1);
+        console.error(cl.red("Error during login:"), error);
+        exit(1);
     }
 };
-exports.loginCommand = loginCommand;

package/dist/cmd/period.js

@@ -1,19 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.periodCommand = void 0;
-const node_process_1 = require("node:process");
-const commandHandler_1 = require("../utils/commandHandler");
-const getInfoBroadcast_1 = require("../utils/getInfoBroadcast");
-const colors_1 = __importDefault(require("../utils/colors"));
+import { exit } from "node:process";
+import { client, msgCommonErrorHelp, sleep, handleApiResponse, translateRoundsToFix, checkTokenScopes, } from "../utils/commandHandler.js";
+import { getBroadcast } from "../utils/getInfoBroadcast.js";
+import cl from "../utils/colors.js";
 const setPeriodRounds = async (rounds, period, roundsToFix) => {
     let filteredRounds = rounds.filter((_, i) => !roundsToFix?.length || roundsToFix.includes(i + 1));
     if (filteredRounds.length === 0)
         filteredRounds = rounds;
     for (const round of filteredRounds) {
-        await (0, commandHandler_1.handleApiResponse)(commandHandler_1.client.POST("/broadcast/round/{broadcastRoundId}/edit", {
+        await handleApiResponse(client.POST("/broadcast/round/{broadcastRoundId}/edit", {
             params: {
                 path: { broadcastRoundId: round.id },
                 query: { patch: 1 },
@@ -21,33 +15,32 @@ const setPeriodRounds = async (rounds, period, roundsToFix) => {
             body: {
                 period: period,
             },
-        }), `Successfully set period for round ${colors_1.default.whiteBold(round.id)} to ${colors_1.default.whiteBold(period.toString())} seconds.`, `Error setting period for round ${colors_1.default.whiteBold(round.id)}`);
-        await (0, commandHandler_1.sleep)(200);
+        }), `Successfully set period for round ${cl.whiteBold(round.id)} to ${cl.whiteBold(period.toString())} seconds.`, `Error setting period for round ${cl.whiteBold(round.id)}`);
+        await sleep(200);
     }
 };
-const periodCommand = async (args) => {
-    await (0, commandHandler_1.checkTokenScopes)(true);
+export const periodCommand = async (args) => {
+    await checkTokenScopes(true);
     const [broadcastId, period] = args.slice(0, 2);
     if (!broadcastId || !period) {
-        (0, commandHandler_1.msgCommonErrorHelp)("Broadcast ID and period are required.");
-        (0, node_process_1.exit)(1);
+        msgCommonErrorHelp("Broadcast ID and period are required.");
+        exit(1);
     }
     const periodNum = parseInt(period, 10);
     if (isNaN(periodNum) || periodNum < 2 || periodNum > 60) {
-        (0, commandHandler_1.msgCommonErrorHelp)("Period must be a number between 2 and 60 seconds.");
-        (0, node_process_1.exit)(1);
+        msgCommonErrorHelp("Period must be a number between 2 and 60 seconds.");
+        exit(1);
     }
     const roundsArgIndex = args.findIndex((arg) => arg === "--rounds");
     let roundsToFix = undefined;
     if (roundsArgIndex !== -1 && roundsArgIndex + 1 < args.length) {
         const roundsArg = args[roundsArgIndex + 1];
-        roundsToFix = roundsArg ? (0, commandHandler_1.translateRoundsToFix)(roundsArg) : undefined;
+        roundsToFix = roundsArg ? translateRoundsToFix(roundsArg) : undefined;
     }
-    const broadcast = await (0, getInfoBroadcast_1.getBroadcast)(broadcastId);
+    const broadcast = await getBroadcast(broadcastId);
     if (!broadcast?.rounds || broadcast.rounds.length === 0) {
-        console.error(colors_1.default.red("No rounds found for the specified broadcast."));
-        (0, node_process_1.exit)(1);
+        console.error(cl.red("No rounds found for the specified broadcast."));
+        exit(1);
     }
     await setPeriodRounds(broadcast.rounds, periodNum, roundsToFix);
 };
-exports.periodCommand = periodCommand;

package/dist/cmd/push.js

@@ -1,18 +1,12 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pushCommand = void 0;
-const node_process_1 = require("node:process");
-const promises_1 = require("node:fs/promises");
-const node_path_1 = __importDefault(require("node:path"));
-const commandHandler_1 = require("../utils/commandHandler");
-const getInfoBroadcast_1 = require("../utils/getInfoBroadcast");
-const colors_1 = __importDefault(require("../utils/colors"));
+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 { getBroadcastRound } from "../utils/getInfoBroadcast.js";
+import cl from "../utils/colors.js";
 const pushPGN = async (round, pgn) => {
     try {
-        const res = await commandHandler_1.client
+        const res = await client
             .POST("/api/broadcast/round/{broadcastRoundId}/push", {
             params: {
                 path: { broadcastRoundId: round.id },
@@ -21,7 +15,7 @@ const pushPGN = async (round, pgn) => {
             bodySerializer: (body) => body,
         })
             .then((response) => response.data);
-        console.log(colors_1.default.green(`✓ Successfully pushed PGN for round ${colors_1.default.whiteBold(round.id)}.`));
+        console.log(cl.green(`✓ Successfully pushed PGN for round ${cl.whiteBold(round.id)}.`));
         console.table(res?.games.map((game, i) => {
             return {
                 "Game #": i + 1,
@@ -34,7 +28,7 @@ const pushPGN = async (round, pgn) => {
         }));
     }
     catch (error) {
-        console.error(colors_1.default.red(`Error pushing PGN for round ${colors_1.default.whiteBold(round.id)}:`), error);
+        console.error(cl.red(`Error pushing PGN for round ${cl.whiteBold(round.id)}:`), error);
     }
 };
 const readPGNFromURL = async (pgnURL) => {
@@ -42,20 +36,20 @@ const readPGNFromURL = async (pgnURL) => {
         const response = await fetch(pgnURL, {
             method: "GET",
             headers: {
-                "User-Agent": commandHandler_1.packageJson.name + "/" + commandHandler_1.packageJson.version,
+                "User-Agent": packageJson.name + "/" + packageJson.version,
             },
         });
         if (!response.ok) {
-            console.error(colors_1.default.red(`Failed to fetch PGN from URL: ${response.statusText}`));
+            console.error(cl.red(`Failed to fetch PGN from URL: ${response.statusText}`));
             return undefined;
         }
         const pgnText = await response.text();
         return pgnText;
     }
     else {
-        const resolvedPath = node_path_1.default.resolve(pgnURL);
-        const stats = await (0, promises_1.readFile)(resolvedPath, { encoding: "utf-8" }).catch((err) => {
-            console.error(colors_1.default.red(`Failed to read PGN file: ${err.message}`));
+        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)
@@ -68,20 +62,20 @@ const loop = async (roundInfo, pgnPath, loopTimer) => {
         const pgnContent = await readPGNFromURL(pgnPath);
         if (pgnContent)
             await pushPGN(roundInfo, pgnContent);
-        await (0, commandHandler_1.sleep)(loopTimer * 1000);
+        await sleep(loopTimer * 1000);
     }
 };
-const pushCommand = async (args) => {
-    await (0, commandHandler_1.checkTokenScopes)();
+export const pushCommand = async (args) => {
+    await checkTokenScopes();
     const [roundId, pgnPath] = args.slice(0, 2);
     if (!roundId || !pgnPath) {
-        (0, commandHandler_1.msgCommonErrorHelp)("Round ID and PGN are required.");
-        (0, node_process_1.exit)(1);
+        msgCommonErrorHelp("Round ID and PGN are required.");
+        exit(1);
     }
-    const roundInfo = await (0, getInfoBroadcast_1.getBroadcastRound)(roundId);
+    const roundInfo = await getBroadcastRound(roundId);
     if (!roundInfo) {
-        console.error(colors_1.default.red("Round not found."));
-        (0, node_process_1.exit)(1);
+        console.error(cl.red("Round not found."));
+        exit(1);
     }
     const loopArgIndex = args.findIndex((arg) => arg === "--loop");
     let loopTimer = undefined;
@@ -89,13 +83,13 @@ const pushCommand = async (args) => {
         const loopTimerStr = args[loopArgIndex + 1];
         loopTimer = parseInt(loopTimerStr, 10);
         if (isNaN(loopTimer) || loopTimer <= 0) {
-            console.error(colors_1.default.red("Loop timer must be a positive integer."));
-            (0, node_process_1.exit)(1);
+            console.error(cl.red("Loop timer must be a positive integer."));
+            exit(1);
         }
     }
     if (loopTimer) {
-        console.log(colors_1.default.green(`Starting loop to push PGN every ${colors_1.default.whiteBold(loopTimer.toString())} seconds...`));
-        console.log(colors_1.default.blue("Press Ctrl+C to stop."));
+        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);
     }
     else {
@@ -104,4 +98,3 @@ const pushCommand = async (args) => {
             await pushPGN(roundInfo, pgnContent);
     }
 };
-exports.pushCommand = pushCommand;

package/dist/cmd/pushFilterID.js

@@ -0,0 +1,134 @@
+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 { 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) => {
+    const parsed = parsePgn(pgn);
+    const filteredGames = parsed.filter((game) => {
+        const whiteFideId = game.headers.get("WhiteFideId");
+        const blackFideId = game.headers.get("BlackFideId");
+        if (filterIds.length > 1) {
+            for (let i = 0; i < filterIds.length; i += 2) {
+                const whiteId = filterIds[i];
+                const blackId = filterIds[i + 1];
+                if ((whiteFideId === String(whiteId) &&
+                    blackFideId === String(blackId)) ||
+                    (whiteFideId === String(blackId) && blackFideId === String(whiteId))) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        else {
+            return (filterIds.includes(parseInt(whiteFideId || "", 10)) ||
+                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 (!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;
+        });
+        if (!stats)
+            return undefined;
+        return stats.toString();
+    }
+};
+const loop = async (roundInfo, pgnPath, loopTimer, filterIds) => {
+    while (true) {
+        const pgnContent = await readPGNFromURL(pgnPath, filterIds);
+        if (pgnContent)
+            await pushPGN(roundInfo, pgnContent);
+        await sleep(loopTimer * 1000);
+    }
+};
+export const pushFilterIDCommand = async (args) => {
+    await checkTokenScopes();
+    const [roundId, pgnPath] = args.slice(0, 2);
+    const filterIds = args
+        .slice(2)
+        .filter((arg) => !arg.startsWith("--") && Number.isInteger(parseInt(arg)))
+        .map((arg) => parseInt(arg, 10));
+    if (!roundId || !pgnPath || filterIds.length === 0) {
+        msgCommonErrorHelp("Round ID, PGN, and at least one filter ID are required.");
+        exit(1);
+    }
+    const roundInfo = await getBroadcastRound(roundId);
+    if (!roundInfo) {
+        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);
+        }
+    }
+    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);
+    }
+    else {
+        const pgnContent = await readPGNFromURL(pgnPath, filterIds);
+        if (pgnContent)
+            await pushPGN(roundInfo, pgnContent);
+    }
+};