twitchdropsminer-cli 0.1.0

package/README.md

@@ -0,0 +1,153 @@
+# TwitchDropsMiner-CLI
+
+Headless, npm-installable CLI rewrite of [TwitchDropsMiner](https://github.com/DevilXD/TwitchDropsMiner) for Linux server operation.
+
+**Based on:** [DevilXD/TwitchDropsMiner](https://github.com/DevilXD/TwitchDropsMiner) — the original Python/GUI app that AFK mines timed Twitch drops with automatic claiming and channel switching. This CLI reimplements the same behavior (GQL, spade, PubSub, priority lists) for headless and server use.
+
+## Install
+
+**Global install from npm** (recommended; puts `tdm` on your PATH):
+
+```bash
+npm install -g twitchdropsminer-cli
+tdm doctor
+```
+
+**Alternative: global install from GitHub** (equivalent CLI, installs directly from this repo):
+
+```bash
+npm install -g github:vocino/TwitchDropsMiner-CLI
+tdm doctor
+```
+
+**Run from project** (no global install): from the repo root run `npm install`, `npm run build`, then use `npx tdm`:
+
+```bash
+npm install && npm run build
+npx tdm run --dry-run --verbose
+npx tdm status --json
+```
+
+## First-time setup
+
+1. **Log in** (headless-friendly device code; no browser on the server):
+
+   ```bash
+   tdm auth login --no-open
+   ```
+   Visit the printed URL on another device, enter the code, then:
+
+   ```bash
+   tdm auth validate
+   ```
+
+2. **Choose which games to mine** – the miner only watches games you list. List campaigns Twitch shows for your account:
+
+   ```bash
+   tdm games
+   ```
+   Copy the exact **game name** from the list (first column). Add one to your priority list:
+
+   ```bash
+   tdm games --add "Exact Game Name"
+   ```
+   Or set the full list manually (config file path: `tdm config path`):
+
+   ```bash
+   tdm config set priority '["Game One", "Game Two"]'
+   ```
+
+3. **Run the miner**:
+
+   ```bash
+   tdm run
+   tdm run --verbose
+   ```
+
+**Config file:** `~/.config/tdm/config.json` (or run `tdm config path` to print it). The file is created on first use; you can edit it directly or use `tdm config set <key> <value>` and `tdm config get`.
+
+## Headless authentication
+
+```bash
+tdm auth login --no-open
+tdm auth validate
+```
+
+Alternative imports:
+
+```bash
+tdm auth import --token-file /secure/path/token.txt
+tdm auth import-cookie --cookie-file /secure/path/cookies.txt
+```
+
+## Choosing which games to mine
+
+- **List available games** (from Twitch, for your account):
+
+  ```bash
+  tdm games
+  tdm games --json
+  ```
+
+- **Add a game to your priority list:** `tdm games --add "Exact Game Name"` (uses exact name from `tdm games`).
+
+- **Set priority manually:** `tdm config set priority '["Game A", "Game B"]'`. Use exact game names from `tdm games`.
+
+- **Config location:** `tdm config path` prints the path (e.g. `~/.config/tdm/config.json`). Options: `priority`, `exclude`, `priorityMode` (`priority_only` | `ending_soonest` | `low_avbl_first`), `enableBadgesEmotes`. See `docs/ops/drops-validation.md`.
+
+If you never set `priority`, the miner will have no “wanted games” and will not watch any channel. Link game accounts at [twitch.tv/drops/campaigns](https://www.twitch.tv/drops/campaigns) so more games appear in `tdm games`.
+
+## Run miner
+
+```bash
+tdm run
+tdm run --verbose
+tdm run --dry-run --verbose   # log actions only; no spade/claim network writes
+```
+
+### Stopping the miner
+
+Stop it gracefully so the lock file is removed automatically:
+
+- **In a terminal:** **Ctrl+C** (Windows or Linux/macOS). The miner handles SIGINT, shuts down, and exits; the lock is cleared on exit.
+- **As a systemd service:** `tdm service stop` or `systemctl --user stop tdm` (sends SIGTERM; same clean shutdown).
+
+You only need to [remove the lock file manually](#troubleshooting) if the process was **force-killed** (e.g. kill -9), **crashed**, or the machine lost power—cases where the process never got to run its exit handler.
+
+### How it mines drops
+
+1. **Inventory** – Fetches your in-progress campaigns and drop state via Twitch GQL.
+2. **Wanted games** – From config `priority`, `exclude`, and `priorityMode` (e.g. `priority_only`, `ending_soonest`).
+3. **Channels** – Fetches live channels per game (GameDirectory GQL), filters by drops-enabled and wanted game, orders by priority and viewers.
+4. **Watch simulation** – Sends “minute-watched” beacons to Twitch’s spade endpoint for the selected channel (no video stream).
+5. **Progress** – PubSub user-drop-events and optional CurrentDrop GQL keep drop minutes in sync; stream-state topics trigger channel refresh.
+6. **Claims** – Eligible drops are claimed automatically via ClaimDrop GQL (24h post-campaign window).
+7. **Maintenance** – Hourly inventory refresh and campaign time triggers (start/end) drive channel cleanup and re-fetch.
+
+## Service mode
+
+```bash
+tdm service install --user --autostart
+tdm service start
+tdm service status
+tdm logs --follow
+```
+
+More ops docs:
+
+- `docs/ops/linux-install.md`
+- `docs/ops/authentication.md`
+- `docs/ops/service-management.md`
+- `docs/ops/systemd-hardening.md`
+- `docs/ops/drops-validation.md` – validate drops progression and claims
+
+### Troubleshooting
+
+- **"Another tdm instance appears to be running"** – Only one miner can run at a time (lock file). If the previous run was **force-killed**, **crashed**, or didn’t exit cleanly, remove the lock and try again:  
+  **Windows:** delete `%USERPROFILE%\.local\state\tdm\lock.file`  
+  **Linux/macOS:** `rm -f ~/.local/state/tdm/lock.file`
+
+## Credits
+
+This CLI is based on [**TwitchDropsMiner**](https://github.com/DevilXD/TwitchDropsMiner) by [DevilXD](https://github.com/DevilXD) — the original desktop app that mines Twitch drops without streaming video. TwitchDropsMiner-CLI reimplements its behavior (inventory, spade beacons, PubSub, game priority, auto-claim) for headless and server use.
+

package/dist/auth/cookieImport.js

@@ -0,0 +1,7 @@
+export function normalizeCookieHeader(input) {
+    const header = input.trim();
+    if (!header) {
+        throw new Error("Empty cookie header.");
+    }
+    return { rawHeader: header };
+}

package/dist/auth/deviceAuth.js

@@ -0,0 +1,61 @@
+import { TWITCH_ANDROID_CLIENT_ID, TWITCH_ANDROID_USER_AGENT, TWITCH_OAUTH_DEVICE_URL, TWITCH_OAUTH_TOKEN_URL } from "../core/constants.js";
+import { request } from "undici";
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function startDeviceAuth() {
+    // Twitch's device endpoint expects form-encoded parameters, not JSON.
+    const body = new URLSearchParams({
+        client_id: TWITCH_ANDROID_CLIENT_ID,
+        scope: ""
+    }).toString();
+    const resp = await request(TWITCH_OAUTH_DEVICE_URL, {
+        method: "POST",
+        body,
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Client-Id": TWITCH_ANDROID_CLIENT_ID,
+            "User-Agent": TWITCH_ANDROID_USER_AGENT
+        }
+    });
+    const text = await resp.body.text();
+    const response = JSON.parse(text);
+    return {
+        deviceCode: response.device_code,
+        userCode: response.user_code,
+        verificationUri: response.verification_uri,
+        interval: response.interval,
+        expiresIn: response.expires_in
+    };
+}
+export async function pollDeviceToken(start) {
+    const expiresAt = Date.now() + start.expiresIn * 1000;
+    while (Date.now() < expiresAt) {
+        await sleep(start.interval * 1000);
+        try {
+            const body = new URLSearchParams({
+                client_id: TWITCH_ANDROID_CLIENT_ID,
+                device_code: start.deviceCode,
+                grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+            }).toString();
+            const resp = await request(TWITCH_OAUTH_TOKEN_URL, {
+                method: "POST",
+                body,
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    "Client-Id": TWITCH_ANDROID_CLIENT_ID,
+                    "User-Agent": TWITCH_ANDROID_USER_AGENT
+                }
+            });
+            const text = await resp.body.text();
+            const tokenResp = JSON.parse(text);
+            if (tokenResp.access_token) {
+                return tokenResp.access_token;
+            }
+        }
+        catch {
+            // expected while pending authorization
+        }
+    }
+    throw new Error("Device authorization timed out.");
+}

package/dist/auth/sessionManager.js

@@ -0,0 +1,30 @@
+import { loadAuthState, saveAuthState } from "../state/authStore.js";
+import { httpJson } from "../integrations/httpClient.js";
+import { TWITCH_OAUTH_VALIDATE_URL } from "../core/constants.js";
+import { parseTokenInput } from "./tokenImport.js";
+export class SessionManager {
+    getAccessToken() {
+        const state = loadAuthState();
+        return state?.accessToken ?? null;
+    }
+    setAccessToken(rawTokenInput) {
+        const token = parseTokenInput(rawTokenInput).accessToken;
+        const prev = loadAuthState() ?? { updatedAt: new Date().toISOString() };
+        saveAuthState({
+            ...prev,
+            accessToken: token
+        });
+    }
+    async validateAccessToken(token) {
+        const accessToken = token ?? this.getAccessToken();
+        if (!accessToken) {
+            throw new Error("No access token available.");
+        }
+        return httpJson("GET", TWITCH_OAUTH_VALIDATE_URL, undefined, {
+            retries: 1,
+            headers: {
+                Authorization: `OAuth ${accessToken}`
+            }
+        });
+    }
+}

package/dist/auth/tokenImport.js

@@ -0,0 +1,21 @@
+export function parseTokenInput(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        throw new Error("Empty token input.");
+    }
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) {
+        // raw OAuth token
+        return { accessToken: trimmed, source: "raw" };
+    }
+    const key = trimmed.slice(0, eqIndex).trim().toLowerCase();
+    const value = trimmed.slice(eqIndex + 1).trim();
+    if (!value) {
+        throw new Error("Token value is empty.");
+    }
+    if (key === "auth-token") {
+        return { accessToken: value, source: "auth-token" };
+    }
+    // Unknown key, but still treat as token pair
+    return { accessToken: value, source: "raw" };
+}

package/dist/auth/validate.js

@@ -0,0 +1,29 @@
+import { loadAuthState } from "../state/authStore.js";
+import { SessionManager } from "./sessionManager.js";
+export function validateAuthLocally() {
+    const state = loadAuthState();
+    if (!state) {
+        return { hasToken: false, hasCookies: false };
+    }
+    return {
+        hasToken: !!state.accessToken,
+        hasCookies: !!state.cookiesHeader
+    };
+}
+export async function validateAuthRemote() {
+    try {
+        const session = new SessionManager();
+        const validateResponse = await session.validateAccessToken();
+        return {
+            valid: true,
+            userId: validateResponse.user_id,
+            clientId: validateResponse.client_id
+        };
+    }
+    catch (err) {
+        return {
+            valid: false,
+            error: err instanceof Error ? err.message : String(err)
+        };
+    }
+}

package/dist/cli/commands/auth.js

@@ -0,0 +1,172 @@
+import { Command } from "@commander-js/extra-typings";
+import fs from "node:fs";
+import { parseTokenInput } from "../../auth/tokenImport.js";
+import { normalizeCookieHeader } from "../../auth/cookieImport.js";
+import { loadAuthState, saveAuthState } from "../../state/authStore.js";
+import { validateAuthLocally, validateAuthRemote } from "../../auth/validate.js";
+import { startDeviceAuth, pollDeviceToken } from "../../auth/deviceAuth.js";
+export const authCommand = new Command("auth").description("Authentication commands");
+const loginCommand = new Command("login")
+    .description("Login using device-code flow (headless-friendly)")
+    .option("--no-open", "Do not attempt to open a browser, print URL and code only", true)
+    .action(async (opts) => {
+    const start = await startDeviceAuth();
+    // eslint-disable-next-line no-console
+    console.log(`verification_uri=${start.verificationUri}`);
+    // eslint-disable-next-line no-console
+    console.log(`user_code=${start.userCode}`);
+    // eslint-disable-next-line no-console
+    console.log(`interval=${start.interval}`);
+    // eslint-disable-next-line no-console
+    console.log(`expires_in=${start.expiresIn}`);
+    if (opts.open) {
+        // Intentionally no local browser launch for server safety.
+    }
+    const accessToken = await pollDeviceToken(start);
+    const prev = loadAuthState() || { updatedAt: new Date().toISOString() };
+    saveAuthState({
+        ...prev,
+        accessToken
+    });
+    // eslint-disable-next-line no-console
+    console.log("Device authentication completed and token stored.");
+});
+const importTokenCommand = new Command("import")
+    .description("Import an existing OAuth token")
+    .option("--token <token>", "Raw token or auth-token=<value> pair")
+    .option("--token-file <path>", "Path to a file containing the token")
+    .action(async (opts) => {
+    let raw = opts.token;
+    if (!raw && opts.tokenFile) {
+        raw = fs.readFileSync(opts.tokenFile, "utf8");
+    }
+    if (!raw) {
+        // eslint-disable-next-line no-console
+        console.error("No token provided. Use --token or --token-file.");
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const imported = parseTokenInput(raw);
+        const prev = loadAuthState() || { updatedAt: new Date().toISOString() };
+        saveAuthState({
+            ...prev,
+            accessToken: imported.accessToken
+        });
+        // eslint-disable-next-line no-console
+        console.log("Token imported successfully.");
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.error(`Failed to import token: ${err.message}`);
+        process.exitCode = 1;
+    }
+});
+const importCookieCommand = new Command("import-cookie")
+    .description("Import cookies (auth-token and related) from a header string or file")
+    .option("--cookie <header>", "Cookie header string")
+    .option("--cookie-file <path>", "Path to a Netscape cookie file or header text file")
+    .action(async (opts) => {
+    let header = opts.cookie;
+    if (!header && opts.cookieFile) {
+        header = fs.readFileSync(opts.cookieFile, "utf8");
+    }
+    if (!header) {
+        // eslint-disable-next-line no-console
+        console.error("No cookies provided. Use --cookie or --cookie-file.");
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const imported = normalizeCookieHeader(header);
+        const prev = loadAuthState() || { updatedAt: new Date().toISOString() };
+        saveAuthState({
+            ...prev,
+            cookiesHeader: imported.rawHeader
+        });
+        // eslint-disable-next-line no-console
+        console.log("Cookies imported successfully.");
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.error(`Failed to import cookies: ${err.message}`);
+        process.exitCode = 1;
+    }
+});
+const exportCommand = new Command("export")
+    .description("Export current auth material in a machine-readable format")
+    .option("--format <fmt>", "Output format: env|json", "env")
+    .option("--show-secrets", "Include raw secrets in output (use with care)", false)
+    .action(async (opts) => {
+    const state = loadAuthState();
+    if (!state) {
+        // eslint-disable-next-line no-console
+        console.error("No auth state found.");
+        process.exitCode = 1;
+        return;
+    }
+    const tokenValue = opts.showSecrets ? state.accessToken ?? "" : "<redacted>";
+    const cookieValue = opts.showSecrets ? state.cookiesHeader ?? "" : "<redacted>";
+    if (opts.format === "json") {
+        // eslint-disable-next-line no-console
+        console.log(JSON.stringify({
+            accessToken: tokenValue,
+            cookiesHeader: cookieValue,
+            updatedAt: state.updatedAt
+        }, null, 2));
+    }
+    else {
+        // env format
+        // eslint-disable-next-line no-console
+        console.log(`TDM_ACCESS_TOKEN=${tokenValue}`);
+        // eslint-disable-next-line no-console
+        console.log(`TDM_COOKIES_HEADER=${cookieValue}`);
+    }
+});
+const validateCommand = new Command("validate")
+    .description("Validate auth material presence and token validity")
+    .option("--local-only", "Only check local presence without remote Twitch validation", false)
+    .action(async (opts) => {
+    const result = validateAuthLocally();
+    if (!result.hasToken && !result.hasCookies) {
+        // eslint-disable-next-line no-console
+        console.error("No auth material found (token or cookies).");
+        process.exitCode = 1;
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.log(`Auth state: token=${result.hasToken ? "present" : "missing"}, cookies=${result.hasCookies ? "present" : "missing"}`);
+    if (!opts.localOnly) {
+        const remote = await validateAuthRemote();
+        if (!remote.valid) {
+            // eslint-disable-next-line no-console
+            console.error(`Remote token validation failed: ${remote.error ?? "unknown error"}`);
+            process.exitCode = 1;
+            return;
+        }
+        // eslint-disable-next-line no-console
+        console.log(`Remote token validation OK for user ${remote.userId}.`);
+    }
+});
+const logoutCommand = new Command("logout").description("Clear saved auth material").action(() => {
+    const state = loadAuthState();
+    if (!state) {
+        // eslint-disable-next-line no-console
+        console.log("No auth state to clear.");
+        return;
+    }
+    // Overwrite with empty values but keep file structure.
+    saveAuthState({
+        accessToken: undefined,
+        cookiesHeader: undefined,
+        updatedAt: new Date().toISOString()
+    });
+    // eslint-disable-next-line no-console
+    console.log("Auth state cleared.");
+});
+authCommand.addCommand(loginCommand);
+authCommand.addCommand(importTokenCommand);
+authCommand.addCommand(importCookieCommand);
+authCommand.addCommand(exportCommand);
+authCommand.addCommand(validateCommand);
+authCommand.addCommand(logoutCommand);

package/dist/cli/commands/config.js

@@ -0,0 +1,51 @@
+import { Command } from "@commander-js/extra-typings";
+import { loadConfig, saveConfig, configPath } from "../../config/store.js";
+import { ConfigSchema } from "../../config/schema.js";
+export const configCommand = new Command("config").description("Manage TwitchDropsMiner CLI configuration");
+const getCommand = new Command("get")
+    .argument("[key]", "Configuration key")
+    .action(async (key) => {
+    const cfg = loadConfig();
+    if (!key) {
+        // eslint-disable-next-line no-console
+        console.log(JSON.stringify(cfg, null, 2));
+    }
+    else {
+        const value = cfg[key];
+        // eslint-disable-next-line no-console
+        console.log(typeof value === "undefined" ? "" : JSON.stringify(value));
+    }
+});
+const setCommand = new Command("set")
+    .argument("<key>", "Configuration key")
+    .argument("<value>", "Configuration value")
+    .action(async (key, value) => {
+    const cfg = loadConfig();
+    let parsedValue = value;
+    try {
+        parsedValue = JSON.parse(value);
+    }
+    catch {
+        parsedValue = value;
+    }
+    cfg[key] = parsedValue;
+    const validated = ConfigSchema.parse(cfg);
+    saveConfig(validated);
+    // eslint-disable-next-line no-console
+    console.log(`Saved ${key}.`);
+});
+const validateCommand = new Command("validate").action(async () => {
+    ConfigSchema.parse(loadConfig());
+    // eslint-disable-next-line no-console
+    console.log("Config is valid.");
+});
+const pathCommand = new Command("path")
+    .description("Print config file path (create dir if missing)")
+    .action(() => {
+    // eslint-disable-next-line no-console
+    console.log(configPath());
+});
+configCommand.addCommand(getCommand);
+configCommand.addCommand(setCommand);
+configCommand.addCommand(validateCommand);
+configCommand.addCommand(pathCommand);

package/dist/cli/commands/doctor.js

@@ -0,0 +1,49 @@
+import { Command } from "@commander-js/extra-typings";
+import os from "node:os";
+import { request } from "undici";
+import { EXIT_ENV_UNSUPPORTED, EXIT_OK } from "../contracts/exitCodes.js";
+export const doctorCommand = new Command("doctor")
+    .description("Run environment checks for TwitchDropsMiner CLI")
+    .action(async () => {
+    // Basic checks for now; can be extended later.
+    const issues = [];
+    const platform = os.platform();
+    if (platform !== "linux" && platform !== "darwin" && platform !== "win32") {
+        issues.push(`Unsupported platform: ${platform}`);
+    }
+    // Node version check is effectively enforced via package.json engines,
+    // but we can still surface it here.
+    const [majorStr] = process.versions.node.split(".");
+    const major = Number(majorStr);
+    if (!Number.isNaN(major) && major < 20) {
+        issues.push(`Node.js version ${process.versions.node} is below the required >=20.`);
+    }
+    if (issues.length > 0) {
+        for (const msg of issues) {
+            // eslint-disable-next-line no-console
+            console.error(msg);
+        }
+        process.exitCode = EXIT_ENV_UNSUPPORTED;
+        return;
+    }
+    try {
+        const res = await request("https://id.twitch.tv/oauth2/validate", { method: "GET" });
+        if (res.statusCode >= 500) {
+            issues.push(`Twitch endpoint returned ${res.statusCode}.`);
+        }
+    }
+    catch (err) {
+        issues.push(`Network reachability check failed: ${err.message}`);
+    }
+    if (issues.length > 0) {
+        for (const msg of issues) {
+            // eslint-disable-next-line no-console
+            console.error(msg);
+        }
+        process.exitCode = EXIT_ENV_UNSUPPORTED;
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.log("Environment looks OK for TwitchDropsMiner CLI.");
+    process.exitCode = EXIT_OK;
+});

package/dist/cli/commands/games.js

@@ -0,0 +1,79 @@
+import { Command } from "@commander-js/extra-typings";
+import { SessionManager } from "../../auth/sessionManager.js";
+import { GQL_OPERATIONS } from "../../integrations/gqlOperations.js";
+import { gqlRequest } from "../../integrations/gqlClient.js";
+import { buildInventoryFromGqlResponses } from "../../domain/inventory.js";
+import { loadConfig, saveConfig } from "../../config/store.js";
+export const gamesCommand = new Command("games")
+    .description("List available drop campaigns/games from Twitch (use these names in priority)")
+    .option("--json", "Output as JSON")
+    .option("--add <gameName>", "Add a game name to config priority and save")
+    .action(async (opts) => {
+    const session = new SessionManager();
+    const token = session.getAccessToken();
+    if (!token) {
+        // eslint-disable-next-line no-console
+        console.error("Not logged in. Run: tdm auth login --no-open");
+        process.exitCode = 1;
+        return;
+    }
+    await session.validateAccessToken(token);
+    const [inventoryResponse, campaignsResponse] = await Promise.all([
+        gqlRequest(GQL_OPERATIONS.Inventory, token),
+        gqlRequest(GQL_OPERATIONS.Campaigns, token)
+    ]);
+    const cfg = loadConfig();
+    const built = buildInventoryFromGqlResponses(inventoryResponse, campaignsResponse, { enableBadgesEmotes: cfg.enableBadgesEmotes });
+    const rows = built.campaigns.map((c) => ({
+        gameName: c.gameName,
+        campaignName: c.name,
+        status: c.active ? "active" : c.upcoming ? "upcoming" : "expired",
+        eligible: c.eligible
+    }));
+    if (opts.add) {
+        const name = String(opts.add).trim();
+        const match = built.campaigns.find((c) => c.gameName === name || c.gameName.toLowerCase() === name.toLowerCase());
+        if (!match) {
+            // eslint-disable-next-line no-console
+            console.error(`No campaign found for "${name}". Use exact game name from list (e.g. tdm games).`);
+            process.exitCode = 1;
+            return;
+        }
+        const next = loadConfig();
+        const priority = [...next.priority];
+        if (!priority.includes(match.gameName)) {
+            priority.push(match.gameName);
+            saveConfig({ ...next, priority });
+            // eslint-disable-next-line no-console
+            console.log(`Added "${match.gameName}" to priority. Current priority: ${JSON.stringify(priority)}`);
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.log(`"${match.gameName}" already in priority.`);
+        }
+        return;
+    }
+    if (opts.json) {
+        // eslint-disable-next-line no-console
+        console.log(JSON.stringify(rows, null, 2));
+        return;
+    }
+    if (rows.length === 0) {
+        // eslint-disable-next-line no-console
+        console.log("No drop campaigns found. Link game accounts at https://www.twitch.tv/drops/campaigns");
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.log("Available games (use exact gameName in: tdm config set priority '[\"Game Name\"]')");
+    // eslint-disable-next-line no-console
+    console.log("---");
+    for (const r of rows) {
+        const elig = r.eligible ? "eligible" : "not-eligible";
+        // eslint-disable-next-line no-console
+        console.log(`${r.gameName}\t${r.status}\t${elig}\t# ${r.campaignName}`);
+    }
+    // eslint-disable-next-line no-console
+    console.log("---");
+    // eslint-disable-next-line no-console
+    console.log("To mine a game: tdm config set priority '[\"" + rows[0].gameName + "\"]'   (or use --add)");
+});