@valoranchi/riot-client 0.3.0 → 0.5.0

package/dist/cli.js

@@ -1,12 +1,16 @@
 import { readFileSync } from "node:fs";
 import { parseArgs } from "node:util";
 import { RiotClientError, ValidationError } from "./errors.js";
+import { PACKAGE_VERSION } from "./version.js";
+import { formatError } from "./formatError.js";
+import { McpServer } from "./mcp/index.js";
 import { RiotClient } from "./RiotClient.js";
 export const USAGE = `Usage: riotclient <command> [options]
 
 Account:
   whoami           Print signed-in player profile and region
   owned-items      Print owned inventory items
+  collection-value Calculate estimated VP and Radianite value of owned collection
   loadout          Print currently equipped loadout
   wallet           Print VP, Radianite, and Kingdom Credits balances
   xp               Print account level, XP progression and recent match XP history
@@ -21,6 +25,9 @@ Account:
   settings-save    Save player settings from JSON file (<file.json>, requires --yes --confirm)
   equip            Equip skins, buddies, sprays, card, title, border, flex (dry-run, --yes to apply)
   equip-collection Equip a collection of skins (<skinUuid,...>) (dry-run, --yes to apply)
+  loadout-export   Export current loadout as a preset JSON
+  loadout-diff     Compare current loadout against preset JSON file (<preset.json>)
+  loadout-apply    Apply loadout preset from JSON file (<preset.json>, dry-run, --yes to apply)
   contract-activate Activate an agent contract (<uuid>) (dry-run, --yes to apply)
   favourite-add    Add skin to favourites (<skin>) (dry-run, --yes to apply)
   favourite-remove Remove skin from favourites (<skin>) (dry-run, --yes to apply)
@@ -44,13 +51,17 @@ Social:
 
 Store:
   store            Print storefront (daily, night market, bundles, accessories)
+  store-history    Print recorded daily store rotations [--days <n>]
+  store-seen       Print when a skin was last seen in daily store (<skin>)
   offers           Print full item offers catalog and pricing
   order <id>       Print store order details
   night-market-reveal Reveal night market offers (dry-run, --yes to apply)
   buy              Purchase offer or bundle (--offer <id> | --bundle <id>, requires --yes --confirm)
+  wishlist         Print skin wishlist or manage items (add <skin>, remove <skin>, check)
 
 Matches:
   matches          Print recent match history summaries
+  matches-sync     Synchronize match history to local cache [--pages <n>]
   match <id>       Print full match details by ID
   mmr              Print current rank, rating, and MMR breakdown
   rank-history     Print competitive rating adjustments and tier changes
@@ -61,6 +72,9 @@ Matches:
   leaderboard      Print competitive leaderboard [--season] [--start] [--size] [--query]
   content          Print active act, episode and live events
   premier          Print premier eligibility, roster, and season info
+  trend            Print competitive rating streak, net RR gains, and climbing pace
+  summary          Print player performance summary across recent matches [--count n] [--queue q]
+  assess [puuid]   Assess player rank anomalies, streaks, and warning flags
   agent-select     Select an agent in pregame (<uuid|name>) (dry-run, --yes to apply)
   agent-lock       Lock in an agent in pregame (<uuid|name>) (dry-run, --yes to apply)
   dodge            Dodge pregame agent select (requires --yes --confirm)
@@ -102,6 +116,22 @@ Raw (unsupported):
 
 Events:
   watch            Stream real-time events as JSON lines until interrupted
+  watch store      Stream store wishlist rotation hits until interrupted [--webhook <url>] [--interval <min>]
+  watch-match      Stream match lifecycle events until interrupted
+  watch-friends    Stream friend activity and presence events until interrupted
+
+Server:
+  serve            Start local HTTP server with SSE events and OpenAPI docs [--port 47800] [--host 127.0.0.1] [--allow-remote]
+  mcp              Start Model Context Protocol (MCP) server over stdio for AI assistants
+
+Official:
+  official account <name#tag> Print player PUUID and active shard
+  official matches <name#tag> Print player match history [--queue <q>] [--count <n>]
+  official match <id> Print full match details (--shard <shard> [--self <puuid>])
+  official leaderboard Print competitive leaderboard (--shard <shard> [--act <id>] [--start <n>] [--size <n>])
+  official status Print platform status and maintenance alerts (--shard <shard>)
+  official summary <name#tag> Print player performance summary [--queue <q>] [--count <n>]
+  official profile <name#tag> Print player scouting profile [--count <n>]
 
 Options:
   --yes              Execute write command (default is dry-run)
@@ -138,19 +168,29 @@ Options:
   --only <events>    Comma-separated list of event names to print
   --raw              Include raw client event frames or unformatted settings
   --cid <id>         Conversation ID for filtering messages or participants
+  --api-key <key>    Riot Developer API key (or RIOT_API_KEY env)
+  --shard <shard>    Riot shard (na, latam, br, eu, ap, kr)
+  --self <puuid>     Player PUUID for self perspective in official match
+  --act <uuid>       Act or season UUID for official leaderboard
   --language <lang>  Catalogue language (default: en-US)
   --cache <seconds>  Reuse Riot responses younger than this many seconds
+  --no-official-cache Disable official match disk cache
+  --webhook <url>    Webhook URL for store alerts (Discord or generic)
+  --interval <min>   Check interval in minutes for store watcher
+  --port <n>         Port to bind HTTP server (default: 47800)
+  --host <ip>        Host address to bind HTTP server (default: 127.0.0.1)
+  --allow-remote     Allow binding HTTP server to non-loopback address
   --pretty           Pretty-print JSON output
   --help             Show usage instructions
   --version          Show version number
 `;
-const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
 const ERROR_EXIT_CODES = {
     RIOT_CLIENT_NOT_RUNNING: 2,
     RIOT_CLIENT_NOT_READY: 3,
     REGION_UNKNOWN: 4,
     RIOT_API_ERROR: 5,
     VALIDATION: 6,
+    OFFICIAL_API_KEY_MISSING: 7,
 };
 export function exitCodeForError(error) {
     if (error instanceof RiotClientError) {
@@ -158,33 +198,7 @@ export function exitCodeForError(error) {
     }
     return 1;
 }
-export function formatError(error) {
-    if (error instanceof ValidationError) {
-        return {
-            error: {
-                code: error.code,
-                reason: error.reason,
-                message: error.message,
-                details: error.details,
-            },
-        };
-    }
-    if (error instanceof RiotClientError) {
-        return {
-            error: {
-                code: error.code,
-                message: error.message,
-            },
-        };
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-        error: {
-            code: "UNKNOWN_ERROR",
-            message,
-        },
-    };
-}
+export { formatError };
 export function formatWatchLine(event, data, at = new Date().toISOString()) {
     return JSON.stringify({
         event,
@@ -240,6 +254,111 @@ export async function runWatch(client, options = {}) {
     await client.close();
     return 0;
 }
+export async function runWatchMatch(client) {
+    const watcher = client.watch.match();
+    const onSignal = () => {
+        process.off("SIGINT", onSignal);
+        process.off("SIGTERM", onSignal);
+        watcher.stop();
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+    try {
+        for await (const item of watcher) {
+            process.stdout.write(`${JSON.stringify(item)}\n`);
+        }
+    }
+    finally {
+        process.off("SIGINT", onSignal);
+        process.off("SIGTERM", onSignal);
+        watcher.stop();
+        await client.close();
+    }
+    return 0;
+}
+export async function runWatchFriends(client) {
+    const watcher = client.watch.friends();
+    const onSignal = () => {
+        process.off("SIGINT", onSignal);
+        process.off("SIGTERM", onSignal);
+        watcher.stop();
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+    try {
+        for await (const item of watcher) {
+            process.stdout.write(`${JSON.stringify(item)}\n`);
+        }
+    }
+    finally {
+        process.off("SIGINT", onSignal);
+        process.off("SIGTERM", onSignal);
+        watcher.stop();
+        await client.close();
+    }
+    return 0;
+}
+export async function runWatchStore(client, options = {}) {
+    const intervalMs = options.intervalMinutes && options.intervalMinutes > 0
+        ? options.intervalMinutes * 60 * 1000
+        : undefined;
+    const watcher = client.watch.store({
+        webhook: options.webhook,
+        intervalMs,
+    });
+    const onSignal = () => {
+        process.off("SIGINT", onSignal);
+        process.off("SIGTERM", onSignal);
+        watcher.stop();
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+    try {
+        for await (const item of watcher) {
+            process.stdout.write(`${JSON.stringify(item)}\n`);
+        }
+    }
+    finally {
+        process.off("SIGINT", onSignal);
+        process.off("SIGTERM", onSignal);
+        watcher.stop();
+        await client.close();
+    }
+    return 0;
+}
+export async function runServe(client, options = {}) {
+    const server = await client.serve(options);
+    process.stdout.write(`Riot Client HTTP server listening on ${server.url}\n`);
+    await new Promise((resolve) => {
+        const onSignal = () => {
+            process.off("SIGINT", onSignal);
+            process.off("SIGTERM", onSignal);
+            resolve();
+        };
+        process.on("SIGINT", onSignal);
+        process.on("SIGTERM", onSignal);
+    });
+    await server.close();
+    await client.close();
+    return 0;
+}
+export async function runMcp(client) {
+    const server = new McpServer(client);
+    const onSignal = () => {
+        server.close();
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+    try {
+        await server.start();
+    }
+    finally {
+        process.off("SIGINT", onSignal);
+        process.off("SIGTERM", onSignal);
+        await client.close();
+    }
+    return 0;
+}
 const UNKNOWN_COMMAND = Symbol("UNKNOWN_COMMAND");
 function parseTarget(to) {
     if (to.includes("#"))
@@ -347,6 +466,8 @@ async function executeStandardCommand(client, command, options) {
             return client.account.whoami();
         case "owned-items":
             return client.account.ownedItems({ language: options?.language });
+        case "collection-value":
+            return client.account.collectionValue();
         case "loadout":
             return client.account.loadout();
         case "wallet":
@@ -377,10 +498,34 @@ async function executeStandardCommand(client, command, options) {
             return client.social.messages(options?.cid);
         case "store":
             return client.store.current({ language: options?.language });
+        case "store-history":
+            return client.store.history({ days: options?.days });
+        case "store-seen": {
+            const skin = requirePositional(pos, 1, "Usage: riotclient store-seen <skin>");
+            return client.store.seen(skin);
+        }
         case "offers":
             return client.store.offers();
         case "order":
             return client.store.order(requirePositional(pos, 1, "Usage: riotclient order <id>"));
+        case "wishlist": {
+            const action = pos[1];
+            if (!action || action === "list") {
+                return client.store.wishlist();
+            }
+            if (action === "add") {
+                const skin = requirePositional(pos, 2, "Usage: riotclient wishlist add <skin>");
+                return client.store.wishlistAdd(skin);
+            }
+            if (action === "remove") {
+                const skin = requirePositional(pos, 2, "Usage: riotclient wishlist remove <skin>");
+                return client.store.wishlistRemove(skin);
+            }
+            if (action === "check") {
+                return client.store.wishlistCheck();
+            }
+            throw new ValidationError("unknown-command", `Unknown wishlist action: ${action}`);
+        }
         case "client":
             return client.account.client();
         case "participants":
@@ -399,6 +544,8 @@ async function executeGameCommand(client, command, options) {
     switch (command) {
         case "matches":
             return client.matches.list({ count: options?.count, queue: options?.queue });
+        case "matches-sync":
+            return client.matches.sync({ maxPages: options?.pages });
         case "match":
             if (!options?.matchId)
                 throw new Error("Missing match ID: riotclient match <id>");
@@ -426,6 +573,12 @@ async function executeGameCommand(client, command, options) {
             return client.matches.content();
         case "premier":
             return client.matches.premier();
+        case "trend":
+            return client.matches.trend({ count: options?.count });
+        case "summary":
+            return client.matches.summary({ count: options?.count, queue: options?.queue });
+        case "assess":
+            return client.matches.assess(pos[1]);
         case "party":
             return client.party.current();
         case "queues":
@@ -445,23 +598,33 @@ async function executeSocialWriteCommand(client, command, yes, pos, vals) {
                 throw new ValidationError("invalid-argument", "Usage: riotclient send --to <puuid|name#tag|cid> --text <message>");
             }
             const target = parseTarget(to);
-            return yes ? client.social.sendMessage(target, text) : client.social.validateSendMessage(target, text);
+            return yes
+                ? client.social.sendMessage(target, text)
+                : client.social.validateSendMessage(target, text);
         }
         case "friend-request": {
             const riotId = requirePositional(pos, 1, "Usage: riotclient friend-request <name#tag>");
-            return yes ? client.social.sendFriendRequest(riotId) : client.social.validateSendFriendRequest(riotId);
+            return yes
+                ? client.social.sendFriendRequest(riotId)
+                : client.social.validateSendFriendRequest(riotId);
         }
         case "friend-accept": {
             const puuid = requirePositional(pos, 1, "Usage: riotclient friend-accept <puuid>");
-            return yes ? client.social.acceptFriendRequest(puuid) : client.social.validateAcceptFriendRequest(puuid);
+            return yes
+                ? client.social.acceptFriendRequest(puuid)
+                : client.social.validateAcceptFriendRequest(puuid);
         }
         case "friend-decline": {
             const puuid = requirePositional(pos, 1, "Usage: riotclient friend-decline <puuid>");
-            return yes ? client.social.declineFriendRequest(puuid) : client.social.validateDeclineFriendRequest(puuid);
+            return yes
+                ? client.social.declineFriendRequest(puuid)
+                : client.social.validateDeclineFriendRequest(puuid);
         }
         case "friend-cancel": {
             const puuid = requirePositional(pos, 1, "Usage: riotclient friend-cancel <puuid>");
-            return yes ? client.social.cancelFriendRequest(puuid) : client.social.validateCancelFriendRequest(puuid);
+            return yes
+                ? client.social.cancelFriendRequest(puuid)
+                : client.social.validateCancelFriendRequest(puuid);
         }
         case "friend-remove": {
             const puuid = requirePositional(pos, 1, "Usage: riotclient friend-remove <puuid>");
@@ -506,15 +669,36 @@ async function executeAccountWriteCommand(client, command, yes, pos, vals) {
         }
         case "equip-collection": {
             const raw = pos.slice(1).join(",");
-            const skinUuids = raw.split(",").map((s) => s.trim()).filter(Boolean);
+            const skinUuids = raw
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean);
             if (skinUuids.length === 0) {
                 throw new ValidationError("invalid-argument", "Usage: riotclient equip-collection <skinUuid,...>");
             }
-            return yes ? client.account.equipCollection(skinUuids) : client.account.validateEquipCollection(skinUuids);
+            return yes
+                ? client.account.equipCollection(skinUuids)
+                : client.account.validateEquipCollection(skinUuids);
+        }
+        case "loadout-export":
+            return client.account.exportLoadout();
+        case "loadout-diff": {
+            const file = requirePositional(pos, 1, "Usage: riotclient loadout-diff <preset.json>");
+            const content = JSON.parse(readFileSync(file, "utf-8"));
+            return client.account.diffLoadout(content);
+        }
+        case "loadout-apply": {
+            const file = requirePositional(pos, 1, "Usage: riotclient loadout-apply <preset.json> [--yes]");
+            const content = JSON.parse(readFileSync(file, "utf-8"));
+            return yes
+                ? client.account.equipPreset(content)
+                : client.account.validateEquipPreset(content);
         }
         case "contract-activate": {
             const uuid = requirePositional(pos, 1, "Usage: riotclient contract-activate <uuid>");
-            return yes ? client.account.activateContract(uuid) : client.account.validateActivateContract(uuid);
+            return yes
+                ? client.account.activateContract(uuid)
+                : client.account.validateActivateContract(uuid);
         }
         case "favourite-add": {
             const skin = requirePositional(pos, 1, "Usage: riotclient favourite-add <skin>");
@@ -522,7 +706,9 @@ async function executeAccountWriteCommand(client, command, yes, pos, vals) {
         }
         case "favourite-remove": {
             const skin = requirePositional(pos, 1, "Usage: riotclient favourite-remove <skin>");
-            return yes ? client.account.removeFavourite(skin) : client.account.validateRemoveFavourite(skin);
+            return yes
+                ? client.account.removeFavourite(skin)
+                : client.account.validateRemoveFavourite(skin);
         }
         case "privacy":
             return executePrivacyCommand(client, yes, vals);
@@ -574,8 +760,12 @@ async function executePartyCommand(client, command, options) {
         }
         case "party-code":
             return vals.revoke
-                ? (yes ? client.party.revokeInviteCode() : client.party.validateRevokeInviteCode())
-                : (yes ? client.party.createInviteCode() : client.party.validateCreateInviteCode());
+                ? yes
+                    ? client.party.revokeInviteCode()
+                    : client.party.validateRevokeInviteCode()
+                : yes
+                    ? client.party.createInviteCode()
+                    : client.party.validateCreateInviteCode();
         case "party-join": {
             const target = requirePositional(pos, 1, "Usage: riotclient party-join <partyId|code>");
             const isPartyId = target.includes("-") || target.length >= 32;
@@ -586,7 +776,9 @@ async function executePartyCommand(client, command, options) {
         }
         case "party-ready": {
             const ready = parseBooleanFlag("ready", requirePositional(pos, 1, "Usage: riotclient party-ready on|off"));
-            return yes ? client.party.setReady(Boolean(ready)) : client.party.validateSetReady(Boolean(ready));
+            return yes
+                ? client.party.setReady(Boolean(ready))
+                : client.party.validateSetReady(Boolean(ready));
         }
         case "party-queue": {
             const queue = requirePositional(pos, 1, "Usage: riotclient party-queue <queue>");
@@ -597,7 +789,9 @@ async function executePartyCommand(client, command, options) {
             if (access !== "open" && access !== "closed") {
                 throw new ValidationError("invalid-argument", "Usage: riotclient party-access open|closed");
             }
-            return yes ? client.party.setAccessibility(access) : client.party.validateSetAccessibility(access);
+            return yes
+                ? client.party.setAccessibility(access)
+                : client.party.validateSetAccessibility(access);
         }
         case "party-start":
             return yes ? client.party.startMatchmaking() : client.party.validateStartMatchmaking();
@@ -645,13 +839,20 @@ async function executePartyExtraCommand(client, command, yes, pos) {
         }
         case "party-servers": {
             const raw = requirePositional(pos, 1, "Usage: riotclient party-servers <id,...>");
-            const ids = raw.split(",").map((s) => s.trim()).filter(Boolean);
-            return yes ? client.party.setPreferredServers(ids) : client.party.validateSetPreferredServers(ids);
+            const ids = raw
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean);
+            return yes
+                ? client.party.setPreferredServers(ids)
+                : client.party.validateSetPreferredServers(ids);
         }
         case "party-moderator": {
             const puuid = requirePositional(pos, 1, "Usage: riotclient party-moderator <puuid> on|off");
             const mod = parseBooleanFlag("moderator", requirePositional(pos, 2, "Usage: riotclient party-moderator <puuid> on|off"));
-            return yes ? client.party.setModerator(puuid, Boolean(mod)) : client.party.validateSetModerator(puuid, Boolean(mod));
+            return yes
+                ? client.party.setModerator(puuid, Boolean(mod))
+                : client.party.validateSetModerator(puuid, Boolean(mod));
         }
         case "party-refresh":
             return yes ? client.party.refresh() : client.party.validateRefresh();
@@ -660,7 +861,11 @@ async function executePartyExtraCommand(client, command, yes, pos) {
     }
 }
 function parseCustomGameRules(vals) {
-    const ruleList = Array.isArray(vals.rule) ? vals.rule : vals.rule ? [String(vals.rule)] : [];
+    const ruleList = Array.isArray(vals.rule)
+        ? vals.rule
+        : vals.rule
+            ? [String(vals.rule)]
+            : [];
     const rules = {};
     for (const r of ruleList) {
         const idx = r.indexOf("=");
@@ -778,10 +983,85 @@ async function executeRawCommand(client, command, pos, vals) {
             throw new ValidationError("invalid-argument", `Unknown HTTP method: ${method}. Expected get, post, put, or delete`);
     }
 }
+async function executeOfficialCommand(client, command, pos, vals) {
+    if (command !== "official") {
+        return UNKNOWN_COMMAND;
+    }
+    const sub = pos[1];
+    switch (sub) {
+        case "account": {
+            const riotId = pos[2];
+            if (!riotId) {
+                throw new ValidationError("missing-riot-id", "Riot ID required (e.g. Name#Tag)");
+            }
+            return client.official.account(riotId);
+        }
+        case "matches": {
+            const riotId = pos[2];
+            if (!riotId) {
+                throw new ValidationError("missing-riot-id", "Riot ID required (e.g. Name#Tag)");
+            }
+            const count = vals.count !== undefined ? Number(vals.count) : undefined;
+            const queue = vals.queue !== undefined ? String(vals.queue) : undefined;
+            return client.official.matches(riotId, { count, queue });
+        }
+        case "match": {
+            const matchId = pos[2];
+            if (!matchId) {
+                throw new ValidationError("missing-match-id", "Match ID required");
+            }
+            const shard = vals.shard !== undefined ? String(vals.shard) : undefined;
+            if (!shard) {
+                throw new ValidationError("missing-shard", "Shard required (--shard <shard>)");
+            }
+            const self = vals.self !== undefined ? String(vals.self) : undefined;
+            return client.official.match(matchId, { shard, self });
+        }
+        case "leaderboard": {
+            const shard = vals.shard !== undefined ? String(vals.shard) : undefined;
+            if (!shard) {
+                throw new ValidationError("missing-shard", "Shard required (--shard <shard>)");
+            }
+            const act = vals.act !== undefined ? String(vals.act) : undefined;
+            const start = vals.start !== undefined ? Number(vals.start) : undefined;
+            const size = vals.size !== undefined ? Number(vals.size) : undefined;
+            return client.official.leaderboard({ shard, act, start, size });
+        }
+        case "status": {
+            const shard = vals.shard !== undefined ? String(vals.shard) : undefined;
+            if (!shard) {
+                throw new ValidationError("missing-shard", "Shard required (--shard <shard>)");
+            }
+            return client.official.status(shard);
+        }
+        case "summary": {
+            const riotId = pos[2];
+            if (!riotId) {
+                throw new ValidationError("missing-riot-id", "Riot ID required (e.g. Name#Tag)");
+            }
+            const count = vals.count !== undefined ? Number(vals.count) : undefined;
+            const queue = vals.queue !== undefined ? String(vals.queue) : undefined;
+            return client.official.summary(riotId, { count, queue });
+        }
+        case "profile": {
+            const riotId = pos[2];
+            if (!riotId) {
+                throw new ValidationError("missing-riot-id", "Riot ID required (e.g. Name#Tag)");
+            }
+            const count = vals.count !== undefined ? Number(vals.count) : undefined;
+            return client.official.profile(riotId, { count });
+        }
+        default:
+            return UNKNOWN_COMMAND;
+    }
+}
 async function executeCommand(client, command, options) {
     const pos = options?.positionals ?? [];
     const vals = options?.rawValues ?? {};
     const yes = Boolean(options?.yes);
+    const official = await executeOfficialCommand(client, command, pos, vals);
+    if (official !== UNKNOWN_COMMAND)
+        return official;
     const std = await executeStandardCommand(client, command, options);
     if (std !== UNKNOWN_COMMAND)
         return std;
@@ -854,11 +1134,23 @@ export async function runCli(args) {
             server: { type: "string" },
             rule: { type: "string", multiple: true },
             body: { type: "string" },
+            days: { type: "string" },
+            pages: { type: "string" },
+            port: { type: "string" },
+            host: { type: "string" },
+            "allow-remote": { type: "boolean", default: false },
+            "api-key": { type: "string" },
+            shard: { type: "string" },
+            self: { type: "string" },
+            act: { type: "string" },
+            "no-official-cache": { type: "boolean", default: false },
+            webhook: { type: "string" },
+            interval: { type: "string" },
         },
         allowPositionals: true,
     });
     if (parsed.values.version) {
-        process.stdout.write(`${packageJson.version}\n`);
+        process.stdout.write(`${PACKAGE_VERSION}\n`);
         return 0;
     }
     if (parsed.values.help || parsed.positionals.length === 0) {
@@ -867,17 +1159,48 @@ export async function runCli(args) {
     }
     const command = parsed.positionals[0];
     const cacheSeconds = Number(parsed.values.cache ?? 0);
+    const apiKey = parsed.values["api-key"]
+        ? String(parsed.values["api-key"])
+        : process.env.RIOT_API_KEY;
+    const officialCache = parsed.values["no-official-cache"] ? false : undefined;
     const client = new RiotClient({
         language: parsed.values.language,
         responseCache: cacheSeconds > 0 ? { ttlMs: cacheSeconds * 1000 } : undefined,
+        officialApiKey: apiKey,
+        officialCache,
     });
     try {
         if (command === "watch") {
+            if (parsed.positionals[1] === "store") {
+                const intervalMinutes = parsed.values.interval ? Number(parsed.values.interval) : undefined;
+                const webhook = parsed.values.webhook ? String(parsed.values.webhook) : undefined;
+                return await runWatchStore(client, { webhook, intervalMinutes });
+            }
             return await runWatch(client, {
                 only: parsed.values.only,
                 raw: parsed.values.raw,
             });
         }
+        if (command === "watch-store") {
+            const intervalMinutes = parsed.values.interval ? Number(parsed.values.interval) : undefined;
+            const webhook = parsed.values.webhook ? String(parsed.values.webhook) : undefined;
+            return await runWatchStore(client, { webhook, intervalMinutes });
+        }
+        if (command === "watch-match") {
+            return await runWatchMatch(client);
+        }
+        if (command === "watch-friends") {
+            return await runWatchFriends(client);
+        }
+        if (command === "serve") {
+            const port = parsed.values.port ? Number(parsed.values.port) : undefined;
+            const host = parsed.values.host;
+            const allowRemote = Boolean(parsed.values["allow-remote"]);
+            return await runServe(client, { port, host, allowRemote });
+        }
+        if (command === "mcp") {
+            return await runMcp(client);
+        }
         const count = parsed.values.count ? Number(parsed.values.count) : undefined;
         const loadouts = parsed.values["no-loadouts"] ? false : (parsed.values.loadouts ?? true);
         const result = await executeCommand(client, command, {
@@ -889,6 +1212,8 @@ export async function runCli(args) {
             loadouts,
             matchId: command === "match" ? parsed.positionals[1] : undefined,
             yes: Boolean(parsed.values.yes),
+            days: parsed.values.days ? Number(parsed.values.days) : undefined,
+            pages: parsed.values.pages ? Number(parsed.values.pages) : undefined,
             positionals: parsed.positionals,
             rawValues: parsed.values,
         });