libroadcast-cli 1.0.0

package/README.md

@@ -0,0 +1,17 @@
+## Installation
+
+```bash
+pnpm install
+```
+
+## Usage
+
+```bash
+pnpx tsx src/index.ts delay <broadcastId> <delayInSeconds> [--only-delay] [--no-delay]
+```
+
+```bash
+export LICHESS_TOKEN=lip_yourtoken
+export LICHESS_DOMAIN=http://localhost:8080/
+pnpx tsx src/index.ts delay <broadcastId> <delayInSeconds> [--only-delay] [--no-delay]
+```

package/dist/index.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+import { argv, env } from "process";
+import createClient from "openapi-fetch";
+const LICHESS_TOKEN = env.LICHESS_TOKEN;
+const LICHESS_DOMAIN = env.LICHESS_DOMAIN || "https://lichess.org/";
+if (!LICHESS_TOKEN) {
+    console.error("Error: LICHESS_TOKEN environment variable is not set.");
+    process.exit(1);
+}
+const args = argv.slice(2);
+const client = createClient({
+    baseUrl: LICHESS_DOMAIN,
+    headers: {
+        Authorization: `Bearer ${LICHESS_TOKEN}`,
+        Accept: "application/json",
+    },
+});
+const getBroadcast = (broadcastId) => client
+    .GET("/api/broadcast/{broadcastTournamentId}", {
+    params: {
+        path: { broadcastTournamentId: broadcastId },
+    },
+})
+    .then((response) => response.data)
+    .catch((error) => {
+    console.error("Error fetching broadcast:", error);
+    return null;
+});
+const setDelayRounds = (rounds, delay, onlyDelay, noDelay) => rounds.forEach((round) => {
+    client
+        .POST("/broadcast/round/{broadcastRoundId}/edit", {
+        params: {
+            path: { broadcastRoundId: round.id },
+            // @ts-ignore patch param is not yet documented
+            query: { patch: 1 },
+        },
+        // @ts-ignore name of body properties due patch param is implicit
+        body: {
+            delay: noDelay ? undefined : delay,
+            startsAt: round.startsAt && !onlyDelay
+                ? round.startsAt + delay * 1000
+                : undefined,
+        },
+    })
+        .then((response) => {
+        if (response.response.ok)
+            console.log(`Successfully set delay for round ${round.id} to ${delay} seconds.`);
+        else
+            console.error(`Failed to set delay for round ${round.id}: ${response.response.statusText}`);
+    })
+        .catch((error) => {
+        console.error(`Error setting delay for round ${round.id}:`, error);
+    });
+});
+const setSourceLCC = (rounds, sourceLCC) => {
+    let rN = 1;
+    rounds.forEach((round) => {
+        client
+            .POST("/broadcast/round/{broadcastRoundId}/edit", {
+            params: {
+                path: { broadcastRoundId: round.id },
+                // @ts-ignore patch param is not yet documented
+                query: { patch: 1 },
+            },
+            // @ts-ignore name of body properties due patch param is implicit
+            body: {
+                // @ts-ignore property is not yet documented
+                syncSource: "url",
+                syncUrl: `${sourceLCC}/${rN}`,
+            },
+        })
+            .then((response) => {
+            if (response.response.ok)
+                console.log(`Successfully set source LCC for round ${round.id} to ${sourceLCC}/${rN}.`);
+            else
+                console.error(`Failed to set source LCC for round ${round.id}: ${response.response.statusText}`);
+        })
+            .catch((error) => {
+            console.error(`Error setting source LCC for round ${round.id}:`, error);
+        });
+        rN += 1;
+    });
+};
+var Command;
+(function (Command) {
+    Command["Delay"] = "delay";
+    Command["SetLCC"] = "setLCC";
+})(Command || (Command = {}));
+const showHelp = (cmd) => {
+    const msg = [
+        "Usage: <command> [options]",
+        "Commands:",
+        "  delay <broadcastId> <delayInSeconds> [--onlyDelay] [--noDelay]",
+        "     Sets the delay for all rounds in the specified broadcast.",
+        "     Options:",
+        "       --onlyDelay   Set only the delay without changing the start time.",
+        "       --noDelay     Remove the delay from the rounds.",
+        "  setLCC <broadcastId> <sourceLCCUrl>",
+        "     Sets the source LCC URL for all rounds in the specified broadcast.",
+    ];
+    switch (cmd) {
+        case Command.Delay:
+            console.info(msg.slice(2, 7).join("\n"));
+            break;
+        case Command.SetLCC:
+            console.info(msg.slice(7, 8).join("\n"));
+            break;
+        default:
+            console.info(msg.join("\n"));
+    }
+};
+(async () => {
+    // check args[0] is --help or -h
+    if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+        showHelp();
+        process.exit(0);
+    }
+    switch (args[0]) {
+        case Command.Delay:
+            const [broadcastId, delay] = args.slice(1, 3);
+            // check arg --help or -h
+            if (args.includes("--help") || args.includes("-h")) {
+                showHelp(Command.Delay);
+                process.exit(0);
+            }
+            // Validate required args
+            if (!broadcastId || !delay) {
+                showHelp(Command.Delay);
+                process.exit(1);
+            }
+            const delayNum = parseInt(delay, 10);
+            // Validate delay is a number between 0s and 1h
+            if (isNaN(delayNum) && delayNum >= 0 && delayNum <= 3600) {
+                console.error("Delay must be a number between 0 and 3600 seconds.");
+                process.exit(1);
+            }
+            // check arg --onlyDelay
+            const onlyDelay = args.includes("--onlyDelay");
+            // check arg --noDelay
+            const noDelay = args.includes("--noDelay");
+            if (onlyDelay && noDelay) {
+                console.error("Cannot use --onlyDelay and --noDelay together.");
+                process.exit(1);
+            }
+            const broadcast = await getBroadcast(broadcastId);
+            if (!broadcast?.rounds || broadcast.rounds.length === 0) {
+                console.error("No rounds found for the specified broadcast.");
+                process.exit(1);
+            }
+            setDelayRounds(broadcast.rounds, parseInt(delay, 10), onlyDelay, noDelay);
+            break;
+        case Command.SetLCC:
+            const [bId, sourceLCC] = args.slice(1, 3);
+            // check arg --help or -h
+            if (args.includes("--help") || args.includes("-h")) {
+                showHelp(Command.SetLCC);
+                process.exit(0);
+            }
+            // Validate required args
+            if (!bId || !sourceLCC) {
+                showHelp(Command.SetLCC);
+                process.exit(1);
+            }
+            const bcast = await getBroadcast(bId);
+            if (!bcast?.rounds || bcast.rounds.length === 0) {
+                console.error("No rounds found for the specified broadcast.");
+                process.exit(1);
+            }
+            // check sourceLCC is a valid URL
+            let url;
+            try {
+                url = new URL(sourceLCC.startsWith("http")
+                    ? sourceLCC
+                    : `https://view.livechesscloud.com/${sourceLCC}`);
+            }
+            catch (e) {
+                console.error("sourceLCC must be a valid URL or LCC ID.");
+                process.exit(1);
+            }
+            setSourceLCC(bcast.rounds, url.toString());
+            break;
+        default:
+            console.error("Unknown command. Supported commands: delay, setLCC");
+            process.exit(1);
+    }
+})();

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "libroadcast-cli",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/index.ts",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.20.0+sha512.cf9998222162dd85864d0a8102e7892e7ba4ceadebbf5a31f9c2fce48dfce317a9c53b9f6464d1ef9042cba2e02ae02a9f7c143a2b438cd93c91840f0192b9dd",
+  "type": "module",
+  "dependencies": {
+    "@lichess-org/types": "^2.0.94",
+    "@types/node": "^24.10.0",
+    "openapi-fetch": "^0.15.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "bin": {
+    "libroadcast": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "pnpm build && node ./dist/index.js"
+  }
+}

package/src/index.ts

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+import { argv, env } from "process";
+import createClient from "openapi-fetch";
+import { components, paths } from "@lichess-org/types";
+
+const LICHESS_TOKEN = env.LICHESS_TOKEN;
+const LICHESS_DOMAIN = env.LICHESS_DOMAIN || "https://lichess.org/";
+
+if (!LICHESS_TOKEN) {
+  console.error("Error: LICHESS_TOKEN environment variable is not set.");
+  process.exit(1);
+}
+
+const args = argv.slice(2);
+
+const client = createClient<paths>({
+  baseUrl: LICHESS_DOMAIN,
+  headers: {
+    Authorization: `Bearer ${LICHESS_TOKEN}`,
+    Accept: "application/json",
+  },
+});
+
+const getBroadcast = (broadcastId: string) =>
+  client
+    .GET("/api/broadcast/{broadcastTournamentId}", {
+      params: {
+        path: { broadcastTournamentId: broadcastId },
+      },
+    })
+    .then((response) => response.data)
+    .catch((error) => {
+      console.error("Error fetching broadcast:", error);
+      return null;
+    });
+
+const setDelayRounds = (
+  rounds: components["schemas"]["BroadcastRoundInfo"][],
+  delay: number,
+  onlyDelay: boolean,
+  noDelay: boolean
+) =>
+  rounds.forEach((round) => {
+    client
+      .POST("/broadcast/round/{broadcastRoundId}/edit", {
+        params: {
+          path: { broadcastRoundId: round.id },
+          // @ts-ignore patch param is not yet documented
+          query: { patch: 1 },
+        },
+        // @ts-ignore name of body properties due patch param is implicit
+        body: {
+          delay: noDelay ? undefined : delay,
+          startsAt:
+            round.startsAt && !onlyDelay
+              ? round.startsAt + delay * 1000
+              : undefined,
+        },
+      })
+      .then((response) => {
+        if (response.response.ok)
+          console.log(
+            `Successfully set delay for round ${round.id} to ${delay} seconds.`
+          );
+        else
+          console.error(
+            `Failed to set delay for round ${round.id}: ${response.response.statusText}`
+          );
+      })
+      .catch((error) => {
+        console.error(`Error setting delay for round ${round.id}:`, error);
+      });
+  });
+
+const setSourceLCC = (
+  rounds: components["schemas"]["BroadcastRoundInfo"][],
+  sourceLCC: string
+) => {
+  let rN = 1;
+  rounds.forEach((round) => {
+    client
+      .POST("/broadcast/round/{broadcastRoundId}/edit", {
+        params: {
+          path: { broadcastRoundId: round.id },
+          // @ts-ignore patch param is not yet documented
+          query: { patch: 1 },
+        },
+        // @ts-ignore name of body properties due patch param is implicit
+        body: {
+          // @ts-ignore property is not yet documented
+          syncSource: "url",
+          syncUrl: `${sourceLCC}/${rN}`,
+        },
+      })
+      .then((response) => {
+        if (response.response.ok)
+          console.log(
+            `Successfully set source LCC for round ${round.id} to ${sourceLCC}/${rN}.`
+          );
+        else
+          console.error(
+            `Failed to set source LCC for round ${round.id}: ${response.response.statusText}`
+          );
+      })
+      .catch((error) => {
+        console.error(`Error setting source LCC for round ${round.id}:`, error);
+      });
+    rN += 1;
+  });
+};
+
+enum Command {
+  Delay = "delay",
+  SetLCC = "setLCC",
+}
+
+const showHelp = (cmd?: Command) => {
+  const msg = [
+    "Usage: <command> [options]",
+    "Commands:",
+    "  delay <broadcastId> <delayInSeconds> [--onlyDelay] [--noDelay]",
+    "     Sets the delay for all rounds in the specified broadcast.",
+    "     Options:",
+    "       --onlyDelay   Set only the delay without changing the start time.",
+    "       --noDelay     Remove the delay from the rounds.",
+    "  setLCC <broadcastId> <sourceLCCUrl>",
+    "     Sets the source LCC URL for all rounds in the specified broadcast.",
+  ];
+  switch (cmd) {
+    case Command.Delay:
+      console.info(msg.slice(2, 7).join("\n"));
+      break;
+    case Command.SetLCC:
+      console.info(msg.slice(7, 8).join("\n"));
+      break;
+    default:
+      console.info(msg.join("\n"));
+  }
+};
+
+(async () => {
+  // check args[0] is --help or -h
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    showHelp();
+    process.exit(0);
+  }
+  switch (args[0]) {
+    case Command.Delay:
+      const [broadcastId, delay] = args.slice(1, 3);
+      // check arg --help or -h
+      if (args.includes("--help") || args.includes("-h")) {
+        showHelp(Command.Delay);
+        process.exit(0);
+      }
+      // Validate required args
+      if (!broadcastId || !delay) {
+        showHelp(Command.Delay);
+        process.exit(1);
+      }
+      const delayNum = parseInt(delay, 10);
+      // Validate delay is a number between 0s and 1h
+      if (isNaN(delayNum) && delayNum >= 0 && delayNum <= 3600) {
+        console.error("Delay must be a number between 0 and 3600 seconds.");
+        process.exit(1);
+      }
+      // check arg --onlyDelay
+      const onlyDelay = args.includes("--onlyDelay");
+      // check arg --noDelay
+      const noDelay = args.includes("--noDelay");
+      if (onlyDelay && noDelay) {
+        console.error("Cannot use --onlyDelay and --noDelay together.");
+        process.exit(1);
+      }
+      const broadcast = await getBroadcast(broadcastId);
+      if (!broadcast?.rounds || broadcast.rounds.length === 0) {
+        console.error("No rounds found for the specified broadcast.");
+        process.exit(1);
+      }
+      setDelayRounds(broadcast.rounds, parseInt(delay, 10), onlyDelay, noDelay);
+      break;
+
+    case Command.SetLCC:
+      const [bId, sourceLCC] = args.slice(1, 3);
+      // check arg --help or -h
+      if (args.includes("--help") || args.includes("-h")) {
+        showHelp(Command.SetLCC);
+        process.exit(0);
+      }
+      // Validate required args
+      if (!bId || !sourceLCC) {
+        showHelp(Command.SetLCC);
+        process.exit(1);
+      }
+
+      const bcast = await getBroadcast(bId);
+      if (!bcast?.rounds || bcast.rounds.length === 0) {
+        console.error("No rounds found for the specified broadcast.");
+        process.exit(1);
+      }
+
+      // check sourceLCC is a valid URL
+      let url: URL;
+      try {
+        url = new URL(
+          sourceLCC.startsWith("http")
+            ? sourceLCC
+            : `https://view.livechesscloud.com/${sourceLCC}`
+        );
+      } catch (e) {
+        console.error("sourceLCC must be a valid URL or LCC ID.");
+        process.exit(1);
+      }
+
+      setSourceLCC(bcast.rounds, url.toString());
+      break;
+
+    default:
+      console.error("Unknown command. Supported commands: delay, setLCC");
+      process.exit(1);
+  }
+})();

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "lib": ["DOM", "ES2024"],
+    "target": "es2024",
+    "moduleResolution": "node",
+    "module": "ESNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+  }
+}