claude-code-discord-presence 1.0.0

package/dist/claude/monthly-usage.js

@@ -0,0 +1,279 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { createLogger } from "../util/logger.js";
+import { costForUsageByModel } from "./cost.js";
+const log = createLogger("claude-monthly");
+const DEFAULT_POLL_MS = 60_000;
+function object(value) {
+    return value && typeof value === "object" ? value : undefined;
+}
+function count(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+function timestamp(value) {
+    if (typeof value === "string" && Number.isFinite(Date.parse(value)))
+        return value;
+    return undefined;
+}
+function usageTotal(usage) {
+    return usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+function parseLine(line) {
+    if (line.charCodeAt(0) !== 123 || !line.includes('"usage"'))
+        return undefined;
+    let record;
+    try {
+        record = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    const wrapped = object(object(record.data)?.message);
+    const entry = wrapped && object(wrapped.message) ? wrapped : record;
+    const message = object(entry.message);
+    const raw = object(message?.usage);
+    const at = timestamp(entry.timestamp);
+    const model = message?.model;
+    if (!message || !raw || !at || typeof model !== "string" || model.trim() === "") {
+        return undefined;
+    }
+    const cacheCreation = object(raw.cache_creation);
+    const oneHour = count(cacheCreation?.ephemeral_1h_input_tokens);
+    const fiveMinute = count(cacheCreation?.ephemeral_5m_input_tokens);
+    const usage = {
+        input: count(raw.input_tokens),
+        output: count(raw.output_tokens),
+        cacheRead: count(raw.cache_read_input_tokens),
+        cacheWrite: cacheCreation ? oneHour + fiveMinute : count(raw.cache_creation_input_tokens),
+    };
+    if (oneHour > 0)
+        usage.cacheWriteOneHour = Math.min(usage.cacheWrite, oneHour);
+    if (usageTotal(usage) === 0)
+        return undefined;
+    return {
+        timestamp: at,
+        model: raw.speed === "fast" ? `${model}-fast` : model,
+        messageId: typeof message.id === "string" && message.id !== "" ? message.id : undefined,
+        requestId: typeof entry.requestId === "string" && entry.requestId !== "" ? entry.requestId : undefined,
+        sidechain: entry.isSidechain === true,
+        usage,
+    };
+}
+async function collectJsonl(dir) {
+    const files = [];
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return files;
+    }
+    for (const entry of entries) {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory())
+            files.push(...(await collectJsonl(path)));
+        else if (entry.isFile() && entry.name.endsWith(".jsonl"))
+            files.push(path);
+    }
+    return files;
+}
+function expandHome(path) {
+    if (path === "~")
+        return homedir();
+    if (path.startsWith("~/") || path.startsWith("~\\"))
+        return join(homedir(), path.slice(2));
+    return path;
+}
+export function claudeConfigDirs(env = process.env) {
+    const configured = env.CLAUDE_CONFIG_DIR?.trim();
+    if (configured) {
+        return configured
+            .split(",")
+            .map((path) => expandHome(path.trim()))
+            .filter((path) => path !== "")
+            .map((path) => (basename(path).toLowerCase() === "projects" ? dirname(path) : path));
+    }
+    const xdg = env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
+    return [join(xdg, "claude"), join(homedir(), ".claude")];
+}
+function dedupe(events) {
+    const deduped = [];
+    const exact = new Map();
+    const byMessage = new Map();
+    const anonymous = [];
+    for (const event of events) {
+        if (!event.messageId) {
+            anonymous.push(event);
+            continue;
+        }
+        const exactKey = `${event.messageId}\u0000${event.requestId ?? ""}`;
+        let index = exact.get(exactKey);
+        if (index !== undefined && deduped[index]?.requestId !== event.requestId)
+            index = undefined;
+        if (index === undefined) {
+            index = byMessage.get(event.messageId)?.find((candidate) => event.sidechain || deduped[candidate]?.sidechain === true);
+        }
+        if (index === undefined) {
+            const next = deduped.length;
+            deduped.push(event);
+            exact.set(exactKey, next);
+            const indexes = byMessage.get(event.messageId) ?? [];
+            indexes.push(next);
+            byMessage.set(event.messageId, indexes);
+            continue;
+        }
+        const existing = deduped[index];
+        const nextTotal = usageTotal(event.usage);
+        const currentTotal = usageTotal(existing.usage);
+        if ((existing.sidechain !== event.sidechain && !event.sidechain) ||
+            (existing.sidechain === event.sidechain && nextTotal > currentTotal) ||
+            (existing.sidechain === event.sidechain &&
+                nextTotal === currentTotal &&
+                event.requestId !== undefined &&
+                existing.requestId === undefined)) {
+            deduped[index] = event;
+            exact.set(exactKey, index);
+        }
+    }
+    return [...deduped, ...anonymous];
+}
+export class ClaudeUsageFileCache {
+    entries = new Map();
+}
+function parseTranscript(text) {
+    const events = [];
+    for (const line of text.split(/\r?\n/)) {
+        const event = parseLine(line);
+        if (event)
+            events.push(event);
+    }
+    return events;
+}
+export async function readClaudeMonthlyUsageRaw(configDirs = claudeConfigDirs(), now = new Date(), cache) {
+    const events = [];
+    const liveFiles = new Set();
+    for (const configDir of configDirs) {
+        for (const file of await collectJsonl(join(configDir, "projects"))) {
+            liveFiles.add(file);
+            try {
+                let fileEvents;
+                if (cache) {
+                    const info = await stat(file);
+                    const entry = cache.entries.get(file);
+                    if (entry && entry.size === info.size && entry.mtimeMs === info.mtimeMs) {
+                        fileEvents = entry.events;
+                    }
+                    else {
+                        fileEvents = parseTranscript(await readFile(file, "utf8"));
+                        cache.entries.set(file, { size: info.size, mtimeMs: info.mtimeMs, events: fileEvents });
+                    }
+                }
+                else {
+                    fileEvents = parseTranscript(await readFile(file, "utf8"));
+                }
+                for (const event of fileEvents)
+                    events.push(event);
+            }
+            catch {
+                // A transcript can be rotated while the scan is running; the next poll retries it.
+            }
+        }
+    }
+    if (cache) {
+        for (const key of cache.entries.keys()) {
+            if (!liveFiles.has(key))
+                cache.entries.delete(key);
+        }
+    }
+    const unique = dedupe(events);
+    const aggregate = (selected) => {
+        const usageByModel = {};
+        let totalTokens = 0;
+        for (const event of selected) {
+            const bucket = (usageByModel[event.model] ??= { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+            bucket.input += event.usage.input;
+            bucket.output += event.usage.output;
+            bucket.cacheRead += event.usage.cacheRead;
+            bucket.cacheWrite += event.usage.cacheWrite;
+            if (event.usage.cacheWriteOneHour) {
+                bucket.cacheWriteOneHour = (bucket.cacheWriteOneHour ?? 0) + event.usage.cacheWriteOneHour;
+            }
+            totalTokens += usageTotal(event.usage);
+        }
+        return { totalTokens, usageByModel };
+    };
+    const startDay = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+    const startWeek = startDay - 6 * 24 * 60 * 60 * 1000;
+    const startMonth = new Date(now.getFullYear(), now.getMonth(), 1).getTime();
+    const beforeTomorrow = startDay + 24 * 60 * 60 * 1000;
+    const within = (start) => unique.filter((event) => {
+        const at = Date.parse(event.timestamp);
+        return at >= start && at < beforeTomorrow;
+    });
+    return {
+        ...aggregate(within(startMonth)),
+        day: aggregate(within(startDay)),
+        week: aggregate(within(startWeek)),
+        allTime: aggregate(unique),
+    };
+}
+export function claudeMonthlyUsage(raw) {
+    const summary = (period) => ({
+        totalTokens: period.totalTokens,
+        costUsd: costForUsageByModel(period.usageByModel).total,
+    });
+    return {
+        ...summary(raw),
+        ...(raw.day ? { day: summary(raw.day) } : {}),
+        ...(raw.week ? { week: summary(raw.week) } : {}),
+        ...(raw.allTime ? { allTime: summary(raw.allTime) } : {}),
+    };
+}
+function same(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+export class ClaudeMonthlyUsageWatcher {
+    onUpdate;
+    intervalMs;
+    timer;
+    polling = false;
+    stopped = false;
+    last;
+    cache = new ClaudeUsageFileCache();
+    constructor(onUpdate, intervalMs = DEFAULT_POLL_MS) {
+        this.onUpdate = onUpdate;
+        this.intervalMs = intervalMs;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.stopped = false;
+        void this.poll();
+        this.timer = setInterval(() => void this.poll(), this.intervalMs);
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = undefined;
+    }
+    async poll() {
+        if (this.stopped || this.polling)
+            return;
+        this.polling = true;
+        try {
+            const usage = claudeMonthlyUsage(await readClaudeMonthlyUsageRaw(undefined, undefined, this.cache));
+            if (!same(this.last, usage)) {
+                this.last = usage;
+                this.onUpdate(usage);
+            }
+        }
+        catch (error) {
+            log.warn(`monthly usage scan failed: ${error.message}`);
+        }
+        finally {
+            this.polling = false;
+        }
+    }
+}

package/dist/claude/oauth-discovery.js

@@ -0,0 +1,82 @@
+import { execFile } from "node:child_process";
+import { open } from "node:fs/promises";
+import { promisify } from "node:util";
+import { createLogger } from "../util/logger.js";
+const execFileAsync = promisify(execFile);
+const log = createLogger("oauth-discovery");
+export const FALLBACK_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+export const FALLBACK_TOKEN_URLS = [
+    "https://platform.claude.com/v1/oauth/token",
+    "https://console.anthropic.com/v1/oauth/token",
+];
+const CLIENT_RE = /MANUAL_REDIRECT_URL:"https:\/\/[a-z0-9.\-]+\/oauth\/code\/callback",CLIENT_ID:"([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})"/g;
+const TOKEN_URL_RE = /https:\/\/[a-z0-9.\-]+\/v1\/oauth\/token/g;
+const CHUNK_BYTES = 8 * 1024 * 1024;
+const OVERLAP_BYTES = 1024;
+function ownHost(url) {
+    return url.includes("claude.com") || url.includes("anthropic.com");
+}
+function push(list, value) {
+    if (!list.includes(value))
+        list.push(value);
+}
+async function findClaudeExecutable() {
+    try {
+        const command = process.platform === "win32" ? "where.exe" : "which";
+        const { stdout } = await execFileAsync(command, ["claude"], {
+            encoding: "utf8",
+            windowsHide: true,
+            timeout: 10_000,
+        });
+        return stdout.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function discoverOauthConfig() {
+    const clientIds = [];
+    const tokenUrls = [];
+    const envId = process.env.CLAUDE_CODE_OAUTH_CLIENT_ID?.trim();
+    if (envId)
+        push(clientIds, envId);
+    let discovered;
+    let handle;
+    try {
+        const executable = await findClaudeExecutable();
+        if (executable) {
+            handle = await open(executable, "r");
+            const size = (await handle.stat()).size;
+            const decoder = new TextDecoder();
+            let carry = "";
+            for (let offset = 0; offset < size; offset += CHUNK_BYTES) {
+                const buffer = Buffer.allocUnsafe(Math.min(CHUNK_BYTES, size - offset));
+                const { bytesRead } = await handle.read(buffer, 0, buffer.length, offset);
+                const text = carry + decoder.decode(buffer.subarray(0, bytesRead));
+                for (const match of text.matchAll(CLIENT_RE)) {
+                    discovered ??= match[1];
+                    push(clientIds, match[1]);
+                }
+                for (const match of text.matchAll(TOKEN_URL_RE)) {
+                    if (ownHost(match[0]))
+                        push(tokenUrls, match[0]);
+                }
+                carry = text.slice(-OVERLAP_BYTES);
+            }
+        }
+        else {
+            log.debug("claude executable not found; using fallback oauth config");
+        }
+    }
+    catch (err) {
+        log.debug(`oauth discovery failed: ${err.message}; using fallback`);
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+    push(clientIds, FALLBACK_CLIENT_ID);
+    for (const url of FALLBACK_TOKEN_URLS)
+        push(tokenUrls, url);
+    log.debug(`oauth config source=${discovered ? "claude binary" : "fallback"}`);
+    return { clientIds, tokenUrls };
+}

package/dist/claude/paths.js

@@ -0,0 +1,13 @@
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+export function claudeConfigDir(env = process.env) {
+    const configured = env.CLAUDE_CONFIG_DIR?.split(",")[0]?.trim();
+    if (!configured)
+        return resolve(homedir(), ".claude");
+    if (configured === "~")
+        return homedir();
+    if (configured.startsWith("~/") || configured.startsWith("~\\")) {
+        return resolve(homedir(), configured.slice(2));
+    }
+    return resolve(configured);
+}

package/dist/claude/plan-info.js

@@ -0,0 +1,102 @@
+import { join } from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+import { createLogger } from "../util/logger.js";
+import { claudeConfigDir } from "./paths.js";
+const log = createLogger("plan-info");
+const CLAUDE_DIR = claudeConfigDir();
+export const CREDENTIALS_PATH = join(CLAUDE_DIR, ".credentials.json");
+const SETTINGS_PATH = join(CLAUDE_DIR, "settings.json");
+const CACHE_TTL_MS = 60 * 60 * 1000;
+const EFFORT_LEVELS = new Set(["low", "medium", "high", "xhigh", "max"]);
+export async function getDefaultEffort() {
+    try {
+        const raw = await readFile(SETTINGS_PATH, "utf8");
+        const level = JSON.parse(raw).effortLevel;
+        return typeof level === "string" && EFFORT_LEVELS.has(level) ? level : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function planNameFrom(subscriptionType, rateLimitTier) {
+    const sub = (subscriptionType ?? "").toLowerCase();
+    const tier = (rateLimitTier ?? "").toLowerCase();
+    if (sub === "pro")
+        return "Pro";
+    if (sub === "max") {
+        if (tier.includes("20x"))
+            return "Max 20X";
+        if (tier.includes("5x"))
+            return "Max 5X";
+        return "Max";
+    }
+    if (sub === "team" || sub === "enterprise")
+        return sub.charAt(0).toUpperCase() + sub.slice(1);
+    return "Claude";
+}
+async function readCredentials() {
+    for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+            const raw = await readFile(CREDENTIALS_PATH, "utf8");
+            return JSON.parse(raw);
+        }
+        catch (err) {
+            if (attempt === 2) {
+                const error = err;
+                const message = `could not read credentials: ${error.message}`;
+                if (error.code === "ENOENT")
+                    log.debug(message);
+                else
+                    log.warn(message);
+                return undefined;
+            }
+            await new Promise((r) => setTimeout(r, 50));
+        }
+    }
+    return undefined;
+}
+export async function readAccessToken() {
+    const creds = await readCredentials();
+    return creds?.claudeAiOauth?.accessToken;
+}
+export async function readOauthCredentials() {
+    const oauth = (await readCredentials())?.claudeAiOauth;
+    return {
+        accessToken: oauth?.accessToken,
+        refreshToken: oauth?.refreshToken,
+        expiresAt: typeof oauth?.expiresAt === "number" ? oauth.expiresAt : undefined,
+    };
+}
+export async function saveRefreshedCredentials(accessToken, refreshToken, expiresInS) {
+    try {
+        const raw = await readFile(CREDENTIALS_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        const oauth = parsed.claudeAiOauth && typeof parsed.claudeAiOauth === "object"
+            ? parsed.claudeAiOauth
+            : {};
+        oauth.accessToken = accessToken;
+        if (refreshToken)
+            oauth.refreshToken = refreshToken;
+        if (typeof expiresInS === "number" && Number.isFinite(expiresInS) && expiresInS > 0) {
+            oauth.expiresAt = Date.now() + Math.round(expiresInS * 1000);
+        }
+        parsed.claudeAiOauth = oauth;
+        await writeFile(CREDENTIALS_PATH, JSON.stringify(parsed), "utf8");
+        return true;
+    }
+    catch (err) {
+        log.warn(`could not save refreshed credentials: ${err.message}`);
+        return false;
+    }
+}
+let cached;
+export async function getPlanName() {
+    const now = Date.now();
+    if (cached && now - cached.at < CACHE_TTL_MS)
+        return cached.name;
+    const creds = await readCredentials();
+    const oauth = creds?.claudeAiOauth;
+    const name = planNameFrom(oauth?.subscriptionType, oauth?.rateLimitTier);
+    cached = { name, at: now };
+    return name;
+}