claude-code-discord-presence 1.0.0

package/dist/claude/transcript.js

@@ -0,0 +1,150 @@
+import { open, stat, readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { createLogger } from "../util/logger.js";
+import { claudeConfigDir } from "./paths.js";
+const log = createLogger("transcript");
+const TAIL_BYTES = 262144;
+const PROJECTS_DIR = join(claudeConfigDir(), "projects");
+export async function findTranscriptPath(sessionId) {
+    try {
+        for (const dir of await readdir(PROJECTS_DIR)) {
+            const candidate = join(PROJECTS_DIR, dir, `${sessionId}.jsonl`);
+            try {
+                await stat(candidate);
+                return candidate;
+            }
+            catch {
+                /* not in this project dir */
+            }
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return undefined;
+}
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+export async function readSessionStats(path) {
+    try {
+        const text = await readFile(path, "utf8");
+        const seen = new Set();
+        const usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+        const usageByModel = {};
+        let lastModel;
+        for (const line of text.split("\n")) {
+            if (line.charCodeAt(0) !== 123)
+                continue;
+            let obj;
+            try {
+                obj = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (obj.type !== "assistant" || obj.isSidechain === true)
+                continue;
+            const msg = obj.message;
+            const id = msg?.id;
+            const model = msg?.model;
+            const u = msg?.usage;
+            if (typeof id !== "string" || typeof model !== "string" || !u || seen.has(id))
+                continue;
+            seen.add(id);
+            lastModel = model;
+            const bucket = (usageByModel[model] ??= { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+            const input = num(u.input_tokens);
+            const output = num(u.output_tokens);
+            const cacheRead = num(u.cache_read_input_tokens);
+            const cacheWrite = num(u.cache_creation_input_tokens);
+            usage.input += input;
+            usage.output += output;
+            usage.cacheRead += cacheRead;
+            usage.cacheWrite += cacheWrite;
+            bucket.input += input;
+            bucket.output += output;
+            bucket.cacheRead += cacheRead;
+            bucket.cacheWrite += cacheWrite;
+        }
+        if (seen.size === 0)
+            return undefined;
+        const stats = { usage, usageByModel };
+        if (lastModel)
+            stats.model = lastModel;
+        return stats;
+    }
+    catch (err) {
+        log.debug(`session stats read failed: ${err.message}`);
+        return undefined;
+    }
+}
+function modelCommand(content) {
+    const text = typeof content === "string"
+        ? content
+        : Array.isArray(content)
+            ? content
+                .map((item) => item && typeof item === "object" && "text" in item ? item.text : undefined)
+                .filter((item) => typeof item === "string")
+                .join("\n")
+            : "";
+    const args = text.match(/<command-name>\/model<\/command-name>[\s\S]*?<command-args>([^<]+)<\/command-args>/i)?.[1]
+        ?? text.match(/<local-command-stdout>\s*Set model to\s+([^<\s]+)[\s\S]*?<\/local-command-stdout>/i)?.[1];
+    const model = args?.trim();
+    return model?.startsWith("claude-") ? model : undefined;
+}
+export async function readModelFromTranscript(path) {
+    let handle;
+    try {
+        const info = await stat(path);
+        if (info.size === 0)
+            return {};
+        const length = Math.min(info.size, TAIL_BYTES);
+        handle = await open(path, "r");
+        const buffer = Buffer.alloc(length);
+        await handle.read(buffer, 0, length, info.size - length);
+        const text = buffer.toString("utf8");
+        const found = {};
+        for (const line of text.split("\n")) {
+            if (line.charCodeAt(0) !== 123)
+                continue;
+            let obj;
+            try {
+                obj = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const fallback = obj.type === "system" && obj.subtype === "model_refusal_fallback"
+                ? obj.fallbackModel
+                : undefined;
+            const command = obj.type === "user" && obj.isSidechain !== true
+                ? modelCommand(obj.message?.content)
+                : undefined;
+            const messageModel = obj.message?.model;
+            const model = typeof fallback === "string" && fallback.startsWith("claude-")
+                ? fallback
+                : command
+                    ?? (typeof messageModel === "string" && messageModel.startsWith("claude-") ? messageModel : undefined);
+            if (!model)
+                continue;
+            found.any = model;
+            if (obj.isSidechain === true)
+                continue;
+            found.main = model;
+            const timestamp = typeof obj.timestamp === "string" ? Date.parse(obj.timestamp) : Number.NaN;
+            found.mainAt = Number.isFinite(timestamp) ? timestamp : info.mtimeMs;
+            found.mainEvent = [obj.timestamp, obj.uuid, obj.requestId, obj.subtype, model]
+                .filter((value) => typeof value === "string" && value !== "")
+                .join(":");
+        }
+        return found;
+    }
+    catch (err) {
+        log.debug(`transcript read failed: ${err.message}`);
+        return {};
+    }
+    finally {
+        await handle?.close();
+    }
+}

package/dist/claude/usage-poller.js

@@ -0,0 +1,243 @@
+import { watch } from "node:fs";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { limitsFromUsage } from "./limits.js";
+import { readOauthCredentials, saveRefreshedCredentials, CREDENTIALS_PATH } from "./plan-info.js";
+import { discoverOauthConfig } from "./oauth-discovery.js";
+import { createLogger } from "../util/logger.js";
+const log = createLogger("usage");
+const execFileAsync = promisify(execFile);
+const USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+const MAX_BACKOFF_MS = 30 * 60 * 1000;
+const EXPIRY_SLACK_MS = 60_000;
+const EXPIRED_RETRY_MS = 5 * 60 * 1000;
+const REFRESH_COOLDOWN_MS = 5 * 60 * 1000;
+const FALLBACK_CLI_VERSION = "2.1.204";
+export class UsagePoller {
+    intervalMs;
+    onUpdate;
+    timer;
+    inFlight = false;
+    stopped = false;
+    latest;
+    consecutiveFailures = 0;
+    lastRefreshAt = 0;
+    refreshing = false;
+    userAgent;
+    oauthConfig;
+    watcher;
+    watchDebounce;
+    constructor(intervalMs, onUpdate) {
+        this.intervalMs = intervalMs;
+        this.onUpdate = onUpdate;
+    }
+    getLatest() {
+        return this.latest;
+    }
+    start() {
+        this.stopped = false;
+        this.watchCredentials();
+        void this.tick();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        if (this.watchDebounce)
+            clearTimeout(this.watchDebounce);
+        this.watcher?.close();
+    }
+    schedule(delayMs) {
+        if (this.stopped)
+            return;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => void this.tick(), delayMs);
+    }
+    jitter(base) {
+        const spread = base * 0.2;
+        return base + Math.floor((0.5 - Math.abs((Date.now() % 1000) / 1000 - 0.5)) * spread);
+    }
+    watchCredentials() {
+        try {
+            this.watcher = watch(CREDENTIALS_PATH, () => {
+                if (this.watchDebounce)
+                    clearTimeout(this.watchDebounce);
+                this.watchDebounce = setTimeout(() => {
+                    if (this.stopped)
+                        return;
+                    log.debug("credentials changed; polling usage");
+                    void this.tick();
+                }, 2_000);
+            });
+        }
+        catch (err) {
+            log.debug(`credentials watch unavailable: ${err.message}`);
+        }
+    }
+    async getUserAgent() {
+        if (this.userAgent)
+            return this.userAgent;
+        let version = FALLBACK_CLI_VERSION;
+        try {
+            const { stdout } = await execFileAsync("claude", ["-v"], {
+                encoding: "utf8",
+                windowsHide: true,
+                timeout: 10_000,
+            });
+            const match = stdout.match(/(\d+\.\d+\.\d+)/);
+            if (match)
+                version = match[1];
+        }
+        catch (err) {
+            log.debug(`claude version probe failed: ${err.message}`);
+        }
+        this.userAgent = `claude-code/${version}`;
+        return this.userAgent;
+    }
+    refreshEnabled() {
+        const raw = process.env.USAGE_TOKEN_REFRESH?.trim().toLowerCase();
+        return raw === "on" || raw === "1" || raw === "true";
+    }
+    async refreshToken() {
+        if (!this.refreshEnabled() || this.refreshing)
+            return false;
+        const now = Date.now();
+        if (now - this.lastRefreshAt < REFRESH_COOLDOWN_MS)
+            return false;
+        this.lastRefreshAt = now;
+        this.refreshing = true;
+        try {
+            const creds = await readOauthCredentials();
+            if (!creds.refreshToken) {
+                log.warn("no refresh token available; cannot refresh access token");
+                return false;
+            }
+            this.oauthConfig ??= discoverOauthConfig();
+            const config = await this.oauthConfig;
+            for (const clientId of config.clientIds) {
+                for (const url of config.tokenUrls) {
+                    const host = new URL(url).host;
+                    try {
+                        const res = await fetch(url, {
+                            method: "POST",
+                            headers: { "Content-Type": "application/json" },
+                            body: JSON.stringify({
+                                grant_type: "refresh_token",
+                                refresh_token: creds.refreshToken,
+                                client_id: clientId,
+                            }),
+                        });
+                        if (!res.ok) {
+                            log.warn(`token refresh failed at ${host} (client ${clientId.slice(0, 8)}): ${res.status}`);
+                            continue;
+                        }
+                        const data = (await res.json());
+                        if (!data.access_token) {
+                            log.warn(`token refresh response from ${host} missing access_token`);
+                            continue;
+                        }
+                        const saved = await saveRefreshedCredentials(data.access_token, data.refresh_token, data.expires_in);
+                        if (saved)
+                            log.info("access token refreshed and saved");
+                        return saved;
+                    }
+                    catch (err) {
+                        log.warn(`token refresh error at ${host}: ${err.message}`);
+                    }
+                }
+            }
+            return false;
+        }
+        finally {
+            this.refreshing = false;
+        }
+    }
+    tokenExpired(expiresAt) {
+        return expiresAt !== undefined && expiresAt < Date.now() + EXPIRY_SLACK_MS;
+    }
+    async tick() {
+        if (this.inFlight || this.stopped)
+            return;
+        this.inFlight = true;
+        let nextDelay = this.intervalMs;
+        try {
+            let creds = await readOauthCredentials();
+            if (this.tokenExpired(creds.expiresAt)) {
+                if (await this.refreshToken())
+                    creds = await readOauthCredentials();
+                if (this.tokenExpired(creds.expiresAt)) {
+                    this.consecutiveFailures++;
+                    nextDelay = EXPIRED_RETRY_MS;
+                    log.warn("access token expired; waiting for a refresh before polling usage");
+                    return;
+                }
+            }
+            if (!creds.accessToken) {
+                log.warn("no access token available; retrying");
+                this.consecutiveFailures++;
+                nextDelay = Math.min(this.intervalMs, 60_000);
+                return;
+            }
+            const res = await fetch(USAGE_URL, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${creds.accessToken}`,
+                    "anthropic-beta": "oauth-2025-04-20",
+                    "Content-Type": "application/json",
+                    "User-Agent": await this.getUserAgent(),
+                },
+            });
+            if (res.status === 429) {
+                this.consecutiveFailures++;
+                const retryAfter = Number.parseInt(res.headers.get("retry-after") ?? "", 10);
+                const backoff = Number.isFinite(retryAfter) && retryAfter > 0
+                    ? retryAfter * 1000
+                    : Math.min(MAX_BACKOFF_MS, this.intervalMs * 2 ** this.consecutiveFailures);
+                nextDelay = this.jitter(backoff);
+                log.warn(`rate limited (429); backing off ${Math.round(nextDelay / 1000)}s`);
+                return;
+            }
+            if (res.status === 401 || res.status === 403) {
+                this.consecutiveFailures++;
+                const refreshed = await this.refreshToken();
+                nextDelay = refreshed ? 10_000 : EXPIRED_RETRY_MS;
+                log.warn(`usage auth failed (${res.status}); ${refreshed ? "retrying with the refreshed token" : "waiting for a token refresh"}`);
+                return;
+            }
+            if (!res.ok) {
+                this.consecutiveFailures++;
+                nextDelay = this.jitter(Math.min(MAX_BACKOFF_MS, this.intervalMs * 2 ** this.consecutiveFailures));
+                log.warn(`usage request failed: ${res.status}`);
+                return;
+            }
+            let parsed;
+            try {
+                parsed = (await res.json());
+            }
+            catch {
+                this.consecutiveFailures++;
+                nextDelay = 5_000;
+                log.warn("usage response parse failed; retrying shortly");
+                return;
+            }
+            const limits = limitsFromUsage(parsed, Date.now());
+            this.consecutiveFailures = 0;
+            if (limits) {
+                this.latest = limits;
+                const scoped = limits.sevenDayScoped?.map((s) => `${s.label}=${s.usedPercentage}`).join(",") ?? "-";
+                log.debug(`usage ok: 5h used=${limits.fiveHour?.usedPercentage ?? "-"} 7d used=${limits.sevenDay?.usedPercentage ?? "-"} scoped=${scoped}`);
+                this.onUpdate(limits);
+            }
+        }
+        catch (err) {
+            this.consecutiveFailures++;
+            nextDelay = this.jitter(Math.min(MAX_BACKOFF_MS, this.intervalMs * 2 ** this.consecutiveFailures));
+            log.warn(`usage poll error: ${err.message}`);
+        }
+        finally {
+            this.inFlight = false;
+            this.schedule(nextDelay);
+        }
+    }
+}

package/dist/cli.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+const projectDir = dirname(dirname(fileURLToPath(import.meta.url)));
+const packageJson = JSON.parse(readFileSync(resolve(projectDir, "package.json"), "utf8"));
+const flagEnvironment = {
+    "--application-id": "CLAUDE_DISCORD_APPLICATION_ID",
+    "--port": "PORT",
+    "--claude-config-dir": "CLAUDE_CONFIG_DIR",
+    "--desktop-sessions-dir": "CLAUDE_DESKTOP_SESSIONS_DIR",
+    "--remote-hosts": "CLAUDE_REMOTE_HOSTS",
+    "--remote-port": "CLAUDE_REMOTE_PORT",
+    "--usage-poll-interval": "USAGE_POLL_INTERVAL_S",
+    "--log-level": "RPC_LOG_LEVEL",
+    "--log-max-bytes": "RPC_LOG_MAX_BYTES",
+};
+function help() {
+    console.log(`Claude Code Discord Presence ${packageJson.version}
+
+Usage:
+  claude-code-presence [start] [options]
+  claude-code-presence setup [options]
+  claude-code-presence remote:setup [options]
+  claude-code-presence autostart [options]
+  claude-code-presence autostart:remove
+
+Options:
+  --env <file>                 Load an optional environment file
+  --application-id <id>        Override the shared Discord application
+  --port <port>                Local hook server port (default: 41724)
+  --claude-config-dir <path>   Override Claude's configuration directory
+  --desktop-sessions-dir <p>   Override Desktop session discovery, or off
+  --remote-hosts <aliases>     Comma-separated SSH config aliases
+  --remote-port <port>         Remote loopback tunnel port
+  --usage-poll-interval <sec>  Account usage refresh interval
+  --log-level <level>          debug, info, warn, error, or silent
+  --log-max-bytes <bytes>      Maximum bytes per log file
+  -h, --help                   Show help
+  -v, --version                Show version`);
+}
+const args = process.argv.slice(2);
+let command = "start";
+if (args[0] && !args[0].startsWith("-"))
+    command = args.shift();
+let envFile;
+for (let i = 0; i < args.length; i++) {
+    const flag = args[i];
+    if (flag === "--help" || flag === "-h") {
+        help();
+        process.exit(0);
+    }
+    if (flag === "--version" || flag === "-v") {
+        console.log(packageJson.version);
+        process.exit(0);
+    }
+    const value = args[++i];
+    if (!value)
+        throw new Error(`${flag} requires a value`);
+    if (flag === "--env")
+        envFile = resolve(value);
+    else {
+        const key = flagEnvironment[flag];
+        if (!key)
+            throw new Error(`Unknown option: ${flag}`);
+        process.env[key] = value;
+    }
+}
+if (command === "help") {
+    help();
+    process.exit(0);
+}
+if (command === "version") {
+    console.log(packageJson.version);
+    process.exit(0);
+}
+const candidateEnv = envFile ?? resolve(process.cwd(), ".env");
+if (envFile && !existsSync(envFile))
+    throw new Error(`Environment file not found: ${envFile}`);
+if (existsSync(candidateEnv))
+    process.loadEnvFile(candidateEnv);
+function claudeDir() {
+    const configured = process.env.CLAUDE_CONFIG_DIR?.split(",")[0]?.trim();
+    if (!configured)
+        return join(homedir(), ".claude");
+    if (configured === "~")
+        return homedir();
+    if (configured.startsWith("~/") || configured.startsWith("~\\")) {
+        return resolve(homedir(), configured.slice(2));
+    }
+    return resolve(configured);
+}
+function setupInstalled() {
+    try {
+        const config = JSON.parse(readFileSync(join(claudeDir(), "discord-presence", "config.json"), "utf8"));
+        const settings = readFileSync(join(claudeDir(), "settings.json"), "utf8");
+        return config.installerVersion === 1 && /discord-presence[\\/]hook\.mjs/i.test(settings) &&
+            /discord-presence[\\/]statusline\.mjs/i.test(settings);
+    }
+    catch {
+        return false;
+    }
+}
+function runScript(name) {
+    const result = spawnSync(process.execPath, [resolve(projectDir, "scripts", name)], {
+        stdio: "inherit",
+        windowsHide: true,
+        env: process.env,
+    });
+    if (result.status !== 0)
+        process.exit(result.status ?? 1);
+}
+if (command === "setup") {
+    runScript("setup-claude.mjs");
+    process.exit(0);
+}
+if (command === "remote:setup") {
+    runScript("install-remote.mjs");
+    process.exit(0);
+}
+if (command === "autostart") {
+    if (!setupInstalled())
+        runScript("setup-claude.mjs");
+    runScript("install-autostart.mjs");
+    process.exit(0);
+}
+if (command === "autostart:remove") {
+    runScript("remove-autostart.mjs");
+    process.exit(0);
+}
+if (command !== "start")
+    throw new Error(`Unknown command: ${command}`);
+if (!setupInstalled())
+    runScript("setup-claude.mjs");
+await import("./index.js");

package/dist/config.js

@@ -0,0 +1,96 @@
+import { homedir } from "node:os";
+import { posix, win32 } from "node:path";
+import { defaultDesktopSessionsDir } from "./claude/desktop-focus.js";
+const SSH_ALIAS = /^[a-z0-9](?:[a-z0-9._-]{0,252}[a-z0-9])?$/i;
+export const DEFAULT_DISCORD_APPLICATION_ID = "1524135246633894049";
+export function resolveRemoteHosts(value) {
+    if (!value?.trim() || value.trim().toLowerCase() === "off")
+        return [];
+    const hosts = [...new Set(value.split(",").map((host) => host.trim()).filter(Boolean))];
+    const invalid = hosts.find((host) => !SSH_ALIAS.test(host));
+    if (invalid) {
+        throw new Error(`CLAUDE_REMOTE_HOSTS contains an unsafe SSH alias: ${JSON.stringify(invalid)}`);
+    }
+    return hosts;
+}
+function runtimePaths() {
+    return { userHome: homedir(), cwd: process.cwd(), platform: process.platform };
+}
+function readInt(value, fallback) {
+    if (!value?.trim())
+        return fallback;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function optional(value) {
+    const trimmed = value?.trim();
+    if (!trimmed || ["off", "none", "default"].includes(trimmed.toLowerCase()))
+        return undefined;
+    return trimmed;
+}
+function pathApi(runtime) {
+    return runtime.platform === "win32" ? win32 : posix;
+}
+function resolveUserPath(value, runtime) {
+    const paths = pathApi(runtime);
+    const trimmed = value.trim();
+    if (trimmed === "~")
+        return paths.normalize(runtime.userHome);
+    if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
+        return paths.resolve(runtime.userHome, trimmed.slice(2));
+    }
+    return paths.isAbsolute(trimmed) ? paths.normalize(trimmed) : paths.resolve(runtime.cwd, trimmed);
+}
+export function resolvePresenceDataDir(env, runtime) {
+    const paths = pathApi(runtime);
+    const configured = env.CLAUDE_PRESENCE_DATA_DIR?.trim();
+    if (configured)
+        return resolveUserPath(configured, runtime);
+    if (runtime.platform === "win32") {
+        const base = env.LOCALAPPDATA?.trim() || paths.join(runtime.userHome, "AppData", "Local");
+        return paths.join(base, "Claude Code Discord Presence");
+    }
+    if (runtime.platform === "darwin") {
+        return paths.join(runtime.userHome, "Library", "Application Support", "Claude Code Discord Presence");
+    }
+    const state = env.XDG_STATE_HOME?.trim();
+    const base = state
+        ? resolveUserPath(state, runtime)
+        : paths.join(runtime.userHome, ".local", "state");
+    return paths.join(base, "claude-code-discord-presence");
+}
+export function loadConfig(env = process.env, runtime = runtimePaths()) {
+    const paths = pathApi(runtime);
+    const applicationId = (env.CLAUDE_DISCORD_APPLICATION_ID ?? env.DISCORD_APPLICATION_ID)?.trim() ||
+        DEFAULT_DISCORD_APPLICATION_ID;
+    const dataDir = resolvePresenceDataDir(env, runtime);
+    const rawDesktopDir = env.CLAUDE_DESKTOP_SESSIONS_DIR?.trim();
+    const desktopSessionsDir = rawDesktopDir?.toLowerCase() === "off"
+        ? undefined
+        : rawDesktopDir
+            ? resolveUserPath(rawDesktopDir, runtime)
+            : defaultDesktopSessionsDir();
+    const configuredLog = env.RPC_LOG_FILE?.trim();
+    const port = readInt(env.PORT, 41724);
+    return {
+        applicationId,
+        appName: env.CLAUDE_APP_NAME?.trim() || env.APP_NAME?.trim() || "Claude Code",
+        port,
+        largeImageKey: optional(env.CLAUDE_LARGE_IMAGE_KEY ?? env.LARGE_IMAGE_KEY ?? "claude_code"),
+        largeImageKeyLight: optional(env.CLAUDE_LARGE_IMAGE_KEY_LIGHT ?? env.LARGE_IMAGE_KEY_LIGHT ?? "claude-liquid-light"),
+        largeImageKeyDark: optional(env.CLAUDE_LARGE_IMAGE_KEY_DARK ?? env.LARGE_IMAGE_KEY_DARK ?? "claude-liquid-dark"),
+        largeImageUrl: optional(env.CLAUDE_LARGE_IMAGE_URL ?? env.LARGE_IMAGE_URL),
+        smallImageKey: optional(env.CLAUDE_SMALL_IMAGE_KEY ?? env.SMALL_IMAGE_KEY ?? "claude-usage-stats"),
+        smallImageKeyLight: optional(env.CLAUDE_SMALL_IMAGE_KEY_LIGHT ?? env.SMALL_IMAGE_KEY_LIGHT ?? "claude-stats-light"),
+        smallImageKeyDark: optional(env.CLAUDE_SMALL_IMAGE_KEY_DARK ?? env.SMALL_IMAGE_KEY_DARK ?? "claude-stats-dark"),
+        smallImageUrl: optional(env.CLAUDE_SMALL_IMAGE_URL ?? env.SMALL_IMAGE_URL),
+        usagePollIntervalMs: readInt(env.USAGE_POLL_INTERVAL_S, 300) * 1000,
+        desktopSessionsDir,
+        dataDir,
+        logFile: configuredLog
+            ? resolveUserPath(configuredLog, runtime)
+            : paths.join(dataDir, "claude-code-discord-presence.log"),
+        remoteHosts: resolveRemoteHosts(env.CLAUDE_REMOTE_HOSTS),
+        remotePort: readInt(env.CLAUDE_REMOTE_PORT, port),
+    };
+}