twitchdropsminer-cli 0.1.4 → 0.2.0

package/dist/cli/commands/status.js

@@ -1,5 +1,20 @@
 import { Command } from "@commander-js/extra-typings";
 import { loadSessionState } from "../../state/sessionState.js";
+import { isMinerLockHeldByLiveProcess } from "../../core/runtime.js";
+const SESSION_FRESH_MS = 120_000;
+function sessionImpliesRunning(rawState, updatedAt) {
+    if (rawState === "EXIT" || rawState === "UNKNOWN") {
+        return false;
+    }
+    if (!updatedAt) {
+        return false;
+    }
+    const t = new Date(updatedAt).getTime();
+    if (!Number.isFinite(t)) {
+        return false;
+    }
+    return Date.now() - t < SESSION_FRESH_MS;
+}
 export const statusCommand = new Command("status")
     .description("Show current miner status")
     .option("--json", "Output status as JSON")
@@ -11,8 +26,11 @@ export const statusCommand = new Command("status")
         : rawState !== "IDLE" && rawState !== "EXIT"
             ? "MAINTENANCE"
             : rawState;
+    const lockHeld = isMinerLockHeldByLiveProcess();
+    const running = lockHeld || sessionImpliesRunning(rawState, session?.updatedAt);
     const status = {
-        running: rawState !== "EXIT",
+        running,
+        lockHeld,
         state: highLevel,
         rawState,
         watchedChannel: session?.watchedChannelName ?? null,
@@ -24,6 +42,6 @@ export const statusCommand = new Command("status")
     }
     else {
         // eslint-disable-next-line no-console
-        console.log(`State=${status.state}, channel=${status.watchedChannel ?? "-"}, activeDrop=${status.activeDrop ?? "-"}`);
+        console.log(`Running=${status.running}, lock=${status.lockHeld}, state=${status.state}, channel=${status.watchedChannel ?? "-"}, activeDrop=${status.activeDrop ?? "-"}`);
     }
 });

package/dist/config/schema.js

@@ -11,6 +11,10 @@ export const ConfigSchema = z.object({
     trayNotifications: z.boolean().default(true),
     enableBadgesEmotes: z.boolean().default(false),
     availableDropsCheck: z.boolean().default(false),
-    priorityMode: PriorityModeSchema.default("priority_only")
+    priorityMode: PriorityModeSchema.default("priority_only"),
+    /** Max parallel GameDirectory GQL fetches when resolving channels (default 4). */
+    channelFetchConcurrency: z.number().int().min(1).max(10).default(4),
+    /** Override persisted-query sha256 hashes when Twitch rotates them (operationName -> hash). */
+    gqlHashOverrides: z.record(z.string(), z.string()).default({})
 });
 export const DEFAULT_CONFIG = ConfigSchema.parse({});

package/dist/core/channelService.js

@@ -2,6 +2,8 @@ import { GQL_OPERATIONS } from "../integrations/gqlOperations.js";
 import { gqlRequest } from "../integrations/gqlClient.js";
 import { sortChannelCandidates, canWatchChannel } from "../domain/channel.js";
 import { logger } from "./runtime.js";
+import { mapWithConcurrency } from "./concurrency.js";
+import { loadConfig } from "../config/store.js";
 export const MAX_CHANNELS = 100;
 /**
  * Parse Twitch GQL DirectoryPage_Game response into Channel list.
@@ -56,10 +58,6 @@ export function getAclChannelIdsFromCampaigns(_campaigns) {
     // When GQL provides campaign channel allowlist, add those ids here.
     return ids;
 }
-/**
- * Fetch channels for wanted games via GameDirectory GQL, merge and cap to maxChannels.
- * ACL channels (from campaign allowlist) are marked and preferred in sorting elsewhere.
- */
 /**
  * Resolve game name to Twitch directory slug (from campaigns when available).
  */
@@ -69,16 +67,22 @@ function gameNameToSlug(gameName, campaigns) {
 }
 export async function fetchChannelsForWantedGames(token, options) {
     const { wantedGames, campaigns, maxChannels = MAX_CHANNELS } = options;
+    const gql = options.gqlRequestImpl ??
+        ((op, t, v) => gqlRequest(op, t, v));
+    const concurrency = options.fetchConcurrency ?? loadConfig().channelFetchConcurrency;
     const aclIds = getAclChannelIdsFromCampaigns(campaigns);
     const byId = new Map();
-    for (const gameName of wantedGames) {
+    const rows = await mapWithConcurrency(wantedGames, concurrency, async (gameName) => {
         const slug = gameNameToSlug(gameName, campaigns);
-        const response = await gqlRequest(GQL_OPERATIONS.GameDirectory, token, {
+        const response = await gql(GQL_OPERATIONS.GameDirectory, token, {
             slug,
             limit: 30,
             sortTypeIsRecency: false,
             includeCostreaming: false
         });
+        return { gameName, slug, response };
+    });
+    for (const { gameName, slug, response } of rows) {
         const resp = response;
         const gqlErrors = resp?.errors;
         if (gqlErrors?.length) {

package/dist/core/concurrency.js

@@ -0,0 +1,22 @@
+/**
+ * Map items to promises with at most `concurrency` in flight (results align with input order).
+ */
+export async function mapWithConcurrency(items, concurrency, mapper) {
+    if (items.length === 0) {
+        return [];
+    }
+    const limit = Math.max(1, Math.min(concurrency, items.length));
+    const results = new Array(items.length);
+    let next = 0;
+    async function worker() {
+        while (true) {
+            const i = next++;
+            if (i >= items.length) {
+                return;
+            }
+            results[i] = await mapper(items[i], i);
+        }
+    }
+    await Promise.all(Array.from({ length: limit }, () => worker()));
+    return results;
+}

package/dist/core/miner.js

@@ -29,6 +29,10 @@ export class Miner {
     spadeUrlCache = new Map();
     pubsub = null;
     dryRun = false;
+    signalHandlersAttached = false;
+    onShutdownSignal = () => {
+        void this.shutdown();
+    };
     async run(options) {
         if (this.running) {
             return;
@@ -96,14 +100,10 @@ export class Miner {
                 this.state.setState("CHANNELS_CLEANUP");
             }
         });
-        process.on("SIGINT", () => {
-            void this.shutdown();
-        });
-        process.on("SIGTERM", () => {
-            void this.shutdown();
-        });
+        this.attachSignalHandlers();
     }
     async shutdown() {
+        this.detachSignalHandlers();
         this.running = false;
         this.watchLoop.stop();
         this.maintenance.stop();
@@ -120,6 +120,22 @@ export class Miner {
             watchedChannelName: this.watchingChannel?.login
         });
     }
+    attachSignalHandlers() {
+        if (this.signalHandlersAttached) {
+            return;
+        }
+        this.signalHandlersAttached = true;
+        process.on("SIGINT", this.onShutdownSignal);
+        process.on("SIGTERM", this.onShutdownSignal);
+    }
+    detachSignalHandlers() {
+        if (!this.signalHandlersAttached) {
+            return;
+        }
+        process.off("SIGINT", this.onShutdownSignal);
+        process.off("SIGTERM", this.onShutdownSignal);
+        this.signalHandlersAttached = false;
+    }
     async claimEligibleDrops(token) {
         for (const campaign of this.campaigns) {
             for (const drop of campaign.drops) {

package/dist/core/runtime.js

@@ -6,13 +6,37 @@ export const logger = pino({
     level: process.env.TDM_LOG_LEVEL || "info"
 });
 let lockFd = null;
-function lockPath() {
+export function minerLockPath() {
     const dir = path.join(os.homedir(), ".local", "state", "tdm");
     fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     return path.join(dir, "lock.file");
 }
+/** True if lock file exists and the recorded PID is still running (best-effort). */
+export function isMinerLockHeldByLiveProcess() {
+    const p = minerLockPath();
+    if (!fs.existsSync(p)) {
+        return false;
+    }
+    try {
+        const raw = fs.readFileSync(p, "utf8").trim();
+        const pid = Number(raw);
+        if (!Number.isFinite(pid) || pid <= 0) {
+            return true;
+        }
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+}
 export function ensureSingleInstanceLock() {
-    const p = lockPath();
+    const p = minerLockPath();
     try {
         lockFd = fs.openSync(p, "wx", 0o600);
         fs.writeFileSync(lockFd, String(process.pid));

package/dist/integrations/gqlClient.js

@@ -1,8 +1,46 @@
 import { httpJson } from "./httpClient.js";
 import { TWITCH_GQL_URL, TWITCH_ANDROID_CLIENT_ID, TWITCH_ANDROID_USER_AGENT } from "../core/constants.js";
-import { gqlPayload } from "./gqlOperations.js";
+import { gqlPayload, applyGqlHashOverride } from "./gqlOperations.js";
+import { loadConfig } from "../config/store.js";
+export class GqlPersistedQueryMismatchError extends Error {
+    operationName;
+    sha256Hash;
+    gqlMessages;
+    constructor(operationName, sha256Hash, gqlMessages) {
+        super(`Twitch GQL persisted query failed for "${operationName}" (sha256=${sha256Hash}). ` +
+            `Set "gqlHashOverrides" in config (see tdm config path) with { "${operationName}": "<new_hash>" }. ` +
+            `GQL: ${gqlMessages.slice(0, 400)}`);
+        this.name = "GqlPersistedQueryMismatchError";
+        this.operationName = operationName;
+        this.sha256Hash = sha256Hash;
+        this.gqlMessages = gqlMessages;
+    }
+}
+function collectGqlErrorText(payload) {
+    const rec = payload;
+    if (!rec.errors?.length) {
+        return "";
+    }
+    return rec.errors
+        .map((e) => {
+        const ext = e.extensions ? JSON.stringify(e.extensions) : "";
+        return `${e.message ?? ""} ${ext}`;
+    })
+        .join(" | ");
+}
+export function assertNoGqlPersistedQueryFailure(operation, payload) {
+    const text = collectGqlErrorText(payload);
+    if (!text) {
+        return;
+    }
+    if (/PersistedQueryNotFound|NotFoundForSha256|persisted query|does not match|Unknown query/i.test(text)) {
+        throw new GqlPersistedQueryMismatchError(operation.operationName, operation.sha256Hash, text);
+    }
+}
 export async function gqlRequest(operation, accessToken, variables) {
-    return httpJson("POST", TWITCH_GQL_URL, gqlPayload(operation, variables), {
+    const cfg = loadConfig();
+    const resolved = applyGqlHashOverride(operation, cfg.gqlHashOverrides);
+    const payload = await httpJson("POST", TWITCH_GQL_URL, gqlPayload(resolved, variables), {
         retries: 3,
         headers: {
             "Client-Id": TWITCH_ANDROID_CLIENT_ID,
@@ -10,4 +48,6 @@ export async function gqlRequest(operation, accessToken, variables) {
             Authorization: `OAuth ${accessToken}`
         }
     });
+    assertNoGqlPersistedQueryFailure(resolved, payload);
+    return payload;
 }

package/dist/integrations/gqlOperations.js

@@ -40,3 +40,11 @@ export function gqlPayload(operation, variables) {
         }
     };
 }
+/** Apply config overrides for persisted-query hashes (keyed by operationName). */
+export function applyGqlHashOverride(operation, overrides) {
+    const h = overrides[operation.operationName];
+    if (!h) {
+        return operation;
+    }
+    return { ...operation, sha256Hash: h };
+}

package/dist/integrations/httpClient.js

@@ -1,36 +1,109 @@
 import { request } from "undici";
+const DEFAULT_TIMEOUT_MS = 30_000;
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function jitterMs(base) {
+    return base + Math.floor(Math.random() * 0.25 * base);
+}
+function backoffMs(attempt, baseDelayMs) {
+    const exp = baseDelayMs * 2 ** Math.min(attempt, 8);
+    const capped = Math.min(60_000, exp);
+    return jitterMs(capped);
+}
+/** Parse Twitch/HTTP Retry-After header value: seconds or HTTP-date. */
+export function parseRetryAfterMsFromValue(raw) {
+    if (!raw) {
+        return null;
+    }
+    const trimmed = raw.trim();
+    const asNum = Number(trimmed);
+    if (!Number.isNaN(asNum) && asNum >= 0) {
+        return asNum * 1000;
+    }
+    const when = Date.parse(trimmed);
+    if (!Number.isNaN(when)) {
+        return Math.max(0, when - Date.now());
+    }
+    return null;
+}
+/** Parse Retry-After from Fetch-style headers. */
+export function parseRetryAfterMs(headers) {
+    return parseRetryAfterMsFromValue(headers.get("retry-after"));
+}
+function retryAfterFromUndiciHeaders(headers) {
+    const h = headers;
+    if (typeof h.get === "function") {
+        return parseRetryAfterMsFromValue(h.get("retry-after"));
+    }
+    return null;
+}
+function isAbortError(err) {
+    return (err instanceof Error &&
+        (err.name === "AbortError" || err.message.includes("aborted") || err.message.includes("timeout")));
+}
+export class HttpResponseError extends Error {
+    statusCode;
+    bodySnippet;
+    constructor(statusCode, bodySnippet) {
+        super(`HTTP ${statusCode}: ${bodySnippet.slice(0, 500)}`);
+        this.name = "HttpResponseError";
+        this.statusCode = statusCode;
+        this.bodySnippet = bodySnippet;
+    }
+}
 export async function httpJson(method, url, body, options) {
     const retries = options?.retries ?? 3;
     const retryDelayMs = options?.retryDelayMs ?? 1_000;
+    const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     let lastError;
     for (let attempt = 0; attempt <= retries; attempt += 1) {
         try {
+            const signal = AbortSignal.timeout(timeoutMs);
             const response = await request(url, {
                 method: method,
                 headers: {
                     "content-type": "application/json",
                     ...(options?.headers ?? {})
                 },
-                body: body !== undefined ? JSON.stringify(body) : undefined
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+                signal
             });
             const text = await response.body.text();
-            if (response.statusCode >= 500) {
-                throw new Error(`HTTP ${response.statusCode}: ${text}`);
+            if (response.statusCode >= 200 && response.statusCode < 300) {
+                if (!text) {
+                    return {};
+                }
+                return JSON.parse(text);
             }
-            if (!text) {
-                return {};
+            if (response.statusCode === 429 || response.statusCode >= 500) {
+                lastError = new HttpResponseError(response.statusCode, text);
+                if (attempt === retries) {
+                    break;
+                }
+                const fromHeader = retryAfterFromUndiciHeaders(response.headers);
+                const waitMs = fromHeader !== null ? fromHeader : backoffMs(attempt, retryDelayMs);
+                await sleep(waitMs);
+                continue;
             }
-            return JSON.parse(text);
+            throw new HttpResponseError(response.statusCode, text);
         }
         catch (err) {
             lastError = err;
+            if (err instanceof HttpResponseError) {
+                throw err;
+            }
             if (attempt === retries) {
                 break;
             }
-            await sleep(retryDelayMs * (attempt + 1));
+            const retryable = isAbortError(err) ||
+                err instanceof TypeError ||
+                (err instanceof Error &&
+                    /ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|socket/i.test(err.message));
+            if (!retryable) {
+                throw err;
+            }
+            await sleep(backoffMs(attempt, retryDelayMs));
         }
     }
     throw lastError instanceof Error ? lastError : new Error("HTTP request failed.");

package/dist/integrations/twitchPubSub.js

@@ -1,29 +1,40 @@
 import WebSocket from "ws";
-import { PING_INTERVAL_MS, TWITCH_PUBSUB_URL, WS_TOPICS_LIMIT } from "../core/constants.js";
+import { PING_INTERVAL_MS, PING_TIMEOUT_MS, TWITCH_PUBSUB_URL, WS_TOPICS_LIMIT } from "../core/constants.js";
+const RECONNECT_BASE_MS = 1_000;
+const RECONNECT_MAX_MS = 60_000;
+function reconnectDelayMs(attempt) {
+    const exp = Math.min(RECONNECT_MAX_MS, RECONNECT_BASE_MS * 2 ** Math.min(attempt, 10));
+    const jitter = Math.floor(Math.random() * 0.25 * exp);
+    return exp + jitter;
+}
 export class TwitchPubSub {
     ws = null;
     pingTimer = null;
+    pongWatchTimer = null;
+    reconnectTimer = null;
     handlers = new Map();
     subscribedTopics = new Set();
     authToken = null;
+    stopped = false;
+    reconnectAttempt = 0;
+    createWs;
+    constructor(options) {
+        this.createWs = options?.createWebSocket ?? ((url) => new WebSocket(url));
+    }
     async start() {
+        if (this.stopped) {
+            return;
+        }
         if (this.ws && this.ws.readyState === WebSocket.OPEN) {
             return;
         }
-        await new Promise((resolve, reject) => {
-            const ws = new WebSocket(TWITCH_PUBSUB_URL);
-            this.ws = ws;
-            ws.on("open", () => {
-                this.startPing();
-                resolve();
-            });
-            ws.on("error", (err) => reject(err));
-            ws.on("message", (data) => this.onMessage(data.toString()));
-            ws.on("close", () => this.stopPing());
-        });
+        await this.connectOnce();
     }
     async stop() {
+        this.stopped = true;
+        this.clearReconnectTimer();
         this.stopPing();
+        this.clearPongWatch();
         this.subscribedTopics.clear();
         this.authToken = null;
         const ws = this.ws;
@@ -41,9 +52,6 @@ export class TwitchPubSub {
     }
     /** Subscribe to topics; batches and enforces WS_TOPICS_LIMIT. Stores token for reconnect. */
     listen(topics, authToken) {
-        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-            throw new Error("PubSub socket is not connected.");
-        }
         this.authToken = authToken;
         const toAdd = topics.filter((t) => !this.subscribedTopics.has(t));
         if (toAdd.length === 0)
@@ -55,22 +63,19 @@ export class TwitchPubSub {
         for (const t of batch) {
             this.subscribedTopics.add(t);
         }
-        this.ws.send(JSON.stringify({
-            type: "LISTEN",
-            data: { topics: batch, auth_token: authToken }
-        }));
+        this.sendListenBatch(batch, authToken);
     }
     /** Unsubscribe from topics and send UNLISTEN. */
     unlisten(topics, authToken) {
-        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-            return;
-        }
         const toRemove = topics.filter((t) => this.subscribedTopics.has(t));
         if (toRemove.length === 0)
             return;
         for (const t of toRemove) {
             this.subscribedTopics.delete(t);
         }
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            return;
+        }
         this.ws.send(JSON.stringify({
             type: "UNLISTEN",
             data: { topics: toRemove, auth_token: authToken }
@@ -79,10 +84,89 @@ export class TwitchPubSub {
     getSubscribedTopics() {
         return Array.from(this.subscribedTopics);
     }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    scheduleReconnect() {
+        if (this.stopped || this.reconnectTimer) {
+            return;
+        }
+        const delay = reconnectDelayMs(this.reconnectAttempt);
+        this.reconnectAttempt += 1;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            void this.connectOnce().catch(() => {
+                if (!this.stopped) {
+                    this.scheduleReconnect();
+                }
+            });
+        }, delay);
+    }
+    async connectOnce() {
+        if (this.stopped) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            const ws = this.createWs(TWITCH_PUBSUB_URL);
+            this.ws = ws;
+            let opened = false;
+            const onOpen = () => {
+                opened = true;
+                this.reconnectAttempt = 0;
+                this.resubscribeAll();
+                this.startPing();
+                ws.off("error", onError);
+                resolve();
+            };
+            const onError = (err) => {
+                ws.off("open", onOpen);
+                reject(err);
+            };
+            ws.once("open", onOpen);
+            ws.once("error", onError);
+            ws.on("message", (data) => {
+                void this.onMessage(data.toString());
+            });
+            ws.on("close", () => {
+                this.stopPing();
+                this.clearPongWatch();
+                const wasCurrent = this.ws === ws;
+                if (wasCurrent) {
+                    this.ws = null;
+                }
+                if (!this.stopped && wasCurrent && opened) {
+                    this.scheduleReconnect();
+                }
+            });
+        });
+    }
+    resubscribeAll() {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN || !this.authToken) {
+            return;
+        }
+        const topics = Array.from(this.subscribedTopics);
+        for (let i = 0; i < topics.length; i += WS_TOPICS_LIMIT) {
+            const batch = topics.slice(i, i + WS_TOPICS_LIMIT);
+            this.sendListenBatch(batch, this.authToken);
+        }
+    }
+    sendListenBatch(batch, authToken) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            return;
+        }
+        this.ws.send(JSON.stringify({
+            type: "LISTEN",
+            data: { topics: batch, auth_token: authToken }
+        }));
+    }
     startPing() {
         this.stopPing();
         this.pingTimer = setInterval(() => {
             if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                this.armPongWatch();
                 this.ws.send(JSON.stringify({ type: "PING" }));
             }
         }, PING_INTERVAL_MS);
@@ -93,6 +177,27 @@ export class TwitchPubSub {
             this.pingTimer = null;
         }
     }
+    armPongWatch() {
+        this.clearPongWatch();
+        this.pongWatchTimer = setTimeout(() => {
+            this.pongWatchTimer = null;
+            const ws = this.ws;
+            if (ws && ws.readyState === WebSocket.OPEN) {
+                try {
+                    ws.terminate();
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }, PING_TIMEOUT_MS);
+    }
+    clearPongWatch() {
+        if (this.pongWatchTimer) {
+            clearTimeout(this.pongWatchTimer);
+            this.pongWatchTimer = null;
+        }
+    }
     async onMessage(raw) {
         let parsed;
         try {
@@ -102,6 +207,7 @@ export class TwitchPubSub {
             return;
         }
         if (parsed.type === "PONG") {
+            this.clearPongWatch();
             return;
         }
         if (parsed.type === "MESSAGE" && typeof parsed.data === "object" && parsed.data) {

package/dist/tests/index.js

@@ -1,7 +1,12 @@
 import "./unit/tokenImport.test.js";
 import "./unit/channel.test.js";
 import "./unit/channelService.test.js";
+import "./unit/channelServiceConcurrency.test.js";
+import "./unit/concurrency.test.js";
 import "./unit/dropsDomain.test.js";
+import "./unit/gqlClient.test.js";
+import "./unit/httpClient.test.js";
+import "./unit/twitchPubSub.test.js";
 import "./unit/twitchSpade.test.js";
 import "./integration/configStore.test.js";
 import "./parity/stateMachineFlow.test.js";

package/dist/tests/unit/channelServiceConcurrency.test.js

@@ -0,0 +1,35 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { fetchChannelsForWantedGames } from "../../core/channelService.js";
+import { GQL_OPERATIONS } from "../../integrations/gqlOperations.js";
+test("fetchChannelsForWantedGames respects fetchConcurrency", async () => {
+    let maxParallel = 0;
+    let current = 0;
+    const games = ["A", "B", "C", "D", "E", "F"];
+    await fetchChannelsForWantedGames("fake-token", {
+        wantedGames: games,
+        campaigns: [],
+        fetchConcurrency: 2,
+        gqlRequestImpl: async (_op, _token, _vars) => {
+            current += 1;
+            maxParallel = Math.max(maxParallel, current);
+            await new Promise((r) => setTimeout(r, 5));
+            current -= 1;
+            return { data: { game: { streams: { edges: [] } } } };
+        }
+    });
+    assert.equal(maxParallel, 2);
+});
+test("fetchChannelsForWantedGames uses GameDirectory operation", async () => {
+    let seenOp;
+    await fetchChannelsForWantedGames("t", {
+        wantedGames: ["X"],
+        campaigns: [],
+        fetchConcurrency: 1,
+        gqlRequestImpl: async (op) => {
+            seenOp = op;
+            return { data: { game: { streams: { edges: [] } } } };
+        }
+    });
+    assert.equal(seenOp.operationName, GQL_OPERATIONS.GameDirectory.operationName);
+});

package/dist/tests/unit/concurrency.test.js

@@ -0,0 +1,21 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mapWithConcurrency } from "../../core/concurrency.js";
+test("mapWithConcurrency limits parallel execution", async () => {
+    let inFlight = 0;
+    let maxInFlight = 0;
+    const items = [1, 2, 3, 4, 5, 6];
+    const results = await mapWithConcurrency(items, 2, async (n) => {
+        inFlight += 1;
+        maxInFlight = Math.max(maxInFlight, inFlight);
+        await new Promise((r) => setTimeout(r, 5));
+        inFlight -= 1;
+        return n * 2;
+    });
+    assert.deepEqual(results, [2, 4, 6, 8, 10, 12]);
+    assert.equal(maxInFlight, 2);
+});
+test("mapWithConcurrency preserves order", async () => {
+    const out = await mapWithConcurrency(["a", "b", "c"], 3, async (x) => `${x}1`);
+    assert.deepEqual(out, ["a1", "b1", "c1"]);
+});

package/dist/tests/unit/gqlClient.test.js

@@ -0,0 +1,14 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { assertNoGqlPersistedQueryFailure, GqlPersistedQueryMismatchError } from "../../integrations/gqlClient.js";
+import { GQL_OPERATIONS } from "../../integrations/gqlOperations.js";
+test("assertNoGqlPersistedQueryFailure ignores empty errors", () => {
+    assertNoGqlPersistedQueryFailure(GQL_OPERATIONS.Inventory, { data: {} });
+});
+test("assertNoGqlPersistedQueryFailure throws on persisted query mismatch", () => {
+    assert.throws(() => assertNoGqlPersistedQueryFailure(GQL_OPERATIONS.Inventory, {
+        errors: [{ message: "PersistedQueryNotFound" }]
+    }), (e) => e instanceof GqlPersistedQueryMismatchError &&
+        e.operationName === "Inventory" &&
+        e.sha256Hash === GQL_OPERATIONS.Inventory.sha256Hash);
+});

package/dist/tests/unit/httpClient.test.js

@@ -0,0 +1,52 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { httpJson, parseRetryAfterMs, parseRetryAfterMsFromValue, HttpResponseError } from "../../integrations/httpClient.js";
+test("parseRetryAfterMsFromValue parses delay-seconds", () => {
+    assert.equal(parseRetryAfterMsFromValue("5"), 5000);
+    assert.equal(parseRetryAfterMsFromValue("0"), 0);
+});
+test("parseRetryAfterMs reads header object", () => {
+    assert.equal(parseRetryAfterMs({ get: () => "2" }), 2000);
+    assert.equal(parseRetryAfterMs({ get: () => null }), null);
+});
+test("httpJson retries on 429 then succeeds", async () => {
+    let hits = 0;
+    const server = createServer((req, res) => {
+        hits += 1;
+        if (hits === 1) {
+            res.writeHead(429, { "Retry-After": "0" });
+            res.end("{}");
+            return;
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true }));
+    });
+    await new Promise((resolve) => server.listen(0, resolve));
+    const { port } = server.address();
+    try {
+        const out = await httpJson("GET", `http://127.0.0.1:${port}/`, undefined, { retries: 2, retryDelayMs: 10, timeoutMs: 5000 });
+        assert.equal(out.ok, true);
+        assert.equal(hits, 2);
+    }
+    finally {
+        await new Promise((resolve, reject) => server.close((err) => (err ? reject(err) : resolve())));
+    }
+});
+test("httpJson fails fast on non-retryable 4xx", async () => {
+    const server = createServer((_req, res) => {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "nope" }));
+    });
+    await new Promise((resolve) => server.listen(0, resolve));
+    const { port } = server.address();
+    try {
+        await assert.rejects(() => httpJson("GET", `http://127.0.0.1:${port}/`, undefined, {
+            retries: 3,
+            timeoutMs: 5000
+        }), (e) => e instanceof HttpResponseError && e.statusCode === 404);
+    }
+    finally {
+        await new Promise((resolve, reject) => server.close((err) => (err ? reject(err) : resolve())));
+    }
+});

package/dist/tests/unit/twitchPubSub.test.js

@@ -0,0 +1,63 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import WebSocket from "ws";
+import { TwitchPubSub } from "../../integrations/twitchPubSub.js";
+/** Minimal socket stub matching how TwitchPubSub uses `ws`. */
+class FakeSocket extends EventEmitter {
+    static OPEN = WebSocket.OPEN;
+    readyState = WebSocket.CONNECTING;
+    sent = [];
+    send(data) {
+        this.sent.push(data);
+    }
+    openNow() {
+        this.readyState = WebSocket.OPEN;
+        this.emit("open");
+    }
+    close() {
+        this.readyState = WebSocket.CLOSED;
+        this.emit("close");
+    }
+    terminate() {
+        this.close();
+    }
+}
+test("TwitchPubSub listen sends LISTEN after open", async () => {
+    let sock;
+    const pubsub = new TwitchPubSub({
+        createWebSocket: () => {
+            sock = new FakeSocket();
+            queueMicrotask(() => sock.openNow());
+            return sock;
+        }
+    });
+    await pubsub.start();
+    pubsub.listen(["user-drop-events.99"], "tok");
+    const listenMsg = sock.sent.find((s) => s.includes('"LISTEN"'));
+    assert.ok(listenMsg);
+    assert.ok(listenMsg.includes("user-drop-events.99"));
+    assert.ok(listenMsg.includes("tok"));
+    await pubsub.stop();
+});
+test("TwitchPubSub reconnect resubscribes topics", async () => {
+    const sockets = [];
+    const pubsub = new TwitchPubSub({
+        createWebSocket: () => {
+            const s = new FakeSocket();
+            sockets.push(s);
+            queueMicrotask(() => s.openNow());
+            return s;
+        }
+    });
+    await pubsub.start();
+    pubsub.listen(["topic.one"], "token1");
+    const first = sockets[0];
+    assert.ok(first.sent.some((x) => x.includes("topic.one")));
+    first.close();
+    await new Promise((r) => setTimeout(r, 2500));
+    assert.ok(sockets.length >= 2, "expected second socket after reconnect");
+    const second = sockets[sockets.length - 1];
+    assert.ok(second.sent.some((x) => x.includes("topic.one")));
+    await pubsub.stop();
+});

package/docs/ops/authentication.md

@@ -1,32 +1,32 @@
-## Authentication (headless)
-
-### Device-code login (recommended)
-
-```bash
-tdm auth login --no-open
-```
-
-Follow the printed `verification_uri` and `user_code` on another device.
-
-### Import an existing token
-
-```bash
-tdm auth import --token "auth-token=XXXX"
-# or
-tdm auth import --token-file /secure/path/token.txt
-```
-
-### Import cookies
-
-```bash
-tdm auth import-cookie --cookie "auth-token=XXXX; other=YYY"
-# or
-tdm auth import-cookie --cookie-file /secure/path/cookies.txt
-```
-
-### Validate
-
-```bash
-tdm auth validate
-```
-
+## Authentication (headless)
+
+### Device-code login (recommended)
+
+```bash
+tdm auth login --no-open
+```
+
+Follow the printed `verification_uri` and `user_code` on another device.
+
+### Import an existing token
+
+```bash
+tdm auth import --token "auth-token=XXXX"
+# or
+tdm auth import --token-file /secure/path/token.txt
+```
+
+### Import cookies
+
+```bash
+tdm auth import-cookie --cookie "auth-token=XXXX; other=YYY"
+# or
+tdm auth import-cookie --cookie-file /secure/path/cookies.txt
+```
+
+### Validate
+
+```bash
+tdm auth validate
+```
+

package/docs/ops/drops-validation.md

@@ -1,73 +1,73 @@
-# Drops validation playbook
-
-This playbook helps confirm that the CLI actually advances and claims Twitch Drops as intended, without opening a browser stream.
-
-## Prerequisites
-
-- A Twitch account (test account recommended).
-- CLI installed and built: `npm run build`.
-- Auth completed: `tdm auth login --no-open` (or paste token when prompted).
-
-## 1. Configure for a single game
-
-- Choose an active Drops campaign with a **short first drop** (e.g. 15–30 minutes) so you can see progress quickly.
-- In config (e.g. `~/.config/tdm/config.json` or project `tdm.config.json`), set:
-  - `priority`: `["<Game Name>"]` (exact game name from the campaign).
-  - `priorityMode`: `"priority_only"` so only that game is mined.
-  - `exclude`: `[]` (or leave default).
-
-## 2. Dry run (no network writes)
-
-- Run with dry-run and verbose to see intended actions only:
-  ```bash
-  tdm run --dry-run --verbose
-  ```
-- Confirm logs show:
-  - Inventory fetch and campaign list.
-  - Wanted games = your priority game.
-  - Channel fetch and selected channel.
-  - “Would send watch” (no real spade POST).
-  - “Would claim” for any claimable drop (no real ClaimDrop GQL).
-- Stop with Ctrl+C.
-
-## 3. Live run and Twitch Inventory check
-
-- In a browser, open [Twitch Drops Inventory](https://www.twitch.tv/drops/inventory) and log in with the same account.
-- Note the current “minutes watched” (and “Claim” button if the drop is ready) for the target campaign.
-- Start the miner:
-  ```bash
-  tdm run --verbose
-  ```
-- Let it run for at least one watch interval (about 1 minute). You should see “Watch tick sent for channel …” in the logs.
-- Refresh the Twitch Inventory page: “minutes watched” for the active drop should increase (may take 1–2 minutes to reflect).
-- If the drop becomes claimable, the CLI should auto-claim; check logs for “Claimed drop” and confirm the drop shows as claimed in the Inventory.
-
-## 4. Compare with Python miner (optional)
-
-- Using the same Twitch account and same priority game:
-  - Run the Python TwitchDropsMiner and note progression/claim time.
-  - Run the CLI with the same config and note progression/claim time.
-- Progression and claim times should be comparable (allow for Twitch-side variance).
-
-## 5. Status command
-
-- While the miner is running (or after it has run), in another terminal:
-  ```bash
-  tdm status
-  tdm status --json
-  ```
-- Confirm `state` (e.g. WATCHING or MAINTENANCE) and `activeDrop` (e.g. “Game Name: Drop Name”) look correct.
-
-## Success criteria
-
-- With a test account and active drops campaign:
-  - `tdm run` increases “minutes watched” for the targeted drop on Twitch Inventory without opening a stream in the browser.
-  - Drops are claimed automatically when eligible (or a manual step is documented).
-  - `tdm run --dry-run --verbose` logs intended watch and claim actions without performing spade/claim network calls.
-  - `tdm status` shows a sensible state and active drop.
-
-## Troubleshooting
-
-- **No channels / “No channel candidates”**: Ensure the game has live streams with Drops enabled; try a different game or relax `priorityMode`.
-- **Watch tick failed**: Spade URL extraction or auth may be failing; run with `--verbose` and check logs.
-- **Minutes not updating**: Twitch can delay updates; wait 2–3 minutes and refresh the Inventory page. Ensure you’re watching a channel that has Drops for that campaign.
+# Drops validation playbook
+
+This playbook helps confirm that the CLI actually advances and claims Twitch Drops as intended, without opening a browser stream.
+
+## Prerequisites
+
+- A Twitch account (test account recommended).
+- CLI installed and built: `npm run build`.
+- Auth completed: `tdm auth login --no-open` (or paste token when prompted).
+
+## 1. Configure for a single game
+
+- Choose an active Drops campaign with a **short first drop** (e.g. 15–30 minutes) so you can see progress quickly.
+- In config (e.g. `~/.config/tdm/config.json` or project `tdm.config.json`), set:
+  - `priority`: `["<Game Name>"]` (exact game name from the campaign).
+  - `priorityMode`: `"priority_only"` so only that game is mined.
+  - `exclude`: `[]` (or leave default).
+
+## 2. Dry run (no network writes)
+
+- Run with dry-run and verbose to see intended actions only:
+  ```bash
+  tdm run --dry-run --verbose
+  ```
+- Confirm logs show:
+  - Inventory fetch and campaign list.
+  - Wanted games = your priority game.
+  - Channel fetch and selected channel.
+  - “Would send watch” (no real spade POST).
+  - “Would claim” for any claimable drop (no real ClaimDrop GQL).
+- Stop with Ctrl+C.
+
+## 3. Live run and Twitch Inventory check
+
+- In a browser, open [Twitch Drops Inventory](https://www.twitch.tv/drops/inventory) and log in with the same account.
+- Note the current “minutes watched” (and “Claim” button if the drop is ready) for the target campaign.
+- Start the miner:
+  ```bash
+  tdm run --verbose
+  ```
+- Let it run for at least one watch interval (about 1 minute). You should see “Watch tick sent for channel …” in the logs.
+- Refresh the Twitch Inventory page: “minutes watched” for the active drop should increase (may take 1–2 minutes to reflect).
+- If the drop becomes claimable, the CLI should auto-claim; check logs for “Claimed drop” and confirm the drop shows as claimed in the Inventory.
+
+## 4. Compare with Python miner (optional)
+
+- Using the same Twitch account and same priority game:
+  - Run the Python TwitchDropsMiner and note progression/claim time.
+  - Run the CLI with the same config and note progression/claim time.
+- Progression and claim times should be comparable (allow for Twitch-side variance).
+
+## 5. Status command
+
+- While the miner is running (or after it has run), in another terminal:
+  ```bash
+  tdm status
+  tdm status --json
+  ```
+- Confirm `state` (e.g. WATCHING or MAINTENANCE) and `activeDrop` (e.g. “Game Name: Drop Name”) look correct.
+
+## Success criteria
+
+- With a test account and active drops campaign:
+  - `tdm run` increases “minutes watched” for the targeted drop on Twitch Inventory without opening a stream in the browser.
+  - Drops are claimed automatically when eligible (or a manual step is documented).
+  - `tdm run --dry-run --verbose` logs intended watch and claim actions without performing spade/claim network calls.
+  - `tdm status` shows a sensible state and active drop.
+
+## Troubleshooting
+
+- **No channels / “No channel candidates”**: Ensure the game has live streams with Drops enabled; try a different game or relax `priorityMode`.
+- **Watch tick failed**: Spade URL extraction or auth may be failing; run with `--verbose` and check logs.
+- **Minutes not updating**: Twitch can delay updates; wait 2–3 minutes and refresh the Inventory page. Ensure you’re watching a channel that has Drops for that campaign.

package/docs/ops/linux-install.md

@@ -1,15 +1,15 @@
-## Linux install (headless)
-
-- **Prereqs**: `node >= 20`, outbound HTTPS/WSS to Twitch.
-- Install globally:
-
-```bash
-npm install -g twitchdropsminer-cli
-```
-
-- Verify environment:
-
-```bash
-tdm doctor
-```
-
+## Linux install (headless)
+
+- **Prereqs**: `node >= 20`, outbound HTTPS/WSS to Twitch.
+- Install globally:
+
+```bash
+npm install -g twitchdropsminer-cli
+```
+
+- Verify environment:
+
+```bash
+tdm doctor
+```
+

package/docs/ops/service-management.md

@@ -1,23 +1,23 @@
-## Running as a service (systemd)
-
-### Install user-level service
-
-```bash
-tdm service install --user --autostart
-tdm service start
-```
-
-### Check status
-
-```bash
-tdm service status
-```
-
-### Logs (journalctl)
-
-Use standard `journalctl` commands, e.g.:
-
-```bash
-journalctl --user -u tdm.service -f
-```
-
+## Running as a service (systemd)
+
+### Install user-level service
+
+```bash
+tdm service install --user --autostart
+tdm service start
+```
+
+### Check status
+
+```bash
+tdm service status
+```
+
+### Logs (journalctl)
+
+Use standard `journalctl` commands, e.g.:
+
+```bash
+journalctl --user -u tdm.service -f
+```
+

package/docs/ops/systemd-hardening.md

@@ -1,13 +1,13 @@
-## systemd hardening notes
-
-Recommended service-level settings:
-
-- `NoNewPrivileges=true`
-- `PrivateTmp=true`
-- `Restart=on-failure`
-- `RestartSec=5`
-- `After=network-online.target`
-- `Wants=network-online.target`
-
-Use user-level units for least privilege unless you explicitly need a system unit.
-
+## systemd hardening notes
+
+Recommended service-level settings:
+
+- `NoNewPrivileges=true`
+- `PrivateTmp=true`
+- `Restart=on-failure`
+- `RestartSec=5`
+- `After=network-online.target`
+- `Wants=network-online.target`
+
+Use user-level units for least privilege unless you explicitly need a system unit.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "twitchdropsminer-cli",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Headless CLI rewrite of DevilXD/TwitchDropsMiner for mining Twitch drops on servers.",
   "bin": {
     "tdm": "dist/cli/index.js"

package/resources/systemd/tdm.service.tpl

@@ -1,17 +1,17 @@
-[Unit]
-Description=Twitch Drops Miner CLI
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-ExecStart={{NODE_PATH}} {{TDM_BIN}} run
-Restart=on-failure
-RestartSec=5
-NoNewPrivileges=true
-PrivateTmp=true
-Environment=TDM_LOG_LEVEL=info
-
-[Install]
-WantedBy=default.target
-
+[Unit]
+Description=Twitch Drops Miner CLI
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart={{NODE_PATH}} {{TDM_BIN}} run
+Restart=on-failure
+RestartSec=5
+NoNewPrivileges=true
+PrivateTmp=true
+Environment=TDM_LOG_LEVEL=info
+
+[Install]
+WantedBy=default.target
+