claude-code-discord-presence 1.0.0

package/dist/claude/default-selection.js

@@ -0,0 +1,268 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { claudeConfigDir } from "./paths.js";
+const EFFORT_LEVELS = new Set([
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+    "ultra",
+]);
+function readVarint(data, offset, limit = data.length) {
+    let value = 0;
+    let shift = 0;
+    for (let i = offset; i < limit && shift <= 49; i += 1) {
+        const byte = data[i];
+        value += (byte & 0x7f) * 2 ** shift;
+        if ((byte & 0x80) === 0)
+            return { value, next: i + 1 };
+        shift += 7;
+    }
+    return undefined;
+}
+function decodeSnappy(data) {
+    const expected = readVarint(data, 0);
+    if (!expected || expected.value > 64 * 1024 * 1024)
+        return undefined;
+    const output = new Uint8Array(expected.value);
+    let inputAt = expected.next;
+    let outputAt = 0;
+    while (inputAt < data.length && outputAt < output.length) {
+        const tag = data[inputAt++];
+        const type = tag & 3;
+        if (type === 0) {
+            let length = tag >>> 2;
+            if (length < 60) {
+                length += 1;
+            }
+            else {
+                const bytes = length - 59;
+                length = 0;
+                if (inputAt + bytes > data.length)
+                    return undefined;
+                for (let i = 0; i < bytes; i += 1)
+                    length += data[inputAt++] * 2 ** (8 * i);
+                length += 1;
+            }
+            if (inputAt + length > data.length || outputAt + length > output.length)
+                return undefined;
+            output.set(data.subarray(inputAt, inputAt + length), outputAt);
+            inputAt += length;
+            outputAt += length;
+            continue;
+        }
+        const length = type === 1 ? 4 + ((tag >>> 2) & 7) : 1 + (tag >>> 2);
+        let distance;
+        if (type === 1) {
+            if (inputAt >= data.length)
+                return undefined;
+            distance = ((tag & 0xe0) << 3) | data[inputAt++];
+        }
+        else if (type === 2) {
+            if (inputAt + 2 > data.length)
+                return undefined;
+            distance = data[inputAt] | (data[inputAt + 1] << 8);
+            inputAt += 2;
+        }
+        else {
+            if (inputAt + 4 > data.length)
+                return undefined;
+            distance =
+                (data[inputAt] |
+                    (data[inputAt + 1] << 8) |
+                    (data[inputAt + 2] << 16) |
+                    (data[inputAt + 3] << 24)) >>> 0;
+            inputAt += 4;
+        }
+        if (distance <= 0 || distance > outputAt || outputAt + length > output.length)
+            return undefined;
+        for (let i = 0; i < length; i += 1)
+            output[outputAt + i] = output[outputAt + i - distance];
+        outputAt += length;
+    }
+    return outputAt === output.length ? output : undefined;
+}
+function blockHandle(data, offset, limit = data.length) {
+    const start = readVarint(data, offset, limit);
+    if (!start)
+        return undefined;
+    const size = readVarint(data, start.next, limit);
+    return size ? { offset: start.value, size: size.value, next: size.next } : undefined;
+}
+function readBlock(file, offset, size) {
+    if (offset < 0 || size < 0 || offset + size + 5 > file.length)
+        return undefined;
+    const body = file.subarray(offset, offset + size);
+    const compression = file[offset + size];
+    if (compression === 0)
+        return body;
+    return compression === 1 ? decodeSnappy(body) : undefined;
+}
+function blockEntries(block) {
+    if (block.length < 4)
+        return [];
+    const view = new DataView(block.buffer, block.byteOffset, block.byteLength);
+    const restarts = view.getUint32(block.length - 4, true);
+    const limit = block.length - 4 - restarts * 4;
+    if (limit < 0 || limit > block.length - 4)
+        return [];
+    const entries = [];
+    let previous = new Uint8Array();
+    let at = 0;
+    while (at < limit) {
+        const shared = readVarint(block, at, limit);
+        if (!shared)
+            break;
+        const added = readVarint(block, shared.next, limit);
+        if (!added)
+            break;
+        const valueLength = readVarint(block, added.next, limit);
+        if (!valueLength || shared.value > previous.length)
+            break;
+        const keyAt = valueLength.next;
+        const valueAt = keyAt + added.value;
+        const next = valueAt + valueLength.value;
+        if (next > limit)
+            break;
+        const key = new Uint8Array(shared.value + added.value);
+        key.set(previous.subarray(0, shared.value));
+        key.set(block.subarray(keyAt, valueAt), shared.value);
+        const value = block.slice(valueAt, next);
+        entries.push({ key, value });
+        previous = key;
+        at = next;
+    }
+    return entries;
+}
+function levelDbTableEntries(file) {
+    const footerAt = file.length - 48;
+    if (footerAt < 0)
+        return [];
+    const meta = blockHandle(file, footerAt, footerAt + 40);
+    const indexHandle = meta ? blockHandle(file, meta.next, footerAt + 40) : undefined;
+    if (!indexHandle)
+        return [];
+    const index = readBlock(file, indexHandle.offset, indexHandle.size);
+    if (!index)
+        return [];
+    const entries = [];
+    for (const indexEntry of blockEntries(index)) {
+        const handle = blockHandle(indexEntry.value, 0);
+        if (!handle)
+            continue;
+        const data = readBlock(file, handle.offset, handle.size);
+        if (data)
+            entries.push(...blockEntries(data));
+    }
+    return entries;
+}
+function defaultClaudeDataDir() {
+    if (process.platform === "win32") {
+        return join(process.env.APPDATA?.trim() || join(homedir(), "AppData", "Roaming"), "Claude");
+    }
+    if (process.platform === "darwin") {
+        return join(homedir(), "Library", "Application Support", "Claude");
+    }
+    return join(process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config"), "Claude");
+}
+export function parseClaudeDefaultModel(data) {
+    const bytes = typeof data === "string" ? Buffer.from(data, "latin1") : data;
+    const find = (text) => {
+        const matches = [...text.matchAll(/default-model[\s\S]{0,128}?(claude-[a-z0-9][a-z0-9._-]*)/gi)];
+        return matches.at(-1)?.[1]?.toLowerCase();
+    };
+    const raw = find(Buffer.from(bytes).toString("latin1"));
+    if (raw)
+        return raw;
+    let latest;
+    for (const entry of levelDbTableEntries(bytes)) {
+        if (!Buffer.from(entry.key).includes(Buffer.from("default-model")))
+            continue;
+        latest = find(`default-model ${Buffer.from(entry.value).toString("latin1")}`) ?? latest;
+    }
+    return latest;
+}
+export function parseClaudeDefaultEffort(text) {
+    try {
+        const effort = JSON.parse(text).effortLevel;
+        return typeof effort === "string" && EFFORT_LEVELS.has(effort)
+            ? effort
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function sameSelection(a, b) {
+    return a?.model === b.model && a?.effort === b.effort;
+}
+export class ClaudeDefaultSelectionWatcher {
+    onChange;
+    settingsPath;
+    levelDbDir;
+    pollIntervalMs;
+    timer;
+    current;
+    constructor(options, onChange) {
+        this.onChange = onChange;
+        const dataDir = defaultClaudeDataDir();
+        this.settingsPath = options.settingsPath || join(claudeConfigDir(), "settings.json");
+        this.levelDbDir = options.levelDbDir || join(dataDir, "Local Storage", "leveldb");
+        this.pollIntervalMs = options.pollIntervalMs ?? 2_000;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.poll();
+        this.timer = setInterval(() => this.poll(), this.pollIntervalMs);
+    }
+    stop() {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = undefined;
+    }
+    poll() {
+        const selection = {
+            model: this.readModel() ?? this.current?.model,
+            effort: this.readEffort(),
+        };
+        if (sameSelection(this.current, selection))
+            return;
+        this.current = selection;
+        this.onChange(selection);
+    }
+    readEffort() {
+        try {
+            return parseClaudeDefaultEffort(readFileSync(this.settingsPath, "utf8"));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    readModel() {
+        if (!existsSync(this.levelDbDir))
+            return undefined;
+        try {
+            const candidates = readdirSync(this.levelDbDir)
+                .filter((name) => /\.(?:ldb|log)$/i.test(name))
+                .map((name) => {
+                const path = join(this.levelDbDir, name);
+                return { path, modifiedAt: statSync(path).mtimeMs };
+            })
+                .sort((a, b) => b.modifiedAt - a.modifiedAt);
+            for (const candidate of candidates) {
+                const model = parseClaudeDefaultModel(readFileSync(candidate.path));
+                if (model)
+                    return model;
+            }
+        }
+        catch {
+            return undefined;
+        }
+        return undefined;
+    }
+}

package/dist/claude/desktop-focus.js

@@ -0,0 +1,191 @@
+import { watch } from "node:fs";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createLogger } from "../util/logger.js";
+const log = createLogger("desktop-focus");
+const POLL_MS = 2_000;
+const RESCAN_DEBOUNCE_MS = 150;
+const MAX_DEPTH = 4;
+export function sameDesktopFocus(a, b) {
+    return Boolean(a &&
+        a.cliSessionId === b.cliSessionId &&
+        a.focusedAt === b.focusedAt &&
+        a.model === b.model &&
+        a.effort === b.effort &&
+        a.failed === b.failed);
+}
+export function defaultDesktopSessionsDir() {
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA;
+        return appData ? join(appData, "Claude", "claude-code-sessions") : undefined;
+    }
+    if (process.platform === "darwin") {
+        return join(homedir(), "Library", "Application Support", "Claude", "claude-code-sessions");
+    }
+    const base = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
+    return join(base, "Claude", "claude-code-sessions");
+}
+export function parseDesktopSession(text) {
+    let obj;
+    try {
+        obj = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    if (obj === null || typeof obj !== "object" || obj.isArchived === true)
+        return undefined;
+    const cliSessionId = obj.cliSessionId;
+    const focusedAt = obj.lastFocusedAt;
+    if (typeof cliSessionId !== "string" || cliSessionId === "")
+        return undefined;
+    if (typeof focusedAt !== "number" || !Number.isFinite(focusedAt) || focusedAt <= 0)
+        return undefined;
+    const focus = { cliSessionId, focusedAt };
+    if (typeof obj.lastActivityAt === "number" && Number.isFinite(obj.lastActivityAt) && obj.lastActivityAt > 0) {
+        focus.lastActivityAt = obj.lastActivityAt;
+    }
+    if (typeof obj.model === "string" && obj.model !== "")
+        focus.model = obj.model;
+    if (typeof obj.effort === "string" && obj.effort !== "")
+        focus.effort = obj.effort;
+    if ((typeof obj.error === "string" && obj.error.trim() !== "") ||
+        (obj.error !== undefined && obj.error !== null && obj.error !== false && typeof obj.error !== "string")) {
+        focus.failed = true;
+    }
+    return focus;
+}
+export class DesktopFocusWatcher {
+    dir;
+    onFocus;
+    watcher;
+    pollTimer;
+    rescanTimer;
+    scanning = false;
+    mtimes = new Map();
+    byFile = new Map();
+    lastReported;
+    stopped = false;
+    constructor(dir, onFocus) {
+        this.dir = dir;
+        this.onFocus = onFocus;
+    }
+    async start() {
+        await this.scan();
+        try {
+            this.watcher = watch(this.dir, { recursive: true }, () => this.scheduleScan());
+            this.watcher.on("error", (err) => log.warn(`watch error: ${err.message}`));
+            log.info(`watching ${this.dir}`);
+        }
+        catch (err) {
+            log.warn(`fs.watch unavailable for ${this.dir}: ${err.message}; relying on poll`);
+        }
+        this.pollTimer = setInterval(() => void this.scan(), POLL_MS);
+    }
+    stop() {
+        this.stopped = true;
+        if (this.watcher)
+            this.watcher.close();
+        if (this.pollTimer)
+            clearInterval(this.pollTimer);
+        if (this.rescanTimer)
+            clearTimeout(this.rescanTimer);
+    }
+    scheduleScan() {
+        if (this.stopped || this.rescanTimer)
+            return;
+        this.rescanTimer = setTimeout(() => {
+            this.rescanTimer = undefined;
+            void this.scan();
+        }, RESCAN_DEBOUNCE_MS);
+    }
+    async scan() {
+        if (this.stopped || this.scanning)
+            return;
+        this.scanning = true;
+        try {
+            await this.scanLocked();
+        }
+        catch (err) {
+            log.debug(`scan failed: ${err.message}`);
+        }
+        finally {
+            this.scanning = false;
+        }
+    }
+    async listSessionFiles() {
+        const out = [];
+        const walk = async (dir, depth) => {
+            let entries;
+            try {
+                entries = await readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                const full = join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (depth < MAX_DEPTH)
+                        await walk(full, depth + 1);
+                }
+                else if (entry.name.startsWith("local_") && entry.name.endsWith(".json")) {
+                    out.push(full);
+                }
+            }
+        };
+        await walk(this.dir, 0);
+        return out;
+    }
+    async scanLocked() {
+        const files = await this.listSessionFiles();
+        const seen = new Set(files);
+        for (const file of this.mtimes.keys()) {
+            if (!seen.has(file)) {
+                this.mtimes.delete(file);
+                this.byFile.delete(file);
+            }
+        }
+        for (const file of files) {
+            let mtime;
+            try {
+                mtime = (await stat(file)).mtimeMs;
+            }
+            catch {
+                continue;
+            }
+            if (this.mtimes.get(file) === mtime)
+                continue;
+            let text;
+            try {
+                text = await readFile(file, "utf8");
+            }
+            catch {
+                continue;
+            }
+            const parsed = parseDesktopSession(text);
+            if (!parsed) {
+                this.mtimes.delete(file);
+                this.byFile.delete(file);
+                continue;
+            }
+            parsed.updatedAt = mtime;
+            this.mtimes.set(file, mtime);
+            this.byFile.set(file, parsed);
+        }
+        let best;
+        for (const focus of this.byFile.values()) {
+            if (!best || focus.focusedAt > best.focusedAt)
+                best = focus;
+        }
+        if (!best)
+            return;
+        if (sameDesktopFocus(this.lastReported, best))
+            return;
+        this.lastReported = { ...best };
+        log.debug(`focused session=${best.cliSessionId.slice(0, 8)} at=${best.focusedAt} ` +
+            `model=${best.model ?? "-"} effort=${best.effort ?? "-"} failed=${best.failed ? "yes" : "no"}`);
+        this.onFocus(best);
+    }
+}

package/dist/claude/limits.js

@@ -0,0 +1,90 @@
+function epochSecondsToMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return undefined;
+    return value < 1e12 ? Math.round(value * 1000) : Math.round(value);
+}
+function isoToMs(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const ms = Date.parse(value);
+    return Number.isFinite(ms) ? ms : undefined;
+}
+function percentage(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 100
+        ? value
+        : undefined;
+}
+export function limitsFromStatusline(rateLimits, at) {
+    if (!rateLimits)
+        return undefined;
+    const limits = { updatedAt: at };
+    const five = rateLimits.five_hour;
+    const seven = rateLimits.seven_day;
+    const fiveUsed = percentage(five?.used_percentage);
+    const sevenUsed = percentage(seven?.used_percentage);
+    if (fiveUsed !== undefined) {
+        limits.fiveHour = { usedPercentage: fiveUsed, resetsAt: epochSecondsToMs(five?.resets_at) };
+    }
+    if (sevenUsed !== undefined) {
+        limits.sevenDay = { usedPercentage: sevenUsed, resetsAt: epochSecondsToMs(seven?.resets_at) };
+    }
+    if (!limits.fiveHour && !limits.sevenDay)
+        return undefined;
+    return limits;
+}
+export function limitsFromUsage(usage, at) {
+    const limits = { updatedAt: at };
+    const fiveUsed = percentage(usage.five_hour?.utilization);
+    const sevenUsed = percentage(usage.seven_day?.utilization);
+    if (fiveUsed !== undefined) {
+        limits.fiveHour = { usedPercentage: fiveUsed, resetsAt: isoToMs(usage.five_hour?.resets_at) };
+    }
+    if (sevenUsed !== undefined) {
+        limits.sevenDay = { usedPercentage: sevenUsed, resetsAt: isoToMs(usage.seven_day?.resets_at) };
+    }
+    const scoped = [];
+    for (const entry of usage.limits ?? []) {
+        if (entry.kind !== "weekly_scoped")
+            continue;
+        const label = entry.scope?.model?.display_name;
+        const used = percentage(entry.percent);
+        if (typeof label === "string" && label !== "" && used !== undefined) {
+            scoped.push({ label, usedPercentage: used });
+        }
+    }
+    if (scoped.length > 0)
+        limits.sevenDayScoped = scoped;
+    if (!limits.fiveHour && !limits.sevenDay && !limits.sevenDayScoped)
+        return undefined;
+    return limits;
+}
+function pickWindow(a, aAt, b, bAt) {
+    if (a && b)
+        return aAt >= bAt ? a : b;
+    return a ?? b;
+}
+export function mergeLimits(a, b, preferB = false) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    const fiveHour = preferB
+        ? b.fiveHour ?? a.fiveHour
+        : pickWindow(a.fiveHour, a.updatedAt, b.fiveHour, b.updatedAt);
+    const sevenDay = preferB
+        ? b.sevenDay ?? a.sevenDay
+        : pickWindow(a.sevenDay, a.updatedAt, b.sevenDay, b.updatedAt);
+    const fresher = a.updatedAt >= b.updatedAt ? a : b;
+    const older = a.updatedAt >= b.updatedAt ? b : a;
+    const scoped = preferB
+        ? b.sevenDayScoped ?? a.sevenDayScoped
+        : fresher.sevenDayScoped ?? older.sevenDayScoped;
+    const merged = { updatedAt: Math.max(a.updatedAt, b.updatedAt) };
+    if (fiveHour)
+        merged.fiveHour = fiveHour;
+    if (sevenDay)
+        merged.sevenDay = sevenDay;
+    if (scoped)
+        merged.sevenDayScoped = scoped;
+    return merged;
+}