twitchdropsminer-cli 0.1.0

package/dist/domain/inventory.js

@@ -0,0 +1,370 @@
+const MAX_EXTRA_MINUTES = 15;
+export var BenefitType;
+(function (BenefitType) {
+    BenefitType["UNKNOWN"] = "UNKNOWN";
+    BenefitType["BADGE"] = "BADGE";
+    BenefitType["EMOTE"] = "EMOTE";
+    BenefitType["DIRECT_ENTITLEMENT"] = "DIRECT_ENTITLEMENT";
+})(BenefitType || (BenefitType = {}));
+export class Benefit {
+    id;
+    name;
+    type;
+    imageUrl;
+    constructor(data) {
+        const benefit = data.benefit;
+        this.id = String(benefit.id);
+        this.name = String(benefit.name);
+        const distType = String(benefit.distributionType ?? "UNKNOWN");
+        this.type =
+            Object.values(BenefitType).includes(distType) && distType in BenefitType
+                ? distType
+                : BenefitType.UNKNOWN;
+        this.imageUrl = String(benefit.imageAssetURL ?? "");
+    }
+    isBadgeOrEmote() {
+        return this.type === BenefitType.BADGE || this.type === BenefitType.EMOTE;
+    }
+}
+export class TimedDrop {
+    id;
+    name;
+    campaign;
+    benefits;
+    startsAt;
+    endsAt;
+    requiredMinutes;
+    preconditionDropIds;
+    claimId;
+    claimed;
+    realCurrentMinutes;
+    extraCurrentMinutes;
+    constructor(campaign, data, claimedBenefits) {
+        this.campaign = campaign;
+        this.id = String(data.id);
+        this.name = String(data.name);
+        const benefitEdges = data.benefitEdges || [];
+        this.benefits = benefitEdges.map((b) => new Benefit(b));
+        this.startsAt = new Date(String(data.startAt));
+        this.endsAt = new Date(String(data.endAt));
+        const selfEdge = data.self ?? undefined;
+        this.claimId =
+            selfEdge && typeof selfEdge.dropInstanceID === "string"
+                ? selfEdge.dropInstanceID
+                : null;
+        this.claimed = !!(selfEdge && selfEdge.isClaimed);
+        const required = Number(data.requiredMinutesWatched ?? 0);
+        this.requiredMinutes = Number.isFinite(required) ? required : 0;
+        const currentFromSelf = Number(selfEdge?.currentMinutesWatched ?? 0);
+        this.realCurrentMinutes = Number.isFinite(currentFromSelf) ? currentFromSelf : 0;
+        this.extraCurrentMinutes = 0;
+        // If not explicitly claimed, infer from claimed benefits window.
+        if (!this.claimed && this.benefits.length > 0) {
+            const timestamps = [];
+            for (const benefit of this.benefits) {
+                const ts = claimedBenefits[benefit.id];
+                if (ts) {
+                    timestamps.push(ts);
+                }
+            }
+            if (timestamps.length > 0 && timestamps.every((dt) => this.startsAt <= dt && dt < this.endsAt)) {
+                this.claimed = true;
+            }
+        }
+        if (this.claimed) {
+            this.realCurrentMinutes = this.requiredMinutes;
+        }
+        const preconditions = data.preconditionDrops ?? [];
+        this.preconditionDropIds = preconditions.map((d) => String(d.id));
+    }
+    get isClaimed() {
+        return this.claimed;
+    }
+    get dropInstanceId() {
+        return this.claimId;
+    }
+    get currentMinutes() {
+        return this.realCurrentMinutes + this.extraCurrentMinutes;
+    }
+    get remainingMinutes() {
+        return Math.max(0, this.requiredMinutes - this.currentMinutes);
+    }
+    get totalRequiredMinutes() {
+        const chainTotal = this.preconditionDropIds
+            .map((id) => this.campaign.timedDrops.get(id))
+            .filter((d) => !!d)
+            .reduce((acc, d) => acc + d.totalRequiredMinutes, 0);
+        return this.requiredMinutes + chainTotal;
+    }
+    get totalRemainingMinutes() {
+        const chainRemaining = this.preconditionDropIds
+            .map((id) => this.campaign.timedDrops.get(id))
+            .filter((d) => !!d)
+            .reduce((acc, d) => acc + d.totalRemainingMinutes, 0);
+        return this.remainingMinutes + chainRemaining;
+    }
+    get progress() {
+        if (this.currentMinutes <= 0 || this.requiredMinutes <= 0) {
+            return 0;
+        }
+        if (this.currentMinutes >= this.requiredMinutes) {
+            return 1;
+        }
+        return this.currentMinutes / this.requiredMinutes;
+    }
+    get availability() {
+        const now = new Date();
+        if (this.requiredMinutes > 0 &&
+            this.totalRemainingMinutes > 0 &&
+            now.getTime() < this.endsAt.getTime()) {
+            const minutesLeft = (this.endsAt.getTime() - now.getTime()) / 60000;
+            return minutesLeft / this.totalRemainingMinutes;
+        }
+        return Number.POSITIVE_INFINITY;
+    }
+    baseEarnConditions() {
+        return (!this.claimed &&
+            (this.benefits.length > 0 || this.campaign.preconditionsChain().has(this.id)) &&
+            this.requiredMinutes > 0 &&
+            this.extraCurrentMinutes < MAX_EXTRA_MINUTES);
+    }
+    canEarn(now = new Date()) {
+        return (this.baseEarnConditions() &&
+            this.startsAt.getTime() <= now.getTime() &&
+            now.getTime() < this.endsAt.getTime() &&
+            this.campaign.baseCanEarn());
+    }
+    canEarnWithin(stamp) {
+        return (this.baseEarnConditions() &&
+            this.endsAt.getTime() > Date.now() &&
+            this.startsAt.getTime() < stamp.getTime());
+    }
+    get canClaim() {
+        if (!this.claimId || this.claimed) {
+            return false;
+        }
+        const now = new Date();
+        const cutoff = new Date(this.campaign.endsAt.getTime() + 24 * 60 * 60 * 1000);
+        return now.getTime() < cutoff.getTime();
+    }
+    markClaimed() {
+        this.claimed = true;
+        this.realCurrentMinutes = this.requiredMinutes;
+        this.extraCurrentMinutes = 0;
+    }
+    /** Apply a delta to this drop's real minutes only (no campaign-wide propagation). */
+    addRealMinutes(delta) {
+        if (delta === 0)
+            return;
+        let next = this.realCurrentMinutes + delta;
+        if (next < 0)
+            next = 0;
+        if (next > this.requiredMinutes)
+            next = this.requiredMinutes;
+        this.realCurrentMinutes = next;
+        this.extraCurrentMinutes = 0;
+    }
+    updateMinutes(newMinutes) {
+        const delta = newMinutes - this.realCurrentMinutes;
+        if (delta === 0)
+            return;
+        this.addRealMinutes(delta);
+    }
+    bumpMinutes() {
+        if (this.canEarn()) {
+            this.extraCurrentMinutes += 1;
+            if (this.extraCurrentMinutes >= MAX_EXTRA_MINUTES) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+export class DropsCampaign {
+    id;
+    name;
+    gameName;
+    gameSlug;
+    startsAt;
+    endsAt;
+    linked;
+    valid;
+    timedDrops;
+    enableBadgesEmotes;
+    constructor(raw, claimedBenefits, enableBadgesEmotes) {
+        this.id = String(raw.id);
+        this.name = String(raw.name);
+        const game = raw.game || {};
+        this.gameName = String(game.name ?? game.displayName ?? "Unknown Game");
+        this.gameSlug = String(game.slug ?? this.gameName.toLowerCase().replace(/\s+/g, "-"));
+        this.linked = !!(raw.self?.isAccountConnected);
+        this.startsAt = new Date(String(raw.startAt));
+        this.endsAt = new Date(String(raw.endAt));
+        this.valid = raw.status !== "EXPIRED";
+        this.enableBadgesEmotes = enableBadgesEmotes;
+        const drops = raw.timeBasedDrops || [];
+        this.timedDrops = new Map(drops.map((drop) => {
+            const td = new TimedDrop(this, drop, claimedBenefits);
+            return [td.id, td];
+        }));
+    }
+    get drops() {
+        return Array.from(this.timedDrops.values());
+    }
+    get timeTriggers() {
+        const triggers = new Set();
+        triggers.add(this.startsAt.getTime());
+        triggers.add(this.endsAt.getTime());
+        for (const drop of this.drops) {
+            triggers.add(drop.startsAt.getTime());
+            triggers.add(drop.endsAt.getTime());
+        }
+        return Array.from(triggers)
+            .sort((a, b) => a - b)
+            .map((t) => new Date(t));
+    }
+    get active() {
+        const now = new Date();
+        return (this.valid &&
+            this.startsAt.getTime() <= now.getTime() &&
+            now.getTime() < this.endsAt.getTime());
+    }
+    get upcoming() {
+        const now = new Date();
+        return this.valid && now.getTime() < this.startsAt.getTime();
+    }
+    get expired() {
+        const now = new Date();
+        return !this.valid || this.endsAt.getTime() <= now.getTime();
+    }
+    get eligible() {
+        if (this.hasBadgeOrEmote) {
+            return this.enableBadgesEmotes;
+        }
+        return this.linked;
+    }
+    get hasBadgeOrEmote() {
+        return this.drops.some((drop) => drop.benefits.some((b) => b.isBadgeOrEmote()));
+    }
+    get finished() {
+        return this.drops.every((d) => d.isClaimed || d.requiredMinutes <= 0);
+    }
+    get claimedDrops() {
+        return this.drops.filter((d) => d.isClaimed).length;
+    }
+    get remainingDrops() {
+        return this.drops.filter((d) => !d.isClaimed).length;
+    }
+    get requiredMinutes() {
+        return this.drops.reduce((acc, d) => Math.max(acc, d.totalRequiredMinutes), 0);
+    }
+    get remainingMinutes() {
+        return this.drops.reduce((acc, d) => Math.max(acc, d.totalRemainingMinutes), 0);
+    }
+    get progress() {
+        if (!this.drops.length) {
+            return 0;
+        }
+        return this.drops.reduce((acc, d) => acc + d.progress, 0) / this.drops.length;
+    }
+    get availability() {
+        return this.drops.reduce((acc, d) => Math.min(acc, d.availability), Number.POSITIVE_INFINITY);
+    }
+    get firstDrop() {
+        const candidates = this.drops.filter((d) => d.canEarn());
+        if (!candidates.length) {
+            return null;
+        }
+        candidates.sort((a, b) => a.remainingMinutes - b.remainingMinutes);
+        return candidates[0] ?? null;
+    }
+    updateRealMinutes(delta) {
+        if (delta === 0)
+            return;
+        for (const drop of this.drops) {
+            drop.addRealMinutes(delta);
+        }
+    }
+    baseCanEarn() {
+        return this.eligible && this.active;
+    }
+    preconditionsChain() {
+        const chain = new Set();
+        for (const drop of this.drops) {
+            if (!drop.isClaimed) {
+                for (const id of drop.preconditionDropIds) {
+                    chain.add(id);
+                }
+            }
+        }
+        return chain;
+    }
+    canEarnWithin(stamp) {
+        const now = new Date();
+        return (this.eligible &&
+            this.valid &&
+            this.endsAt.getTime() > now.getTime() &&
+            this.startsAt.getTime() < stamp.getTime() &&
+            this.drops.some((d) => d.canEarnWithin(stamp)));
+    }
+}
+export function buildInventoryFromGqlResponses(inventoryResponse, campaignsResponse, ctx) {
+    const inventoryRoot = inventoryResponse.data?.currentUser;
+    const inv = inventoryRoot?.inventory ?? {};
+    const ongoing = inv.dropCampaignsInProgress ?? [];
+    const gameEventDrops = inv.gameEventDrops ?? [];
+    const claimedBenefits = {};
+    for (const b of gameEventDrops) {
+        const id = String(b.id);
+        const lastAwardedAt = b.lastAwardedAt ? new Date(String(b.lastAwardedAt)) : null;
+        if (lastAwardedAt) {
+            claimedBenefits[id] = lastAwardedAt;
+        }
+    }
+    const inventoryData = {};
+    for (const c of ongoing) {
+        inventoryData[String(c.id)] = c;
+    }
+    const campaignsRoot = campaignsResponse.data?.currentUser;
+    const campaignsList = campaignsRoot?.dropCampaigns ?? [];
+    for (const c of campaignsList) {
+        const status = String(c.status ?? "");
+        if (status !== "ACTIVE" && status !== "UPCOMING") {
+            continue;
+        }
+        const id = String(c.id);
+        if (!inventoryData[id]) {
+            inventoryData[id] = c;
+        }
+    }
+    const campaigns = [];
+    const dropsById = new Map();
+    const triggerSet = new Set();
+    for (const data of Object.values(inventoryData)) {
+        const game = data.game ?? undefined;
+        if (!game) {
+            continue;
+        }
+        const campaign = new DropsCampaign(data, claimedBenefits, ctx.enableBadgesEmotes);
+        campaigns.push(campaign);
+        for (const drop of campaign.drops) {
+            dropsById.set(drop.id, drop);
+        }
+        for (const t of campaign.timeTriggers) {
+            triggerSet.add(t.getTime());
+        }
+    }
+    campaigns.sort((a, b) => {
+        if (a.eligible !== b.eligible) {
+            return a.eligible ? -1 : 1;
+        }
+        if (a.upcoming !== b.upcoming) {
+            return a.upcoming ? 1 : -1;
+        }
+        return a.startsAt.getTime() - b.startsAt.getTime();
+    });
+    const timeTriggers = Array.from(triggerSet)
+        .sort((a, b) => a - b)
+        .map((t) => new Date(t));
+    return { campaigns, dropsById, timeTriggers };
+}

package/dist/integrations/gqlClient.js

@@ -0,0 +1,13 @@
+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";
+export async function gqlRequest(operation, accessToken, variables) {
+    return httpJson("POST", TWITCH_GQL_URL, gqlPayload(operation, variables), {
+        retries: 3,
+        headers: {
+            "Client-Id": TWITCH_ANDROID_CLIENT_ID,
+            "User-Agent": TWITCH_ANDROID_USER_AGENT,
+            Authorization: `OAuth ${accessToken}`
+        }
+    });
+}

package/dist/integrations/gqlOperations.js

@@ -0,0 +1,42 @@
+export const GQL_OPERATIONS = {
+    Inventory: {
+        operationName: "Inventory",
+        sha256Hash: "d86775d0ef16a63a33ad52e80eaff963b2d5b72fada7c991504a57496e1d8e4b",
+        variables: { fetchRewardCampaigns: false }
+    },
+    Campaigns: {
+        operationName: "ViewerDropsDashboard",
+        sha256Hash: "5a4da2ab3d5b47c9f9ce864e727b2cb346af1e3ea8b897fe8f704a97ff017619",
+        variables: { fetchRewardCampaigns: false }
+    },
+    CurrentDrop: {
+        operationName: "DropCurrentSessionContext",
+        sha256Hash: "4d06b702d25d652afb9ef835d2a550031f1cf762b193523a92166f40ea3d142b",
+        variables: { channelID: "", channelLogin: "" }
+    },
+    GameDirectory: {
+        operationName: "DirectoryPage_Game",
+        sha256Hash: "76cb069d835b8a02914c08dc42c421d0dafda8af5b113a3f19141824b901402f",
+        variables: { limit: 30, slug: "" }
+    },
+    ClaimDrop: {
+        operationName: "DropsPage_ClaimDropRewards",
+        sha256Hash: "a455deea71bdc9015b78eb49f4acfbce8baa7ccbedd28e549bb025bd0f751930",
+        variables: { input: { dropInstanceID: "" } }
+    }
+};
+export function gqlPayload(operation, variables) {
+    return {
+        operationName: operation.operationName,
+        variables: {
+            ...operation.variables,
+            ...(variables ?? {})
+        },
+        extensions: {
+            persistedQuery: {
+                version: 1,
+                sha256Hash: operation.sha256Hash
+            }
+        }
+    };
+}

package/dist/integrations/httpClient.js

@@ -0,0 +1,37 @@
+import { request } from "undici";
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function httpJson(method, url, body, options) {
+    const retries = options?.retries ?? 3;
+    const retryDelayMs = options?.retryDelayMs ?? 1_000;
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt += 1) {
+        try {
+            const response = await request(url, {
+                method: method,
+                headers: {
+                    "content-type": "application/json",
+                    ...(options?.headers ?? {})
+                },
+                body: body !== undefined ? JSON.stringify(body) : undefined
+            });
+            const text = await response.body.text();
+            if (response.statusCode >= 500) {
+                throw new Error(`HTTP ${response.statusCode}: ${text}`);
+            }
+            if (!text) {
+                return {};
+            }
+            return JSON.parse(text);
+        }
+        catch (err) {
+            lastError = err;
+            if (attempt === retries) {
+                break;
+            }
+            await sleep(retryDelayMs * (attempt + 1));
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error("HTTP request failed.");
+}

package/dist/integrations/twitchPubSub.js

@@ -0,0 +1,126 @@
+import WebSocket from "ws";
+import { PING_INTERVAL_MS, TWITCH_PUBSUB_URL, WS_TOPICS_LIMIT } from "../core/constants.js";
+export class TwitchPubSub {
+    ws = null;
+    pingTimer = null;
+    handlers = new Map();
+    subscribedTopics = new Set();
+    authToken = null;
+    async start() {
+        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());
+        });
+    }
+    async stop() {
+        this.stopPing();
+        this.subscribedTopics.clear();
+        this.authToken = null;
+        const ws = this.ws;
+        this.ws = null;
+        if (!ws) {
+            return;
+        }
+        await new Promise((resolve) => {
+            ws.once("close", () => resolve());
+            ws.close();
+        });
+    }
+    registerTopic(topic, handler) {
+        this.handlers.set(topic, handler);
+    }
+    /** 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)
+            return;
+        const capacity = WS_TOPICS_LIMIT - this.subscribedTopics.size;
+        const batch = toAdd.slice(0, Math.max(0, capacity));
+        if (batch.length === 0)
+            return;
+        for (const t of batch) {
+            this.subscribedTopics.add(t);
+        }
+        this.ws.send(JSON.stringify({
+            type: "LISTEN",
+            data: { topics: batch, auth_token: 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);
+        }
+        this.ws.send(JSON.stringify({
+            type: "UNLISTEN",
+            data: { topics: toRemove, auth_token: authToken }
+        }));
+    }
+    getSubscribedTopics() {
+        return Array.from(this.subscribedTopics);
+    }
+    startPing() {
+        this.stopPing();
+        this.pingTimer = setInterval(() => {
+            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                this.ws.send(JSON.stringify({ type: "PING" }));
+            }
+        }, PING_INTERVAL_MS);
+    }
+    stopPing() {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer);
+            this.pingTimer = null;
+        }
+    }
+    async onMessage(raw) {
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (parsed.type === "PONG") {
+            return;
+        }
+        if (parsed.type === "MESSAGE" && typeof parsed.data === "object" && parsed.data) {
+            const data = parsed.data;
+            const topic = data.topic;
+            const msg = data.message;
+            if (!topic || !msg) {
+                return;
+            }
+            const handler = this.handlers.get(topic);
+            if (!handler) {
+                return;
+            }
+            try {
+                await handler(JSON.parse(msg));
+            }
+            catch {
+                // swallow callback errors to keep listener alive
+            }
+        }
+    }
+}

package/dist/integrations/twitchSpade.js

@@ -0,0 +1,112 @@
+import { request } from "undici";
+import { TWITCH_ANDROID_CLIENT_ID, TWITCH_ANDROID_USER_AGENT } from "../core/constants.js";
+const SPADE_PATTERN = /"(?:beacon|spade)_?url":\s*"(https:\/\/[.\w\-/]+\.ts(?:\?allow_stream=true)?)"/i;
+const SETTINGS_PATTERN = /src="(https:\/\/[\w.]+\/config\/settings\.[0-9a-f]{32}\.js)"/i;
+const DEFAULT_SPADE_BASE = "https://spade.twitch.tv";
+const CHANNEL_PAGE_BASE = "https://www.twitch.tv";
+/**
+ * Build minute-watched payload and return { data: base64(json) } as sent by Twitch web.
+ */
+export function buildSpadePayload(broadcastId, channelId, channelLogin, userId) {
+    const payload = [
+        {
+            event: "minute-watched",
+            properties: {
+                broadcast_id: broadcastId,
+                channel_id: channelId,
+                channel: channelLogin,
+                hidden: false,
+                live: true,
+                location: "channel",
+                logged_in: true,
+                muted: false,
+                player: "site",
+                user_id: userId
+            }
+        }
+    ];
+    const json = JSON.stringify(payload);
+    const data = Buffer.from(json, "utf8").toString("base64");
+    return { data };
+}
+/**
+ * Resolve spade/beacon URL from channel page (or settings JS). Caches nothing; caller may cache.
+ */
+export async function getSpadeUrl(channelLogin, accessToken) {
+    const url = `${CHANNEL_PAGE_BASE}/${channelLogin}`;
+    const res = await request(url, {
+        method: "GET",
+        headers: {
+            "Client-Id": TWITCH_ANDROID_CLIENT_ID,
+            "User-Agent": TWITCH_ANDROID_USER_AGENT,
+            Authorization: `OAuth ${accessToken}`
+        }
+    });
+    const html = await res.body.text();
+    let match = html.match(SPADE_PATTERN);
+    if (match) {
+        return match[1];
+    }
+    match = html.match(SETTINGS_PATTERN);
+    if (!match) {
+        return `${DEFAULT_SPADE_BASE}/`;
+    }
+    const settingsUrl = match[1];
+    const settingsRes = await request(settingsUrl, {
+        method: "GET",
+        headers: {
+            "Client-Id": TWITCH_ANDROID_CLIENT_ID,
+            "User-Agent": TWITCH_ANDROID_USER_AGENT,
+            Authorization: `OAuth ${accessToken}`
+        }
+    });
+    const js = await settingsRes.body.text();
+    const spadeMatch = js.match(SPADE_PATTERN);
+    if (!spadeMatch) {
+        return `${DEFAULT_SPADE_BASE}/`;
+    }
+    return spadeMatch[1];
+}
+/**
+ * POST spade payload to the given URL. Body is application/x-www-form-urlencoded with key "data".
+ * Returns true on 204, false otherwise.
+ */
+export async function sendSpadePost(spadeUrl, payload, accessToken) {
+    const body = new URLSearchParams({ data: payload.data }).toString();
+    const res = await request(spadeUrl, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Client-Id": TWITCH_ANDROID_CLIENT_ID,
+            "User-Agent": TWITCH_ANDROID_USER_AGENT,
+            Authorization: `OAuth ${accessToken}`
+        },
+        body
+    });
+    return res.statusCode === 204;
+}
+/**
+ * Send a single "minute-watched" beacon for the channel. Resolves spade URL (use cache to avoid repeated fetches)
+ * and POSTs. Returns true on success (204).
+ */
+export async function sendChannelWatch(channel, userId, accessToken, options) {
+    const broadcastId = channel.streamId ?? channel.id;
+    const payload = buildSpadePayload(broadcastId, channel.id, channel.login, userId);
+    const cache = options?.spadeUrlCache;
+    let url = cache?.get(channel.login);
+    if (!url) {
+        try {
+            url = await getSpadeUrl(channel.login, accessToken);
+            cache?.set(channel.login, url);
+        }
+        catch {
+            url = `${DEFAULT_SPADE_BASE}/`;
+        }
+    }
+    try {
+        return await sendSpadePost(url, payload, accessToken);
+    }
+    catch {
+        return false;
+    }
+}