libroadcast-cli 2.4.0 → 2.4.2

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

@@ -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.pushFilterIDCommand = 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 pgn_1 = require("chessops/pgn");
-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 { 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 commandHandler_1.client
+        const res = await client
             .POST("/api/broadcast/round/{broadcastRoundId}/push", {
             params: {
                 path: { broadcastRoundId: round.id },
@@ -22,24 +16,24 @@ 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,
                 "White Player": game.tags["White"] || "Unknown",
                 "Black Player": game.tags["Black"] || "Unknown",
                 Result: game.tags["Result"] || "Unknown",
-                "Ply Count": game.moves || "Unknown",
+                "Ply Count": game.moves ?? "Unknown",
                 Error: game.error || "None",
             };
         }));
     }
     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 filterPgnByIds = (pgn, filterIds) => {
-    const parsed = (0, pgn_1.parsePgn)(pgn);
+    const parsed = parsePgn(pgn);
     const filteredGames = parsed.filter((game) => {
         const whiteFideId = game.headers.get("WhiteFideId");
         const blackFideId = game.headers.get("BlackFideId");
@@ -60,32 +54,32 @@ const filterPgnByIds = (pgn, filterIds) => {
                 filterIds.includes(parseInt(blackFideId || "", 10)));
         }
     });
-    return filteredGames.map((game) => (0, pgn_1.makePgn)(game)).join("\n\n");
+    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": 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();
         const filteredPgn = filterPgnByIds(pgnText, filterIds);
         if (!filteredPgn) {
-            console.error(colors_1.default.red(`No games found matching the provided filter IDs.`));
+            console.error(cl.red(`No games found matching the provided filter IDs.`));
             return undefined;
         }
         return filteredPgn;
     }
     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)
@@ -93,29 +87,32 @@ const readPGNFromURL = async (pgnURL, filterIds) => {
         return stats.toString();
     }
 };
+let lastPGN = "";
 const loop = async (roundInfo, pgnPath, loopTimer, filterIds) => {
     while (true) {
         const pgnContent = await readPGNFromURL(pgnPath, filterIds);
-        if (pgnContent)
+        if (pgnContent && pgnContent !== lastPGN) {
             await pushPGN(roundInfo, pgnContent);
-        await (0, commandHandler_1.sleep)(loopTimer * 1000);
+            lastPGN = pgnContent;
+        }
+        await sleep(loopTimer * 1000);
     }
 };
-const pushFilterIDCommand = async (args) => {
-    await (0, commandHandler_1.checkTokenScopes)();
+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) {
-        (0, commandHandler_1.msgCommonErrorHelp)("Round ID, PGN, and at least one filter ID are required.");
-        (0, node_process_1.exit)(1);
+        msgCommonErrorHelp("Round ID, PGN, and at least one filter ID 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;
@@ -123,13 +120,13 @@ const pushFilterIDCommand = 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, filterIds);
     }
     else {
@@ -138,4 +135,3 @@ const pushFilterIDCommand = async (args) => {
             await pushPGN(roundInfo, pgnContent);
     }
 };
-exports.pushFilterIDCommand = pushFilterIDCommand;