claude-code-discord-presence 1.0.0

package/dist/discord/presence-builder.js

@@ -0,0 +1,295 @@
+const MIN = 2;
+const MAX = 128;
+const SEP = " • ";
+const MODEL_NAMES = {
+    "claude-fable-5": "Fable 5",
+    "claude-opus-4-8": "Opus 4.8",
+    "claude-opus-4-7": "Opus 4.7",
+    "claude-sonnet-5": "Sonnet 5",
+    "claude-haiku-4-5": "Haiku 4.5",
+};
+const EFFORT_LABELS = {
+    minimal: "Minimal",
+    low: "Light",
+    medium: "Medium",
+    high: "High",
+    xhigh: "Extra High",
+    max: "Max",
+    ultra: "Ultra",
+};
+export function effortLabel(level) {
+    return EFFORT_LABELS[level];
+}
+export function modelDisplayName(id, fallback) {
+    if (id && MODEL_NAMES[id])
+        return MODEL_NAMES[id];
+    if (fallback && fallback.trim() !== "")
+        return fallback;
+    if (id && id.trim() !== "")
+        return id;
+    return "Claude";
+}
+function pctLeft(usedPercentage) {
+    const left = Math.round(100 - usedPercentage);
+    return Math.max(0, Math.min(100, left));
+}
+export function formatGoalDuration(elapsedSeconds) {
+    const totalMinutes = Math.max(0, Math.floor((elapsedSeconds ?? 0) / 60));
+    const days = Math.floor(totalMinutes / (24 * 60));
+    const hours = Math.floor((totalMinutes % (24 * 60)) / 60);
+    const minutes = totalMinutes % 60;
+    if (days > 0)
+        return `${days}d ${hours}h ${minutes}m`;
+    if (hours > 0)
+        return `${hours}h ${minutes}m`;
+    return `${minutes}m`;
+}
+function goalChip(state) {
+    return state.goalActive ? `Goal active (${formatGoalDuration(state.goalElapsedSeconds)})` : undefined;
+}
+export function clamp(text) {
+    let out = text;
+    if (byteLength(out) > MAX)
+        out = fitBytes(out, MAX, true);
+    if (out.length < MIN)
+        out = (out + "  ").slice(0, MIN);
+    return out;
+}
+function byteLength(text) {
+    return new TextEncoder().encode(text).length;
+}
+function fitBytes(text, maxBytes, ellipsis) {
+    const suffix = ellipsis ? "…" : "";
+    const suffixBytes = byteLength(suffix);
+    if (maxBytes <= suffixBytes)
+        return suffix.slice(0, maxBytes);
+    let fitted = text;
+    while (fitted !== "" && byteLength(fitted) + suffixBytes > maxBytes)
+        fitted = fitted.slice(0, -1);
+    return fitted.trimEnd() + suffix;
+}
+export function formatResetCountdown(resetsAt, now = Date.now()) {
+    if (resetsAt === undefined || !Number.isFinite(resetsAt) || resetsAt <= now)
+        return undefined;
+    const totalMinutes = Math.max(1, Math.ceil((resetsAt - now) / 60_000));
+    const days = Math.floor(totalMinutes / (24 * 60));
+    const hours = Math.floor((totalMinutes % (24 * 60)) / 60);
+    const minutes = totalMinutes % 60;
+    if (days > 0)
+        return `${days}d${hours > 0 ? ` ${hours}h` : ""}`;
+    if (hours > 0)
+        return `${hours}h${minutes > 0 ? ` ${minutes}m` : ""}`;
+    return `${minutes}m`;
+}
+function limitText(label, usedPercentage, resetsAt, options) {
+    let text = `${label} ${pctLeft(usedPercentage)}% left`;
+    if (!options.showResetCountdowns)
+        return text;
+    const countdown = formatResetCountdown(resetsAt, options.now);
+    if (countdown)
+        text += ` (resets in ${countdown})`;
+    return text;
+}
+export function buildDetails(state, options = {}) {
+    const segments = [];
+    if (state.planName.trim() !== "")
+        segments.push(state.planName);
+    if (state.resetCreditsAvailable !== undefined && state.resetCreditsAvailable > 0) {
+        const noun = state.resetCreditsAvailable === 1 ? "reset" : "resets";
+        segments.push(`${state.resetCreditsAvailable} ${noun} left`);
+    }
+    const five = state.limits?.fiveHour;
+    const seven = state.limits?.sevenDay;
+    const scoped = state.limits?.sevenDayScoped;
+    if (five) {
+        segments.push(limitText("5h", five.usedPercentage, five.resetsAt, options));
+    }
+    const scopedText = scoped
+        ?.map((s) => `${s.label} ${pctLeft(s.usedPercentage)}% left`)
+        .join(", ");
+    if (seven) {
+        let sevenText = limitText("7d", seven.usedPercentage, seven.resetsAt, options);
+        if (scopedText)
+            sevenText += ` (${scopedText})`;
+        segments.push(sevenText);
+    }
+    else if (scopedText) {
+        segments.push(`7d ${scopedText}`);
+    }
+    return clamp(segments.join(SEP));
+}
+function tailChips(state) {
+    const chips = [];
+    const goal = goalChip(state);
+    if (goal)
+        chips.push(goal);
+    if (state.planMode)
+        chips.push("Plan mode");
+    if (state.agentsRunning > 0) {
+        const noun = state.agentsRunning === 1 ? "agent" : "agents";
+        let chip = `${state.agentsRunning} ${noun} running`;
+        if (state.agentsIdle > 0)
+            chip += ` (${state.agentsIdle} idle)`;
+        chips.push(chip);
+    }
+    if (state.realtime)
+        chips.push("Realtime");
+    if (state.remote)
+        chips.push("Remote");
+    return chips.join(SEP);
+}
+function requiredTailChips(state) {
+    const chips = [];
+    const goal = goalChip(state);
+    if (goal)
+        chips.push(goal);
+    return chips.join(SEP);
+}
+export function buildStateLine(state) {
+    const effort = state.effort ? ` (${effortLabel(state.effort)})` : "";
+    const fast = state.fastMode ? " Fast" : "";
+    const head = state.model ? `${state.model.displayName}${effort}${fast}` : state.fastMode ? "Fast" : "";
+    const action = state.status === "thinking" && state.thinkingSeconds !== undefined
+        ? `Thinking (${Math.max(0, Math.floor(state.thinkingSeconds))}s)`
+        : state.action.trim();
+    const tail = tailChips(state);
+    const priority = [head, action, tail].filter((s) => s !== "");
+    if (priority.length === 0)
+        return clamp("Claude Code");
+    let line = priority.join(SEP);
+    if (byteLength(line) <= MAX)
+        return clamp(line);
+    const requiredTail = requiredTailChips(state);
+    if (requiredTail !== "") {
+        const fixedLength = byteLength([head, requiredTail].filter((s) => s !== "").join(SEP));
+        const actionBudget = MAX - fixedLength - (action !== "" ? byteLength(SEP) : 0);
+        const fittedAction = actionBudget <= 0
+            ? ""
+            : byteLength(action) > actionBudget
+                ? fitBytes(action, actionBudget, true)
+                : action;
+        return clamp([head, fittedAction, requiredTail].filter((s) => s !== "").join(SEP));
+    }
+    const headOnly = head !== "" ? head : action;
+    const withAction = [head, action].filter((s) => s !== "").join(SEP);
+    if (byteLength(withAction) <= MAX)
+        return clamp(withAction);
+    return clamp(headOnly);
+}
+export function formatTokens(n) {
+    if (n >= 1_000_000_000_000)
+        return `${(n / 1_000_000_000_000).toFixed(1).replace(/\.0$/, "")}T`;
+    if (n >= 1_000_000_000)
+        return `${(n / 1_000_000_000).toFixed(1).replace(/\.0$/, "")}B`;
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1).replace(/\.0$/, "")}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1).replace(/\.0$/, "")}K`;
+    return String(Math.round(n));
+}
+export function formatCost(usd) {
+    if (usd >= 0.1)
+        return `$${usd.toFixed(2)}`;
+    if (usd >= 0.01)
+        return `$${usd.toFixed(3)}`;
+    return `$${usd.toFixed(4)}`;
+}
+export function formatMonthlyUsage(state) {
+    const monthly = state.monthlyUsage;
+    if (!monthly || (monthly.totalTokens <= 0 && monthly.costUsd <= 0))
+        return undefined;
+    if (!monthly.day || !monthly.week || !monthly.allTime) {
+        return `Month\u00a0$${formatMonthlyCost(monthly.costUsd)}·${formatTokens(monthly.totalTokens)}\u00a0tok`;
+    }
+    const period = (label, usage) => `${label}\u00a0$${formatMonthlyCost(usage.costUsd)}·${formatTokens(usage.totalTokens)}\u00a0tok`;
+    return clampBytes([
+        period("Day", monthly.day),
+        period("Week", monthly.week),
+        period("Month", monthly),
+        period("Total", monthly.allTime),
+    ].join("\n"), MAX);
+}
+function formatMonthlyCost(costUsd) {
+    if (costUsd < 10)
+        return costUsd.toFixed(2);
+    if (costUsd < 100)
+        return costUsd.toFixed(1).replace(/\.0$/, "");
+    if (Math.round(costUsd) < 1_000)
+        return String(Math.round(costUsd));
+    return `${(costUsd / 1_000).toFixed(2).replace(/\.00$/, "").replace(/(\.\d)0$/, "$1")}K`;
+}
+function clampBytes(text, maxBytes) {
+    const encoder = new TextEncoder();
+    if (encoder.encode(text).length <= maxBytes)
+        return text;
+    let out = text;
+    while (out.length > 0 && encoder.encode(out).length > maxBytes)
+        out = out.slice(0, -1);
+    return out;
+}
+export function buildHoverText(state, appName) {
+    const usage = state.usage;
+    if (!usage)
+        return appName;
+    const cost = state.costBreakdown;
+    const seg = (label, tokens, price) => price !== undefined ? `${label} ${formatTokens(tokens)} ${formatCost(price)}` : `${label} ${formatTokens(tokens)}`;
+    const parts = [seg("In", usage.input, cost?.input), seg("Out", usage.output, cost?.output)];
+    if (usage.cacheRead > 0)
+        parts.push(seg("Cache R", usage.cacheRead, cost?.cacheRead));
+    if (usage.cacheWrite > 0)
+        parts.push(seg("Cache W", usage.cacheWrite, cost?.cacheWrite));
+    if (cost)
+        parts.push(`Total ${formatCost(cost.total)}`);
+    const encoder = new TextEncoder();
+    while (parts.length > 1 && encoder.encode(parts.join(SEP)).length > 128)
+        parts.pop();
+    return clampBytes(parts.join(SEP), 128);
+}
+export function buildActivity(state, assets) {
+    const activity = {
+        type: 0,
+        name: assets.appName,
+        details: buildDetails(state),
+        state: buildStateLine(state),
+    };
+    const hover = buildHoverText(state, assets.appName);
+    if (assets.largeImageKey) {
+        activity.largeImageKey = assets.largeImageKey;
+        activity.largeImageText = hover;
+    }
+    else if (assets.largeImageUrl) {
+        activity.largeImageUrl = assets.largeImageUrl;
+        activity.largeImageText = hover;
+    }
+    const monthlyHover = formatMonthlyUsage(state);
+    if (monthlyHover && assets.smallImageKey) {
+        activity.smallImageKey = assets.smallImageKey;
+        activity.smallImageText = monthlyHover;
+    }
+    else if (monthlyHover && assets.smallImageUrl) {
+        activity.smallImageUrl = assets.smallImageUrl;
+        activity.smallImageText = monthlyHover;
+    }
+    if (state.startTimestamp)
+        activity.startTimestamp = state.startTimestamp;
+    return activity;
+}
+export function activityEquals(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    return (a.type === b.type &&
+        a.name === b.name &&
+        a.statusDisplayType === b.statusDisplayType &&
+        a.details === b.details &&
+        a.state === b.state &&
+        a.largeImageKey === b.largeImageKey &&
+        a.largeImageUrl === b.largeImageUrl &&
+        a.largeImageText === b.largeImageText &&
+        a.smallImageKey === b.smallImageKey &&
+        a.smallImageUrl === b.smallImageUrl &&
+        a.smallImageText === b.smallImageText &&
+        a.startTimestamp === b.startTimestamp &&
+        a.endTimestamp === b.endTimestamp);
+}

package/dist/discord/rpc-client.js

@@ -0,0 +1,224 @@
+import { Client } from "@xhayper/discord-rpc";
+import { activityEquals } from "./presence-builder.js";
+import { createLogger } from "../util/logger.js";
+const log = createLogger("rpc");
+const MIN_INTERVAL_MS = 2_000;
+const REFRESH_INTERVAL_MS = 60_000;
+const LOGIN_TIMEOUT_MS = 15_000;
+const BACKOFFS_MS = [10_000, 30_000, 60_000];
+function withTimeout(promise, ms) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`login timed out after ${ms}ms`)), ms);
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
+export class RpcClient {
+    factory;
+    injected;
+    client;
+    ready = false;
+    stopped = false;
+    connecting = false;
+    desired = null;
+    desiredPid = process.pid;
+    lastSent;
+    lastSentPid;
+    lastSendAt = 0;
+    sending = false;
+    flushTimer;
+    refreshTimer;
+    reconnectTimer;
+    reconnectAttempt = 0;
+    connectionGeneration = 0;
+    constructor(applicationId, transport) {
+        if (typeof transport === "function") {
+            this.factory = transport;
+        }
+        else if (transport) {
+            this.injected = transport;
+            this.factory = () => transport;
+        }
+        else {
+            this.factory = () => new Client({ clientId: applicationId });
+        }
+        if (this.injected)
+            this.acquireClient();
+    }
+    start() {
+        this.stopped = false;
+        if (!this.refreshTimer) {
+            this.refreshTimer = setInterval(() => this.refresh(), REFRESH_INTERVAL_MS);
+        }
+        void this.connect();
+    }
+    async stop() {
+        this.stopped = true;
+        if (this.flushTimer)
+            clearTimeout(this.flushTimer);
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        if (this.refreshTimer)
+            clearInterval(this.refreshTimer);
+        this.flushTimer = undefined;
+        this.reconnectTimer = undefined;
+        this.refreshTimer = undefined;
+        const client = this.client;
+        if (!client)
+            return;
+        if (this.ready) {
+            await client.request("SET_ACTIVITY", { pid: this.desiredPid }).catch(() => undefined);
+        }
+        this.ready = false;
+        await client.destroy().catch(() => undefined);
+    }
+    acquireClient() {
+        const previous = this.client;
+        const next = this.factory();
+        if (previous === next)
+            return next;
+        if (previous && !this.injected)
+            void previous.destroy().catch(() => undefined);
+        this.client = next;
+        next.on("ready", () => {
+            if (this.client !== next)
+                return;
+            this.connectionGeneration++;
+            this.ready = true;
+            this.lastSent = undefined;
+            this.lastSentPid = undefined;
+            this.lastSendAt = 0;
+            this.reconnectAttempt = 0;
+            log.info("connected to Discord");
+            this.flush();
+        });
+        next.on("disconnected", () => {
+            if (this.client !== next)
+                return;
+            this.connectionGeneration++;
+            this.ready = false;
+            log.warn("disconnected from Discord");
+            this.scheduleReconnect();
+        });
+        return next;
+    }
+    async connect() {
+        if (this.stopped || this.connecting || this.ready)
+            return;
+        this.connecting = true;
+        try {
+            const client = this.acquireClient();
+            await withTimeout(Promise.resolve(client.login()), LOGIN_TIMEOUT_MS);
+        }
+        catch (err) {
+            this.ready = false;
+            const message = err.message;
+            log.warn(`connect failed (${message}); Discord may be closed`);
+            if (!this.injected && this.client) {
+                const stale = this.client;
+                this.client = undefined;
+                void stale.destroy().catch(() => undefined);
+            }
+            this.scheduleReconnect();
+        }
+        finally {
+            this.connecting = false;
+        }
+    }
+    scheduleReconnect() {
+        if (this.stopped || this.reconnectTimer)
+            return;
+        const delay = BACKOFFS_MS[Math.min(this.reconnectAttempt, BACKOFFS_MS.length - 1)];
+        this.reconnectAttempt++;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = undefined;
+            void this.connect();
+        }, delay);
+    }
+    setActivity(activity, pid) {
+        this.desired = activity;
+        if (pid !== undefined && Number.isInteger(pid) && pid > 0) {
+            this.desiredPid = pid;
+        }
+        else if (activity !== null) {
+            this.desiredPid = process.pid;
+        }
+        this.scheduleFlush();
+    }
+    refresh() {
+        if (this.stopped || !this.ready || this.desired === null)
+            return;
+        if (Date.now() - this.lastSendAt < REFRESH_INTERVAL_MS)
+            return;
+        this.lastSent = undefined;
+        this.flush();
+    }
+    scheduleFlush() {
+        const wait = Math.max(0, MIN_INTERVAL_MS - (Date.now() - this.lastSendAt));
+        if (wait === 0) {
+            this.flush();
+        }
+        else if (!this.flushTimer) {
+            this.flushTimer = setTimeout(() => {
+                this.flushTimer = undefined;
+                this.flush();
+            }, wait);
+        }
+    }
+    flush() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = undefined;
+        }
+        if (!this.ready || this.sending)
+            return;
+        const user = this.client?.user;
+        if (!user)
+            return;
+        const desired = this.desired;
+        const pid = this.desiredPid;
+        if (desired === null) {
+            if (this.lastSent === null && this.lastSentPid === pid)
+                return;
+            void this.send(desired, pid);
+            return;
+        }
+        if (this.lastSentPid === pid && this.lastSent !== null && activityEquals(desired, this.lastSent))
+            return;
+        void this.send(desired, pid);
+    }
+    async send(activity, pid) {
+        const client = this.client;
+        const user = client?.user;
+        if (!client || !user || !this.ready || this.stopped)
+            return;
+        this.sending = true;
+        const generation = this.connectionGeneration;
+        this.lastSendAt = Date.now();
+        try {
+            if (activity === null) {
+                await client.request("SET_ACTIVITY", { pid });
+            }
+            else {
+                await user.setActivity(activity, pid);
+            }
+            if (generation === this.connectionGeneration) {
+                this.lastSent = activity;
+                this.lastSentPid = pid;
+            }
+        }
+        catch (err) {
+            log.warn(`${activity === null ? "clearActivity" : "setActivity"} failed: ${err.message}`);
+        }
+        finally {
+            this.sending = false;
+            if (!this.stopped)
+                this.scheduleFlush();
+        }
+    }
+}

package/dist/index.js

@@ -0,0 +1,160 @@
+import { mkdirSync } from "node:fs";
+import { loadConfig } from "./config.js";
+import { startServer } from "./server/http-server.js";
+import { SessionStore } from "./claude/session-store.js";
+import { DesktopFocusWatcher } from "./claude/desktop-focus.js";
+import { ClaudeDefaultSelectionWatcher } from "./claude/default-selection.js";
+import { ClaudeAppLiveness } from "./claude/app-liveness.js";
+import { UsagePoller } from "./claude/usage-poller.js";
+import { ClaudeMonthlyUsageWatcher } from "./claude/monthly-usage.js";
+import { getDefaultEffort, getPlanName } from "./claude/plan-info.js";
+import { loadPricingOverrides } from "./claude/cost.js";
+import { buildActivity } from "./discord/presence-builder.js";
+import { RpcClient } from "./discord/rpc-client.js";
+import { CLAUDE_WINDOWS_PROCESS_RULES, ProcessLiveness, } from "./util/process-liveness.js";
+import { ProcessRuleTracker, WindowsProcessScanWatcher } from "./util/process-scan-watcher.js";
+import { configureLogger, createLogger } from "./util/logger.js";
+import { activityAssetsForTheme } from "./appearance/theme-assets.js";
+import { AppearanceThemeWatcher } from "./appearance/theme-watcher.js";
+import { RemoteTunnelManager } from "./remote/tunnel-manager.js";
+const config = loadConfig();
+mkdirSync(config.dataDir, { recursive: true });
+configureLogger(config.logFile);
+const log = createLogger("main");
+process.on("uncaughtException", (err) => {
+    log.error(`uncaught exception: ${err.stack ?? err.message}`);
+    process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+    log.error(`unhandled rejection: ${reason instanceof Error ? reason.stack ?? reason.message : String(reason)}`);
+});
+if (loadPricingOverrides())
+    log.info("loaded pricing overrides");
+const assets = {
+    appName: config.appName,
+    largeImageKey: config.largeImageKey,
+    largeImageKeyLight: config.largeImageKeyLight,
+    largeImageKeyDark: config.largeImageKeyDark,
+    largeImageUrl: config.largeImageUrl,
+    smallImageKey: config.smallImageKey,
+    smallImageKeyLight: config.smallImageKeyLight,
+    smallImageKeyDark: config.smallImageKeyDark,
+    smallImageUrl: config.smallImageUrl,
+};
+const rpc = new RpcClient(config.applicationId);
+let theme = "light";
+let trackedPid;
+let desired = null;
+function coalesce(fn) {
+    let queued = false;
+    return () => {
+        if (queued)
+            return;
+        queued = true;
+        queueMicrotask(() => {
+            queued = false;
+            fn();
+        });
+    };
+}
+function updateActivity() {
+    const snapshot = store.snapshot();
+    desired = snapshot ? buildActivity(snapshot, activityAssetsForTheme(assets, theme)) : null;
+    rpc.setActivity(desired, trackedPid);
+}
+const store = new SessionStore(coalesce(updateActivity));
+const livenessSources = new Map();
+function updateLivenessSource(source, alive, startedAt, pid) {
+    livenessSources.set(source, { alive, startedAt, pid });
+    const live = [...livenessSources.values()].filter((state) => state.alive);
+    const earliest = live.reduce((current, state) => {
+        if (!current)
+            return state;
+        if (state.startedAt === undefined)
+            return current;
+        if (current.startedAt === undefined || state.startedAt < current.startedAt)
+            return state;
+        return current;
+    }, undefined);
+    const aliveNow = live.length > 0;
+    trackedPid = aliveNow ? earliest?.pid ?? live.find((state) => state.pid)?.pid : undefined;
+    store.setAppLiveness(aliveNow, earliest?.startedAt);
+    if (desired)
+        rpc.setActivity(desired, trackedPid);
+}
+const processScan = process.platform === "win32"
+    ? (() => {
+        const tracker = new ProcessRuleTracker("claude", CLAUDE_WINDOWS_PROCESS_RULES, (alive, startedAt, pid) => updateLivenessSource("process", alive, startedAt, pid));
+        return new WindowsProcessScanWatcher("^claude$", (processes) => tracker.update(processes));
+    })()
+    : undefined;
+const sessionLiveness = process.platform === "win32"
+    ? undefined
+    : new ClaudeAppLiveness((alive, startedAt, pid) => updateLivenessSource("session", alive, startedAt, pid));
+const processLiveness = process.platform === "win32"
+    ? undefined
+    : new ProcessLiveness(/^claude$/i, (alive, startedAt, pid) => updateLivenessSource("process", alive, startedAt, pid));
+const desktopFocus = config.desktopSessionsDir
+    ? new DesktopFocusWatcher(config.desktopSessionsDir, (focus) => store.setDesktopFocus(focus.cliSessionId, focus))
+    : undefined;
+const defaultSelection = new ClaudeDefaultSelectionWatcher({}, (selection) => {
+    store.setDefaultModel(selection.model);
+    store.setDefaultEffort(selection.effort);
+});
+const poller = new UsagePoller(config.usagePollIntervalMs, (limits) => store.setUsageLimits(limits));
+const monthlyUsage = new ClaudeMonthlyUsageWatcher((usage) => store.setMonthlyUsage(false, usage));
+const themeWatcher = new AppearanceThemeWatcher({}, (themes) => {
+    theme = themes.claude;
+    updateActivity();
+});
+const server = startServer(config.port, {
+    onHook: (payload) => store.handleHook(payload),
+    onStatusline: (payload) => store.handleStatusline(payload),
+});
+const remoteTunnels = new RemoteTunnelManager(config.remoteHosts, config.port, config.remotePort);
+async function refreshPlan() {
+    try {
+        store.setPlanName(await getPlanName());
+        store.setDefaultEffort(await getDefaultEffort());
+    }
+    catch (err) {
+        log.warn(`plan refresh failed: ${err.message}`);
+    }
+}
+rpc.start();
+themeWatcher.start();
+poller.start();
+if (desktopFocus)
+    void desktopFocus.start();
+defaultSelection.start();
+processScan?.start();
+sessionLiveness?.start();
+processLiveness?.start();
+monthlyUsage.start();
+remoteTunnels.start();
+void refreshPlan();
+const planTimer = setInterval(() => void refreshPlan(), 30 * 60 * 1000);
+let shuttingDown = false;
+async function shutdown(signal) {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    log.info(`shutting down (${signal})`);
+    clearInterval(planTimer);
+    themeWatcher.stop();
+    poller.stop();
+    desktopFocus?.stop();
+    defaultSelection.stop();
+    processScan?.stop();
+    sessionLiveness?.stop();
+    processLiveness?.stop();
+    monthlyUsage.stop();
+    remoteTunnels.stop();
+    store.dispose();
+    await new Promise((resolve) => server.close(() => resolve()));
+    await rpc.stop();
+    process.exit(0);
+}
+process.on("SIGINT", () => void shutdown("SIGINT"));
+process.on("SIGTERM", () => void shutdown("SIGTERM"));
+log.info("Claude Code Discord Presence started");