twitchdropsminer-cli 0.1.0

package/dist/cli/commands/healthcheck.js

@@ -0,0 +1,25 @@
+import { Command } from "@commander-js/extra-typings";
+import { loadAuthState } from "../../state/authStore.js";
+import { EXIT_AUTH_MISSING, EXIT_OK } from "../contracts/exitCodes.js";
+export const healthcheckCommand = new Command("healthcheck")
+    .description("Return a simple machine-readable health status for monitoring")
+    .option("--json", "Output health as JSON", false)
+    .action(async (opts) => {
+    const auth = loadAuthState();
+    const healthy = !!auth && (!!auth.accessToken || !!auth.cookiesHeader);
+    if (opts.json) {
+        // eslint-disable-next-line no-console
+        console.log(JSON.stringify({
+            status: healthy ? "ok" : "degraded",
+            auth: {
+                hasToken: !!auth?.accessToken,
+                hasCookies: !!auth?.cookiesHeader
+            }
+        }, null, 2));
+    }
+    else {
+        // eslint-disable-next-line no-console
+        console.log(healthy ? "OK" : "DEGRADED");
+    }
+    process.exitCode = healthy ? EXIT_OK : EXIT_AUTH_MISSING;
+});

package/dist/cli/commands/logs.js

@@ -0,0 +1,14 @@
+import { Command } from "@commander-js/extra-typings";
+import { spawn } from "node:child_process";
+export const logsCommand = new Command("logs")
+    .description("Follow service logs via journalctl")
+    .option("--name <name>", "Service unit name", "tdm.service")
+    .option("--user", "Use user journal", true)
+    .option("--follow", "Follow logs", true)
+    .action(async (opts) => {
+    const args = [...(opts.user ? ["--user"] : []), "-u", opts.name, ...(opts.follow ? ["-f"] : [])];
+    await new Promise((resolve) => {
+        const proc = spawn("journalctl", args, { stdio: "inherit" });
+        proc.on("close", () => resolve());
+    });
+});

package/dist/cli/commands/run.js

@@ -0,0 +1,20 @@
+import { Command } from "@commander-js/extra-typings";
+import { Miner } from "../../core/miner.js";
+import { logger } from "../../core/runtime.js";
+export const runCommand = new Command("run")
+    .description("Run the Twitch drops miner")
+    .option("-v, --verbose", "Enable verbose logging")
+    .option("--dry-run", "Log intended actions only; no spade POST or claim GQL")
+    .action(async (opts) => {
+    if (opts.verbose) {
+        process.env.TDM_LOG_LEVEL = "debug";
+    }
+    const miner = new Miner();
+    if (opts.verbose) {
+        logger.info("Starting TwitchDropsMiner CLI in verbose mode.");
+    }
+    if (opts.dryRun) {
+        logger.info("Dry-run mode: no spade or claim network writes.");
+    }
+    await miner.run({ dryRun: opts.dryRun ?? false });
+});

package/dist/cli/commands/service.js

@@ -0,0 +1,85 @@
+import { Command } from "@commander-js/extra-typings";
+import { writeUnitFile, systemctl } from "../../ops/systemd.js";
+import { EXIT_OK, EXIT_SERVICE_ERROR } from "../contracts/exitCodes.js";
+export const serviceCommand = new Command("service")
+    .description("Manage TwitchDropsMiner CLI as a systemd service")
+    .option("--user", "Use user-level systemd unit (recommended)", true)
+    .option("--system", "Use system-level systemd unit (requires root)", false);
+serviceCommand
+    .command("install")
+    .description("Install the systemd unit")
+    .option("--name <name>", "Service unit name", "tdm.service")
+    .option("--autostart", "Enable service at boot", true)
+    .action(async (opts, cmd) => {
+    const parent = cmd.parent;
+    const userUnit = parent.getOptionValue("user") && !parent.getOptionValue("system");
+    const unitPath = writeUnitFile({
+        userUnit,
+        autostart: opts.autostart,
+        serviceName: opts.name
+    });
+    // eslint-disable-next-line no-console
+    console.log(`Installed unit at: ${unitPath}`);
+    if (opts.autostart) {
+        const code = await systemctl(["enable", opts.name], userUnit);
+        if (code !== 0) {
+            process.exitCode = EXIT_SERVICE_ERROR;
+            return;
+        }
+    }
+    process.exitCode = EXIT_OK;
+});
+serviceCommand
+    .command("start")
+    .description("Start the service")
+    .option("--name <name>", "Service unit name", "tdm.service")
+    .action(async (opts, cmd) => {
+    const parent = cmd.parent;
+    const userUnit = parent.getOptionValue("user") && !parent.getOptionValue("system");
+    const code = await systemctl(["start", opts.name], userUnit);
+    process.exitCode = code === 0 ? EXIT_OK : EXIT_SERVICE_ERROR;
+});
+serviceCommand
+    .command("stop")
+    .description("Stop the service")
+    .option("--name <name>", "Service unit name", "tdm.service")
+    .action(async (opts, cmd) => {
+    const parent = cmd.parent;
+    const userUnit = parent.getOptionValue("user") && !parent.getOptionValue("system");
+    const code = await systemctl(["stop", opts.name], userUnit);
+    process.exitCode = code === 0 ? EXIT_OK : EXIT_SERVICE_ERROR;
+});
+serviceCommand
+    .command("restart")
+    .description("Restart the service")
+    .option("--name <name>", "Service unit name", "tdm.service")
+    .action(async (opts, cmd) => {
+    const parent = cmd.parent;
+    const userUnit = parent.getOptionValue("user") && !parent.getOptionValue("system");
+    const code = await systemctl(["restart", opts.name], userUnit);
+    process.exitCode = code === 0 ? EXIT_OK : EXIT_SERVICE_ERROR;
+});
+serviceCommand
+    .command("status")
+    .description("Show service status")
+    .option("--name <name>", "Service unit name", "tdm.service")
+    .action(async (opts, cmd) => {
+    const parent = cmd.parent;
+    const userUnit = parent.getOptionValue("user") && !parent.getOptionValue("system");
+    const code = await systemctl(["status", opts.name], userUnit);
+    process.exitCode = code === 0 ? EXIT_OK : EXIT_SERVICE_ERROR;
+});
+serviceCommand
+    .command("uninstall")
+    .description("Disable and remove the systemd unit")
+    .option("--name <name>", "Service unit name", "tdm.service")
+    .action(async (opts, cmd) => {
+    const parent = cmd.parent;
+    const userUnit = parent.getOptionValue("user") && !parent.getOptionValue("system");
+    // Best-effort disable; ignore errors.
+    await systemctl(["disable", opts.name], userUnit);
+    // Unit file removal is left to the user to avoid accidental deletions outside home.
+    // eslint-disable-next-line no-console
+    console.log("Service disabled. To fully remove the unit file, delete it from your systemd directory.");
+    process.exitCode = EXIT_OK;
+});

package/dist/cli/commands/status.js

@@ -0,0 +1,29 @@
+import { Command } from "@commander-js/extra-typings";
+import { loadSessionState } from "../../state/sessionState.js";
+export const statusCommand = new Command("status")
+    .description("Show current miner status")
+    .option("--json", "Output status as JSON")
+    .action(async (opts) => {
+    const session = loadSessionState();
+    const rawState = session?.state ?? "UNKNOWN";
+    const highLevel = rawState === "IDLE" && session?.watchedChannelName
+        ? "WATCHING"
+        : rawState !== "IDLE" && rawState !== "EXIT"
+            ? "MAINTENANCE"
+            : rawState;
+    const status = {
+        running: rawState !== "EXIT",
+        state: highLevel,
+        rawState,
+        watchedChannel: session?.watchedChannelName ?? null,
+        activeDrop: session?.activeDropId ?? null
+    };
+    if (opts.json) {
+        // eslint-disable-next-line no-console
+        console.log(JSON.stringify(status));
+    }
+    else {
+        // eslint-disable-next-line no-console
+        console.log(`State=${status.state}, channel=${status.watchedChannel ?? "-"}, activeDrop=${status.activeDrop ?? "-"}`);
+    }
+});

package/dist/cli/contracts/exitCodes.js

@@ -0,0 +1,7 @@
+export const EXIT_OK = 0;
+export const EXIT_GENERIC_ERROR = 1;
+export const EXIT_CONFIG_ERROR = 2;
+export const EXIT_AUTH_MISSING = 3;
+export const EXIT_AUTH_INVALID = 4;
+export const EXIT_ENV_UNSUPPORTED = 5;
+export const EXIT_SERVICE_ERROR = 6;

package/dist/cli/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { Command } from "@commander-js/extra-typings";
+import { runCommand } from "./commands/run.js";
+import { authCommand } from "./commands/auth.js";
+import { statusCommand } from "./commands/status.js";
+import { configCommand } from "./commands/config.js";
+import { gamesCommand } from "./commands/games.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { healthcheckCommand } from "./commands/healthcheck.js";
+import { serviceCommand } from "./commands/service.js";
+import { logsCommand } from "./commands/logs.js";
+import { ensureSingleInstanceLock } from "../core/runtime.js";
+const program = new Command();
+program
+    .name("tdm")
+    .description("Twitch Drops Miner CLI (headless)")
+    .version("0.1.0");
+program.hook("preAction", (_thisCommand, actionCommand) => {
+    if (actionCommand.name() === "run") {
+        ensureSingleInstanceLock();
+    }
+});
+program.addCommand(runCommand);
+program.addCommand(authCommand);
+program.addCommand(statusCommand);
+program.addCommand(configCommand);
+program.addCommand(gamesCommand);
+program.addCommand(doctorCommand);
+program.addCommand(healthcheckCommand);
+program.addCommand(serviceCommand);
+program.addCommand(logsCommand);
+program.parseAsync().catch((err) => {
+    // eslint-disable-next-line no-console
+    console.error("Fatal error:", err);
+    process.exitCode = 1;
+});

package/dist/config/schema.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export const PriorityModeSchema = z.enum(["priority_only", "ending_soonest", "low_avbl_first"]);
+export const ConfigSchema = z.object({
+    proxy: z.string().default(""),
+    language: z.string().default("English"),
+    darkMode: z.boolean().default(false),
+    exclude: z.array(z.string()).default([]),
+    priority: z.array(z.string()).default([]),
+    autostartTray: z.boolean().default(false),
+    connectionQuality: z.number().int().min(1).max(6).default(1),
+    trayNotifications: z.boolean().default(true),
+    enableBadgesEmotes: z.boolean().default(false),
+    availableDropsCheck: z.boolean().default(false),
+    priorityMode: PriorityModeSchema.default("priority_only")
+});
+export const DEFAULT_CONFIG = ConfigSchema.parse({});

package/dist/config/store.js

@@ -0,0 +1,29 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { ConfigSchema, DEFAULT_CONFIG } from "./schema.js";
+function configDir() {
+    const dir = path.join(os.homedir(), ".config", "tdm");
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    return dir;
+}
+export function configPath() {
+    return path.join(configDir(), "config.json");
+}
+export function loadConfig() {
+    const p = configPath();
+    if (!fs.existsSync(p)) {
+        return DEFAULT_CONFIG;
+    }
+    try {
+        const raw = fs.readFileSync(p, "utf8");
+        return ConfigSchema.parse(JSON.parse(raw));
+    }
+    catch {
+        return DEFAULT_CONFIG;
+    }
+}
+export function saveConfig(config) {
+    const p = configPath();
+    fs.writeFileSync(p, JSON.stringify(ConfigSchema.parse(config), null, 2), { mode: 0o600 });
+}

package/dist/core/channelService.js

@@ -0,0 +1,105 @@
+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";
+export const MAX_CHANNELS = 100;
+/**
+ * Parse Twitch GQL DirectoryPage_Game response into Channel list.
+ * Expects structure: data.game.streams.edges[].node with broadcaster(s), viewersCount, game.
+ */
+export function parseGameDirectoryResponse(response, gameName, aclBased) {
+    const data = response?.data;
+    const game = data?.game;
+    const streams = game?.streams;
+    const edges = streams?.edges ?? [];
+    const channels = [];
+    for (const edge of edges) {
+        const node = edge?.node;
+        if (!node)
+            continue;
+        let broadcasters = Array.isArray(node.broadcasters) ? node.broadcasters : [];
+        if (broadcasters.length === 0 && node.broadcaster != null) {
+            broadcasters = [node.broadcaster];
+        }
+        const broadcaster = broadcasters[0];
+        if (!broadcaster)
+            continue;
+        const id = String(broadcaster.id ?? broadcaster.login ?? "");
+        const login = String(broadcaster.login ?? broadcaster.displayName ?? id);
+        if (!id || !login)
+            continue;
+        const viewers = Number(node.viewersCount ?? node.viewerCount ?? 0);
+        const gameNode = node.game;
+        const displayGame = gameNode
+            ? String(gameNode.displayName ?? gameNode.name ?? gameName)
+            : gameName;
+        const streamId = node.id != null ? String(node.id) : undefined;
+        channels.push({
+            id,
+            login,
+            online: true,
+            viewers: Number.isFinite(viewers) ? viewers : 0,
+            gameName: displayGame,
+            dropsEnabled: node.isDropsEnabled === false ? false : true,
+            aclBased,
+            streamId
+        });
+    }
+    return channels;
+}
+/**
+ * Build ACL-based channel IDs from campaigns (campaign allowlist / tags if present in GQL).
+ * For now campaigns do not expose channel allowlist in our GQL shape; return empty set.
+ */
+export function getAclChannelIdsFromCampaigns(_campaigns) {
+    const ids = new Set();
+    // 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).
+ */
+function gameNameToSlug(gameName, campaigns) {
+    const c = campaigns.find((camp) => camp.gameName === gameName);
+    return c ? c.gameSlug : gameName.toLowerCase().replace(/\s+/g, "-");
+}
+export async function fetchChannelsForWantedGames(token, options) {
+    const { wantedGames, campaigns, maxChannels = MAX_CHANNELS } = options;
+    const aclIds = getAclChannelIdsFromCampaigns(campaigns);
+    const byId = new Map();
+    for (const gameName of wantedGames) {
+        const slug = gameNameToSlug(gameName, campaigns);
+        const response = await gqlRequest(GQL_OPERATIONS.GameDirectory, token, {
+            slug,
+            limit: 30,
+            sortTypeIsRecency: false,
+            includeCostreaming: false
+        });
+        const resp = response;
+        const gqlErrors = resp?.errors;
+        if (gqlErrors?.length) {
+            logger.warn({ gameName, slug, gqlErrors }, "GameDirectory GQL errors");
+        }
+        const aclBased = false;
+        const list = parseGameDirectoryResponse(response, gameName, aclBased);
+        for (const ch of list) {
+            const existing = byId.get(ch.id);
+            const acl = aclIds.has(ch.id);
+            const merged = {
+                ...ch,
+                aclBased: existing?.aclBased ?? acl
+            };
+            if (!existing || merged.viewers > existing.viewers) {
+                byId.set(ch.id, merged);
+            }
+        }
+    }
+    let result = Array.from(byId.values());
+    result = result.filter((ch) => canWatchChannel(ch, wantedGames));
+    result = sortChannelCandidates(result, wantedGames);
+    return result.slice(0, maxChannels);
+}

package/dist/core/constants.js

@@ -0,0 +1,12 @@
+export const TWITCH_OAUTH_DEVICE_URL = "https://id.twitch.tv/oauth2/device";
+export const TWITCH_OAUTH_TOKEN_URL = "https://id.twitch.tv/oauth2/token";
+export const TWITCH_OAUTH_VALIDATE_URL = "https://id.twitch.tv/oauth2/validate";
+export const TWITCH_GQL_URL = "https://gql.twitch.tv/gql";
+export const TWITCH_PUBSUB_URL = "wss://pubsub-edge.twitch.tv/v1";
+export const WATCH_INTERVAL_MS = 59_000;
+export const PING_INTERVAL_MS = 180_000;
+export const PING_TIMEOUT_MS = 10_000;
+export const MAX_WEBSOCKETS = 8;
+export const WS_TOPICS_LIMIT = 50;
+export const TWITCH_ANDROID_CLIENT_ID = "kd1unb4b3q4t58fwlpcbzcbnm76a8fp";
+export const TWITCH_ANDROID_USER_AGENT = "Dalvik/2.1.0 (Linux; Android 16; SM-S911B Build/TP1A.220624.014) tv.twitch.android.app/25.3.0/2503006";

package/dist/core/maintenance.js

@@ -0,0 +1,15 @@
+export class MaintenanceScheduler {
+    timer = null;
+    start(intervalMs, callback) {
+        this.stop();
+        this.timer = setInterval(() => {
+            void callback();
+        }, intervalMs);
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+}