claude-code-discord-presence 1.0.0

package/.env.example

@@ -0,0 +1,21 @@
+CLAUDE_DISCORD_APPLICATION_ID=
+CLAUDE_APP_NAME=Claude Code
+PORT=41724
+USAGE_POLL_INTERVAL_S=300
+CLAUDE_LARGE_IMAGE_KEY=claude_code
+CLAUDE_LARGE_IMAGE_KEY_LIGHT=claude-liquid-light
+CLAUDE_LARGE_IMAGE_KEY_DARK=claude-liquid-dark
+CLAUDE_LARGE_IMAGE_URL=
+CLAUDE_SMALL_IMAGE_KEY=claude-usage-stats
+CLAUDE_SMALL_IMAGE_KEY_LIGHT=claude-stats-light
+CLAUDE_SMALL_IMAGE_KEY_DARK=claude-stats-dark
+CLAUDE_SMALL_IMAGE_URL=
+CLAUDE_CONFIG_DIR=
+CLAUDE_DESKTOP_SESSIONS_DIR=
+CLAUDE_REMOTE_HOSTS=
+CLAUDE_REMOTE_PORT=
+CLAUDE_PRESENCE_DATA_DIR=
+RPC_LOG_FILE=
+RPC_LOG_LEVEL=warn
+RPC_LOG_MAX_BYTES=1048576
+USAGE_TOKEN_REFRESH=off

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dayfinggg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,164 @@
+# Claude Code Discord Presence
+
+[![npm version](https://img.shields.io/npm/v/claude-code-discord-presence?logo=npm)](https://www.npmjs.com/package/claude-code-discord-presence)
+[![CI](https://github.com/dayfinggg/claude-code-discord-presence/actions/workflows/ci.yml/badge.svg)](https://github.com/dayfinggg/claude-code-discord-presence/actions/workflows/ci.yml)
+[![Node.js 22+](https://img.shields.io/badge/Node.js-22.18%2B-339933?logo=node.js&logoColor=white)](https://nodejs.org/)
+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Cross-platform Discord Rich Presence for Claude Code Desktop and Claude Code CLI. Show the active
+model, effort, usage limits, reset countdowns, tools, agents, token usage, cost, context, plan mode,
+Fast mode, and secure remote SSH sessions on Windows, macOS, and Linux.
+
+<p align="center">
+  <img src="assets/claude-code.png" width="180" alt="Claude Code Discord Presence icon">
+</p>
+
+## Quick start — no manual hook setup
+
+You only need Node.js 22.18 or newer, Claude Code, and Discord Desktop. The first command safely
+installs the required Claude Code hooks and statusline, then starts Rich Presence:
+
+```bash
+npx claude-code-discord-presence
+```
+
+For a persistent command:
+
+```bash
+npm install --global claude-code-discord-presence
+claude-code-presence
+```
+
+No Discord application, `.env` file, Bun, `jq`, `curl`, or platform-specific shell script is
+required. Existing unrelated Claude settings and hooks are preserved.
+
+## What it shows
+
+| Discord field | Live data |
+| --- | --- |
+| Details | Plan and authoritative 5-hour/7-day allowance left with reset countdowns |
+| State | Model, effort, Fast mode, current tool/action, Plan mode, agents, notifications |
+| Timer | Current Claude Code session duration |
+| Large-image tooltip | Input, cache read/write, output, cost, and context usage |
+| Small-image tooltip | Day, week, month, and all-time token and cost totals |
+
+The account usage endpoint is preferred over placeholder statusline zeroes. This prevents the false
+`100% left` display that some Claude clients emit while keeping statusline data as an offline fallback.
+
+## Hooks and statusline
+
+The installer copies self-contained Node.js scripts to `~/.claude/discord-presence/` and updates the
+user-level `settings.json` used by Claude Code CLI and Desktop.
+
+- Command hooks cover `SessionStart`, prompts, tool use and failures, agents, notifications, stop,
+  and session end.
+- `SessionStart` uses an official command hook rather than an unsupported HTTP hook.
+- The statusline displays the model, effort, Fast mode, and available usage while forwarding the
+  same structured payload to Rich Presence.
+- Hook and statusline scripts never create their own logs and silently tolerate a stopped service.
+- Existing settings are backed up under `~/.claude/backups/claude-code-presence/`; only five backups
+  are retained.
+
+Run the installer explicitly at any time with `claude-code-presence setup`.
+
+## Desktop, CLI, and platforms
+
+| Platform | Claude Code Desktop | Claude Code CLI | Per-user autostart |
+| --- | ---: | ---: | ---: |
+| Windows | Yes | Yes | Registry launcher with a bounded supervisor log |
+| macOS | Yes | Yes | LaunchAgent |
+| Linux | Where available | Yes | systemd user service |
+
+Windows detection supports Microsoft Store, native Desktop, and native CLI processes. macOS and
+Linux combine Claude's session PID files with native `ps` scanning, so either Desktop or CLI keeps
+the correct activity alive. Desktop focus files select ordinary chats as well as project sessions.
+
+## Autostart
+
+```bash
+claude-code-presence autostart
+```
+
+The command ensures hooks are installed before registering startup. Remove it with:
+
+```bash
+claude-code-presence autostart:remove
+```
+
+## Optional configuration
+
+Defaults work without configuration. Pass options directly:
+
+```bash
+claude-code-presence --log-level debug --usage-poll-interval 120
+claude-code-presence --claude-config-dir ~/.custom-claude
+```
+
+Or copy `.env.example`, edit it, and run `claude-code-presence --env /path/to/.env`.
+
+| CLI option | Environment variable | Purpose |
+| --- | --- | --- |
+| `--application-id` | `CLAUDE_DISCORD_APPLICATION_ID` | Use a different Discord application |
+| `--port` | `PORT` | Local loopback hook port; default `41724` |
+| `--claude-config-dir` | `CLAUDE_CONFIG_DIR` | Override Claude's user config directory |
+| `--desktop-sessions-dir` | `CLAUDE_DESKTOP_SESSIONS_DIR` | Override Desktop focus files, or `off` |
+| `--remote-hosts` | `CLAUDE_REMOTE_HOSTS` | Comma-separated SSH config aliases |
+| `--remote-port` | `CLAUDE_REMOTE_PORT` | Remote loopback forwarding port |
+| `--usage-poll-interval` | `USAGE_POLL_INTERVAL_S` | Account limit refresh interval |
+| `--log-level` | `RPC_LOG_LEVEL` | `debug`, `info`, `warn`, `error`, or `silent` |
+| `--log-max-bytes` | `RPC_LOG_MAX_BYTES` | Maximum size of the active log; default 1 MiB |
+
+Set `USAGE_TOKEN_REFRESH=on` only if you explicitly want the service to refresh and save Claude's
+OAuth token. The safe default is read-only: Claude Code remains responsible for its credentials.
+The repository `.env` is ignored and never published to GitHub or npm.
+
+## Secure remote Claude Code sessions
+
+Use SSH config aliases; the project never contains a hostname, address, username, port, or key.
+First install the same Node hooks and statusline on explicitly selected hosts:
+
+```bash
+claude-code-presence remote:setup --remote-hosts work-box,dev-box
+```
+
+Then start with the same allowlist:
+
+```bash
+claude-code-presence --remote-hosts work-box,dev-box
+```
+
+The service maintains reverse tunnels from remote `127.0.0.1` to local `127.0.0.1`. Aliases that
+look like SSH options, user/address targets, whitespace, or shell syntax are rejected. SSH runs with
+`shell: false`, batch mode, connection timeouts, bounded reconnect backoff, and loopback-only binds.
+
+## Logging, privacy, and safety
+
+The receiver binds only to `127.0.0.1`, accepts only health, hook, and statusline routes, caps JSON
+bodies at 512 KiB, and has short request timeouts. Hooks do not control Claude or execute received
+commands; they provide telemetry to the in-memory presence store.
+
+The default log level is `warn`. Normal statusline invocations, hooks, polling, and Discord updates
+are not logged. The active log and one archive are each limited to 1 MiB by default. Access tokens,
+hook bodies, transcripts, and tool inputs are never written to logs.
+
+## Build from source
+
+```bash
+git clone https://github.com/dayfinggg/claude-code-discord-presence.git
+cd claude-code-discord-presence
+npm ci
+npm test
+npm run typecheck
+npm run build
+npm start
+```
+
+## Discord assets
+
+The exact light, dark, fallback, and usage images used by the default Discord application are in
+[`assets/`](assets). Use the matching keys from `.env.example` when configuring another application.
+
+## License and attribution
+
+[MIT](LICENSE). This community project is not affiliated with or endorsed by Anthropic or Discord.
+Anthropic, Claude, Claude Code, and Discord are trademarks of their respective owners.

package/dist/appearance/theme-assets.js

@@ -0,0 +1,13 @@
+export function activityAssetsForTheme(assets, theme) {
+    return {
+        appName: assets.appName,
+        largeImageKey: theme === "dark"
+            ? assets.largeImageKeyDark ?? assets.largeImageKey
+            : assets.largeImageKeyLight ?? assets.largeImageKey,
+        largeImageUrl: assets.largeImageUrl,
+        smallImageKey: theme === "dark"
+            ? assets.smallImageKeyDark ?? assets.smallImageKey
+            : assets.smallImageKeyLight ?? assets.smallImageKey,
+        smallImageUrl: assets.smallImageUrl,
+    };
+}

package/dist/appearance/theme-watcher.js

@@ -0,0 +1,188 @@
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+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");
+}
+function normalizeThemePreference(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const raw = value.toLowerCase();
+    if (raw === "auto" || raw === "system")
+        return "system";
+    return raw === "light" || raw === "dark" ? raw : undefined;
+}
+export function parseCodexThemePreference(text) {
+    const match = /^\s*appearanceTheme\s*=\s*["']?(light|dark|system)["']?\s*(?:#.*)?$/im.exec(text);
+    return match?.[1]?.toLowerCase();
+}
+export function parseClaudeThemePreference(data) {
+    const text = typeof data === "string" ? data : Buffer.from(data).toString("latin1");
+    const matches = [...text.matchAll(/userTheme[\s\S]{0,96}?(auto|system|light|dark)/gi)];
+    return normalizeThemePreference(matches.at(-1)?.[1]);
+}
+export function parseClaudeConfigTheme(text) {
+    try {
+        const config = JSON.parse(text);
+        return normalizeThemePreference(config.userThemeMode ?? config.userTheme);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readClaudeConfigTheme(path) {
+    try {
+        return parseClaudeConfigTheme(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resolveTheme(preference, systemTheme) {
+    return preference === "light" || preference === "dark" ? preference : systemTheme;
+}
+function readCodexPreference(codexHome) {
+    if (!codexHome)
+        return undefined;
+    try {
+        return parseCodexThemePreference(readFileSync(join(codexHome, "config.toml"), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readSystemTheme() {
+    try {
+        if (process.platform === "win32") {
+            const { stdout } = await execFileAsync("reg.exe", [
+                "query",
+                "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize",
+                "/v",
+                "AppsUseLightTheme",
+            ], { windowsHide: true });
+            const match = /AppsUseLightTheme\s+REG_DWORD\s+0x([0-9a-f]+)/i.exec(stdout);
+            if (match?.[1])
+                return Number.parseInt(match[1], 16) === 0 ? "dark" : "light";
+        }
+        else if (process.platform === "darwin") {
+            const { stdout } = await execFileAsync("defaults", ["read", "-g", "AppleInterfaceStyle"]);
+            return /dark/i.test(stdout) ? "dark" : "light";
+        }
+        else {
+            const { stdout } = await execFileAsync("gsettings", [
+                "get",
+                "org.gnome.desktop.interface",
+                "color-scheme",
+            ]);
+            return /dark/i.test(stdout) ? "dark" : "light";
+        }
+    }
+    catch {
+        return "light";
+    }
+    return "light";
+}
+function themesEqual(a, b) {
+    return a?.claude === b.claude && a.codex === b.codex;
+}
+export class AppearanceThemeWatcher {
+    codexHome;
+    claudeConfigPath;
+    claudeLevelDbDir;
+    pollIntervalMs;
+    onChange;
+    timer;
+    polling = false;
+    current;
+    claudePreference;
+    claudeFileSignatures = new Map();
+    constructor(options, onChange) {
+        const claudeDataDir = defaultClaudeDataDir();
+        this.codexHome = options.codexHome;
+        this.claudeConfigPath = options.claudeConfigPath || join(claudeDataDir, "config.json");
+        this.claudeLevelDbDir =
+            options.claudeLevelDbDir || join(claudeDataDir, "Local Storage", "leveldb");
+        this.pollIntervalMs = options.pollIntervalMs ?? 2_000;
+        this.onChange = onChange;
+    }
+    start() {
+        if (this.timer)
+            return;
+        void this.poll();
+        this.timer = setInterval(() => void this.poll(), this.pollIntervalMs);
+    }
+    stop() {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = undefined;
+    }
+    async poll() {
+        if (this.polling)
+            return;
+        this.polling = true;
+        try {
+            const systemTheme = await readSystemTheme();
+            const themes = {
+                claude: resolveTheme(this.readClaudePreference(), systemTheme),
+                codex: resolveTheme(readCodexPreference(this.codexHome), systemTheme),
+            };
+            if (!themesEqual(this.current, themes)) {
+                this.current = themes;
+                this.onChange(themes);
+            }
+        }
+        finally {
+            this.polling = false;
+        }
+    }
+    readClaudePreference() {
+        const configPreference = readClaudeConfigTheme(this.claudeConfigPath);
+        if (configPreference) {
+            this.claudePreference = configPreference;
+            return configPreference;
+        }
+        if (!existsSync(this.claudeLevelDbDir))
+            return this.claudePreference;
+        try {
+            const candidates = readdirSync(this.claudeLevelDbDir)
+                .filter((name) => /\.(?:ldb|log)$/i.test(name))
+                .map((name) => {
+                const path = join(this.claudeLevelDbDir, name);
+                const stats = statSync(path);
+                return {
+                    path,
+                    modifiedAt: stats.mtimeMs,
+                    signature: `${stats.mtimeMs}:${stats.size}`,
+                };
+            })
+                .sort((a, b) => b.modifiedAt - a.modifiedAt);
+            let latest;
+            const signatures = new Map();
+            for (const candidate of candidates) {
+                signatures.set(candidate.path, candidate.signature);
+                if (this.claudeFileSignatures.get(candidate.path) === candidate.signature)
+                    continue;
+                const preference = parseClaudeThemePreference(readFileSync(candidate.path));
+                if (!latest && preference)
+                    latest = preference;
+            }
+            this.claudeFileSignatures = signatures;
+            if (latest)
+                this.claudePreference = latest;
+        }
+        catch {
+            return this.claudePreference;
+        }
+        return this.claudePreference;
+    }
+}

package/dist/claude/app-liveness.js

@@ -0,0 +1,82 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createLogger } from "../util/logger.js";
+import { claudeConfigDir } from "./paths.js";
+const log = createLogger("app-liveness");
+const POLL_MS = 15_000;
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === "EPERM";
+    }
+}
+export class ClaudeAppLiveness {
+    onUpdate;
+    dir;
+    timer;
+    scanning = false;
+    stopped = false;
+    lastAlive;
+    constructor(onUpdate, dir = join(claudeConfigDir(), "sessions")) {
+        this.onUpdate = onUpdate;
+        this.dir = dir;
+    }
+    start() {
+        void this.scan();
+        this.timer = setInterval(() => void this.scan(), POLL_MS);
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearInterval(this.timer);
+    }
+    async scan() {
+        if (this.stopped || this.scanning)
+            return;
+        this.scanning = true;
+        try {
+            let alive = false;
+            let earliest;
+            let pid;
+            let entries = [];
+            try {
+                entries = await readdir(this.dir);
+            }
+            catch {
+                entries = [];
+            }
+            for (const name of entries) {
+                if (!name.endsWith(".json"))
+                    continue;
+                let obj;
+                try {
+                    obj = JSON.parse(await readFile(join(this.dir, name), "utf8"));
+                }
+                catch {
+                    continue;
+                }
+                if (typeof obj.pid !== "number" || !processAlive(obj.pid))
+                    continue;
+                alive = true;
+                if (typeof obj.startedAt === "number" && (earliest === undefined || obj.startedAt < earliest)) {
+                    earliest = obj.startedAt;
+                    pid = obj.pid;
+                }
+                else if (pid === undefined) {
+                    pid = obj.pid;
+                }
+            }
+            if (alive !== this.lastAlive) {
+                this.lastAlive = alive;
+                log.debug(`claude processes alive=${alive}${earliest !== undefined ? ` earliestStartedAt=${earliest}` : ""}`);
+            }
+            this.onUpdate(alive, earliest, pid);
+        }
+        finally {
+            this.scanning = false;
+        }
+    }
+}

package/dist/claude/cost.js

@@ -0,0 +1,54 @@
+import { join } from "node:path";
+import { readFileSync, existsSync } from "node:fs";
+import pricingConfig from "../../pricing.json" with { type: "json" };
+import { claudeConfigDir } from "./paths.js";
+const DEFAULT_PRICING = pricingConfig.claude.models;
+const PRICING_PATH = join(claudeConfigDir(), "discord-rpc-pricing.json");
+let pricing = { ...DEFAULT_PRICING };
+export function loadPricingOverrides() {
+    if (!existsSync(PRICING_PATH))
+        return false;
+    try {
+        const overrides = JSON.parse(readFileSync(PRICING_PATH, "utf8"));
+        pricing = { ...DEFAULT_PRICING };
+        for (const [id, p] of Object.entries(overrides)) {
+            const base = pricing[normalizeModelId(id)] ?? { input: 0, output: 0, cacheWrite: 0, cacheRead: 0 };
+            pricing[normalizeModelId(id)] = { ...base, ...p };
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function normalizeModelId(id) {
+    return id.replace(/-fast$/, "").replace(/-\d{8}$/, "");
+}
+export function costBreakdown(model, usage) {
+    const price = pricing[normalizeModelId(model)];
+    if (!price)
+        return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+    const multiplier = model.endsWith("-fast") ? (price.fastMultiplier ?? 1) : 1;
+    const oneHour = Math.min(usage.cacheWrite, usage.cacheWriteOneHour ?? 0);
+    const input = (usage.input * price.input * multiplier) / 1_000_000;
+    const output = (usage.output * price.output * multiplier) / 1_000_000;
+    const cacheRead = (usage.cacheRead * price.cacheRead * multiplier) / 1_000_000;
+    const cacheWrite = ((usage.cacheWrite - oneHour) * price.cacheWrite +
+        oneHour * (price.cacheWriteOneHour ?? price.cacheWrite * 2)) * multiplier / 1_000_000;
+    return { input, output, cacheRead, cacheWrite, total: input + output + cacheRead + cacheWrite };
+}
+export function costUsd(model, usage) {
+    return costBreakdown(model, usage).total;
+}
+export function costForUsageByModel(usageByModel) {
+    const total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+    for (const [model, usage] of Object.entries(usageByModel)) {
+        const breakdown = costBreakdown(model, usage);
+        total.input += breakdown.input;
+        total.output += breakdown.output;
+        total.cacheRead += breakdown.cacheRead;
+        total.cacheWrite += breakdown.cacheWrite;
+        total.total += breakdown.total;
+    }
+    return total;
+}