claude-code-discord-presence 1.0.0

package/dist/claude/session-store.js

@@ -0,0 +1,617 @@
+import { limitsFromStatusline, mergeLimits } from "./limits.js";
+import { toolLabel } from "./tool-labels.js";
+import { readModelFromTranscript, readSessionStats, findTranscriptPath } from "./transcript.js";
+import { costBreakdown, costForUsageByModel } from "./cost.js";
+import { modelDisplayName } from "../discord/presence-builder.js";
+const IDLE_MS = 10 * 60 * 1000;
+const APP_CLOSE_GRACE_MS = 45_000;
+const EFFORT_LEVELS = new Set([
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+    "ultra",
+]);
+function effortOf(raw) {
+    return typeof raw === "string" && EFFORT_LEVELS.has(raw) ? raw : undefined;
+}
+function numeric(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function isRemoteTranscript(path, explicit) {
+    return explicit === true || (process.platform === "win32" && path.startsWith("/"));
+}
+function modelOf(raw, displayName) {
+    if (typeof raw === "string" && raw.trim() !== "") {
+        return { id: raw, displayName: modelDisplayName(raw, displayName) };
+    }
+    if (raw && typeof raw === "object") {
+        const obj = raw;
+        const id = typeof obj.id === "string" ? obj.id : "";
+        const dn = typeof obj.display_name === "string" ? obj.display_name : displayName;
+        if (id || dn)
+            return { id, displayName: modelDisplayName(id || undefined, dn) };
+    }
+    if (displayName)
+        return { id: "", displayName };
+    return undefined;
+}
+function actionForStatus(status, working, agentsRunning) {
+    switch (status) {
+        case "new":
+            return "Waiting for a prompt";
+        case "thinking":
+            return "Thinking";
+        case "idle":
+            return agentsRunning ? "Waiting for agents" : "Idle";
+        case "waiting":
+            return "Waiting for input";
+        case "working":
+            return working;
+    }
+}
+export class SessionStore {
+    onChange;
+    sessions = new Map();
+    activeId;
+    planName = "Claude";
+    usageLimits;
+    localMonthlyUsage;
+    remoteMonthlyUsage;
+    defaultEffort;
+    defaultModel;
+    activeSince;
+    appAlive = false;
+    appLivenessKnown = false;
+    appStartedAt;
+    cleared = false;
+    pendingFocus;
+    focusDebounceMs;
+    appCloseGraceMs;
+    idleTimer;
+    modelTimer;
+    constructor(onChange, options = {}) {
+        this.onChange = onChange;
+        this.focusDebounceMs = options.focusDebounceMs ?? 600;
+        this.appCloseGraceMs = options.appCloseGraceMs ?? APP_CLOSE_GRACE_MS;
+        this.idleTimer = setInterval(() => this.checkIdle(), 5_000);
+        this.modelTimer = setInterval(() => void this.pollActiveModel(), options.modelPollIntervalMs ?? 2_000);
+    }
+    dispose() {
+        clearInterval(this.idleTimer);
+        clearInterval(this.modelTimer);
+        this.clearPendingFocus();
+    }
+    setPlanName(name) {
+        if (name === this.planName)
+            return;
+        this.planName = name;
+        this.onChange();
+    }
+    setUsageLimits(limits) {
+        this.usageLimits = limits;
+        this.onChange();
+    }
+    setMonthlyUsage(remote, usage) {
+        const current = remote ? this.remoteMonthlyUsage : this.localMonthlyUsage;
+        if (current?.totalTokens === usage.totalTokens &&
+            Math.abs((current?.costUsd ?? 0) - usage.costUsd) < 1e-9) {
+            return;
+        }
+        if (remote)
+            this.remoteMonthlyUsage = usage;
+        else
+            this.localMonthlyUsage = usage;
+        this.onChange();
+    }
+    setDefaultEffort(effort) {
+        if (effort === this.defaultEffort)
+            return;
+        this.defaultEffort = effort;
+        this.onChange();
+    }
+    setDefaultModel(model) {
+        const parsed = modelOf(model);
+        if (parsed?.id === this.defaultModel?.id && parsed?.displayName === this.defaultModel?.displayName)
+            return;
+        this.defaultModel = parsed;
+        this.onChange();
+    }
+    setAppLiveness(alive, startedAt) {
+        const firstReport = !this.appLivenessKnown;
+        this.appLivenessKnown = true;
+        if (!firstReport && alive === this.appAlive && startedAt === this.appStartedAt)
+            return;
+        this.appAlive = alive;
+        this.appStartedAt = alive ? startedAt : undefined;
+        this.cleared = false;
+        this.onChange();
+    }
+    hidden(session, now) {
+        if (this.appAlive)
+            return false;
+        const age = now - session.lastActivity;
+        if (session.remote)
+            return age > IDLE_MS;
+        return this.appLivenessKnown || age > this.appCloseGraceMs;
+    }
+    ensure(sessionId) {
+        let session = this.sessions.get(sessionId);
+        if (!session) {
+            const now = Date.now();
+            session = {
+                sessionId,
+                startTimestamp: now,
+                lastActivity: now,
+                lastInteractionAt: 0,
+                modelUpdatedAt: 0,
+                runtimeModelAt: 0,
+                runtimeModelFloorAt: 0,
+                desktopModelKnown: false,
+                desktopEffortKnown: false,
+                hasHookActivity: false,
+                status: "idle",
+                action: "Idle",
+                agents: new Set(),
+                idleAgents: 0,
+                lastTranscriptLocateAt: 0,
+                lastModelReadAt: 0,
+                lastStatsReadAt: 0,
+            };
+            this.sessions.set(sessionId, session);
+        }
+        return session;
+    }
+    touch(session) {
+        session.lastActivity = Date.now();
+        this.cleared = false;
+        if (!this.activeId || !this.sessions.has(this.activeId))
+            this.activeId = session.sessionId;
+    }
+    focus(session) {
+        session.lastInteractionAt = Date.now();
+        this.activeId = session.sessionId;
+        this.cleared = false;
+    }
+    scheduleFocus(session) {
+        this.clearPendingFocus();
+        if (this.focusDebounceMs <= 0) {
+            this.focus(session);
+            return;
+        }
+        const id = session.sessionId;
+        this.pendingFocus = {
+            sessionId: id,
+            timer: setTimeout(() => {
+                this.pendingFocus = undefined;
+                const target = this.sessions.get(id);
+                if (target) {
+                    this.focus(target);
+                    this.onChange();
+                }
+            }, this.focusDebounceMs),
+        };
+    }
+    clearPendingFocus(sessionId) {
+        if (!this.pendingFocus)
+            return;
+        if (sessionId !== undefined && this.pendingFocus.sessionId !== sessionId)
+            return;
+        clearTimeout(this.pendingFocus.timer);
+        this.pendingFocus = undefined;
+    }
+    applySelectedModel(session, model, updatedAt = Date.now()) {
+        if (!model)
+            return;
+        const changed = session.model?.id !== model.id || session.model?.displayName !== model.displayName;
+        const hadSelectedModel = session.model !== undefined;
+        session.model = model;
+        if (changed) {
+            session.modelUpdatedAt = Math.max(session.modelUpdatedAt, updatedAt);
+            if (hadSelectedModel) {
+                session.runtimeModel = undefined;
+                session.runtimeModelAt = 0;
+                session.runtimeModelFloorAt = Math.max(session.runtimeModelFloorAt, updatedAt);
+            }
+        }
+    }
+    applyRuntimeModel(session, model, updatedAt, event) {
+        if (!model || updatedAt < session.runtimeModelFloorAt || (event && event === session.runtimeModelEvent))
+            return;
+        session.runtimeModel = model;
+        session.runtimeModelAt = updatedAt;
+        session.runtimeModelEvent = event;
+    }
+    effectiveModel(session) {
+        return session.runtimeModel ?? session.model;
+    }
+    beginTurn(session) {
+        const now = Date.now();
+        session.runtimeModel = undefined;
+        session.runtimeModelAt = 0;
+        session.runtimeModelFloorAt = Math.max(session.runtimeModelFloorAt, now);
+    }
+    handleHook(payload) {
+        const sessionId = payload.session_id;
+        if (!sessionId)
+            return;
+        const event = payload.hook_event_name ?? "";
+        const agentId = typeof payload.agent_id === "string" && payload.agent_id !== "" ? payload.agent_id : undefined;
+        const fromAgent = agentId !== undefined;
+        const session = this.ensure(sessionId);
+        const firstHook = !session.hasHookActivity;
+        session.hasHookActivity = true;
+        this.touch(session);
+        const wasThinking = session.status === "thinking";
+        if (typeof payload.permission_mode === "string")
+            session.permissionMode = payload.permission_mode;
+        if (typeof payload.transcript_path === "string") {
+            const remote = isRemoteTranscript(payload.transcript_path, payload.remote);
+            session.remote = remote;
+            if (!remote)
+                session.transcriptPath = payload.transcript_path;
+        }
+        if (!fromAgent) {
+            const effort = effortOf(payload.effort?.level);
+            if (effort && (firstHook || !session.desktopEffortKnown))
+                session.effort = effort;
+            const model = modelOf(payload.model);
+            if (firstHook || !session.desktopModelKnown)
+                this.applySelectedModel(session, model);
+        }
+        else if (!this.effectiveModel(session)) {
+            this.applySelectedModel(session, modelOf(payload.model));
+        }
+        if (payload.usage)
+            this.applyUsage(session, payload.usage, payload.usage_by_model);
+        switch (event) {
+            case "SessionStart":
+                session.status = "new";
+                session.action = "Waiting for a prompt";
+                this.scheduleFocus(session);
+                break;
+            case "UserPromptSubmit":
+                this.beginTurn(session);
+                session.status = "thinking";
+                session.action = "Thinking";
+                this.clearPendingFocus();
+                this.focus(session);
+                break;
+            case "PreToolUse":
+                if (fromAgent) {
+                    session.agents.add(agentId);
+                    break;
+                }
+                session.status = "working";
+                session.action = toolLabel(payload.tool_name, payload.tool_input);
+                break;
+            case "PostToolUse":
+                break;
+            case "Stop":
+                session.status = "idle";
+                session.action = "Idle";
+                break;
+            case "SubagentStart":
+                if (payload.agent_id)
+                    session.agents.add(payload.agent_id);
+                break;
+            case "SubagentStop":
+                if (payload.agent_id)
+                    session.agents.delete(payload.agent_id);
+                if (session.idleAgents > session.agents.size)
+                    session.idleAgents = session.agents.size;
+                break;
+            case "Notification":
+                this.handleNotification(session, payload.notification_type);
+                break;
+            case "SessionEnd":
+                this.clearPendingFocus(sessionId);
+                this.sessions.delete(sessionId);
+                if (this.activeId === sessionId)
+                    this.activeId = this.mostRecentId();
+                break;
+            default:
+                break;
+        }
+        if (session.status === "thinking") {
+            if (!wasThinking || session.thinkingStartedAt === undefined)
+                session.thinkingStartedAt = Date.now();
+        }
+        else {
+            delete session.thinkingStartedAt;
+        }
+        const turnBoundary = event === "SessionStart" || event === "UserPromptSubmit";
+        if (!session.transcriptPath && turnBoundary) {
+            void this.locateAndRefresh(session);
+        }
+        else if (session.transcriptPath) {
+            if (!this.effectiveModel(session) || turnBoundary)
+                void this.refreshModelFromTranscript(session);
+            const statsEvent = event === "Stop" || event === "UserPromptSubmit" || event === "PostToolUse" || event === "SessionStart";
+            if (statsEvent && !fromAgent) {
+                void this.refreshStatsFromTranscript(session, event === "Stop" || event === "SessionStart");
+            }
+        }
+        this.onChange();
+    }
+    async refreshModelFromTranscript(session) {
+        const now = Date.now();
+        if (now - session.lastModelReadAt < 1_000)
+            return;
+        session.lastModelReadAt = now;
+        const found = await readModelFromTranscript(session.transcriptPath);
+        const current = this.effectiveModel(session);
+        const id = found.main ?? (current ? undefined : found.any);
+        if (id) {
+            const before = this.effectiveModel(session);
+            this.applyRuntimeModel(session, { id, displayName: modelDisplayName(id) }, found.mainAt ?? now, found.mainEvent ?? `transcript:${id}`);
+            const after = this.effectiveModel(session);
+            if (before?.id !== after?.id || before?.displayName !== after?.displayName)
+                this.onChange();
+        }
+    }
+    async pollActiveModel() {
+        const session = this.active();
+        if (!session)
+            return;
+        if (!session.transcriptPath) {
+            await this.locateAndRefresh(session);
+            return;
+        }
+        await this.refreshModelFromTranscript(session);
+    }
+    async locateAndRefresh(session) {
+        const now = Date.now();
+        if (now - session.lastTranscriptLocateAt < 2_000)
+            return;
+        session.lastTranscriptLocateAt = now;
+        const path = await findTranscriptPath(session.sessionId);
+        if (!path)
+            return;
+        session.transcriptPath = path;
+        await this.refreshModelFromTranscript(session);
+        await this.refreshStatsFromTranscript(session, true);
+    }
+    async refreshStatsFromTranscript(session, force) {
+        const now = Date.now();
+        if (!force && session.usage && now - session.lastStatsReadAt < 5000)
+            return;
+        session.lastStatsReadAt = now;
+        const stats = await readSessionStats(session.transcriptPath);
+        if (!stats)
+            return;
+        session.usage = stats.usage;
+        session.usageByModel = stats.usageByModel;
+        this.onChange();
+    }
+    handleNotification(session, type) {
+        switch (type) {
+            case "permission_prompt":
+            case "idle_prompt":
+                session.status = "waiting";
+                session.action = "Waiting for input";
+                break;
+            case "agent_needs_input":
+                session.idleAgents = Math.min(session.agents.size, session.idleAgents + 1);
+                break;
+            case "agent_completed":
+                if (session.idleAgents > 0)
+                    session.idleAgents -= 1;
+                break;
+            default:
+                break;
+        }
+    }
+    setDesktopFocus(sessionId, info) {
+        if (!sessionId || !Number.isFinite(info.focusedAt) || info.focusedAt <= 0)
+            return;
+        if (info.failed) {
+            this.clearPendingFocus(sessionId);
+            this.sessions.delete(sessionId);
+            if (this.activeId === sessionId)
+                this.activeId = this.mostRecentId();
+            this.cleared = false;
+            this.onChange();
+            return;
+        }
+        const existing = this.sessions.get(sessionId);
+        const session = this.ensure(sessionId);
+        if (!existing) {
+            session.startTimestamp = Math.min(info.focusedAt, info.lastActivityAt ?? info.focusedAt);
+            session.lastActivity = Math.max(info.focusedAt, info.lastActivityAt ?? 0);
+        }
+        else if (info.focusedAt > session.lastActivity) {
+            session.lastActivity = info.focusedAt;
+        }
+        const desktopModel = modelOf(info.model);
+        if (desktopModel) {
+            session.desktopModelKnown = true;
+            this.applySelectedModel(session, desktopModel, info.updatedAt ?? Date.now());
+        }
+        const effort = effortOf(info.effort);
+        if (effort) {
+            session.desktopEffortKnown = true;
+            session.effort = effort;
+        }
+        const active = this.active();
+        if (active && active.sessionId !== sessionId && active.lastInteractionAt > info.focusedAt) {
+            this.onChange();
+            return;
+        }
+        this.clearPendingFocus();
+        if (info.focusedAt > session.lastInteractionAt)
+            session.lastInteractionAt = info.focusedAt;
+        this.activeId = sessionId;
+        this.cleared = false;
+        if (!session.transcriptPath) {
+            void this.locateAndRefresh(session);
+        }
+        else if (!session.usage || !this.effectiveModel(session)) {
+            void this.refreshStatsFromTranscript(session, true);
+        }
+        this.onChange();
+    }
+    applyUsage(session, usage, byModel) {
+        session.usage = {
+            input: numeric(usage.input_tokens),
+            output: numeric(usage.output_tokens),
+            cacheRead: numeric(usage.cache_read_input_tokens),
+            cacheWrite: numeric(usage.cache_creation_input_tokens),
+        };
+        if (byModel && typeof byModel === "object") {
+            const map = {};
+            for (const [model, u] of Object.entries(byModel)) {
+                if (!u || typeof u !== "object")
+                    continue;
+                map[model] = {
+                    input: numeric(u.input_tokens),
+                    output: numeric(u.output_tokens),
+                    cacheRead: numeric(u.cache_read_input_tokens),
+                    cacheWrite: numeric(u.cache_creation_input_tokens),
+                };
+            }
+            session.usageByModel = Object.keys(map).length > 0 ? map : undefined;
+        }
+        else {
+            session.usageByModel = undefined;
+        }
+    }
+    handleStatusline(payload) {
+        const sessionId = payload.session_id;
+        if (!sessionId)
+            return;
+        const session = this.ensure(sessionId);
+        if (payload.remote === true)
+            session.remote = true;
+        session.hasHookActivity = true;
+        this.touch(session);
+        if (!session.desktopModelKnown) {
+            this.applySelectedModel(session, modelOf(payload.model, payload.model?.display_name));
+        }
+        const effort = effortOf(payload.effort?.level);
+        if (effort && !session.desktopEffortKnown)
+            session.effort = effort;
+        if (typeof payload.fast_mode === "boolean")
+            session.fastMode = payload.fast_mode;
+        if (typeof payload.permission_mode === "string")
+            session.permissionMode = payload.permission_mode;
+        const limits = limitsFromStatusline(payload.rate_limits, Date.now());
+        if (limits)
+            session.statuslineLimits = limits;
+        const cw = payload.context_window?.current_usage;
+        if (cw && !session.usage) {
+            session.usage = {
+                input: numeric(cw.input_tokens),
+                output: numeric(cw.output_tokens),
+                cacheRead: numeric(cw.cache_read_input_tokens),
+                cacheWrite: numeric(cw.cache_creation_input_tokens),
+            };
+        }
+        this.onChange();
+    }
+    mostRecentId(now = Date.now()) {
+        let best;
+        let bestAt = -1;
+        for (const session of this.sessions.values()) {
+            if (this.hidden(session, now))
+                continue;
+            const at = Math.max(session.lastInteractionAt, session.lastActivity);
+            if (at > bestAt) {
+                bestAt = at;
+                best = session.sessionId;
+            }
+        }
+        return best;
+    }
+    active() {
+        const now = Date.now();
+        const current = this.activeId ? this.sessions.get(this.activeId) : undefined;
+        if (current && now - current.lastActivity <= IDLE_MS && !this.hidden(current, now))
+            return current;
+        const fallbackId = this.mostRecentId(now);
+        const fallback = fallbackId ? this.sessions.get(fallbackId) : undefined;
+        if (fallback && (!current || this.hidden(current, now) || fallback.lastActivity > current.lastActivity)) {
+            this.activeId = fallbackId;
+            return fallback;
+        }
+        return current;
+    }
+    checkIdle() {
+        const active = this.active();
+        const now = Date.now();
+        if (!active || now - active.lastActivity > IDLE_MS || this.hidden(active, now)) {
+            if (!this.cleared) {
+                this.cleared = true;
+                this.onChange();
+            }
+            else if (active && (this.usageLimits || active.statuslineLimits)) {
+                this.onChange();
+            }
+            return;
+        }
+        if (active.status === "thinking" || this.usageLimits || active.statuslineLimits)
+            this.onChange();
+    }
+    snapshot() {
+        const active = this.active();
+        const now = Date.now();
+        if (!active || this.hidden(active, now)) {
+            this.activeSince = undefined;
+            return undefined;
+        }
+        const stale = now - active.lastActivity > IDLE_MS;
+        if (this.appAlive && this.appStartedAt !== undefined) {
+            this.activeSince = Math.min(this.appStartedAt, now);
+        }
+        else if (this.activeSince === undefined) {
+            this.activeSince = Math.min(active.startTimestamp, now);
+        }
+        const status = stale ? "idle" : active.status;
+        const agentsRunning = stale ? 0 : active.agents.size;
+        const state = {
+            planName: this.planName,
+            action: actionForStatus(status, active.action, agentsRunning > 0),
+            status,
+            planMode: !stale && active.permissionMode === "plan",
+            agentsRunning,
+            agentsIdle: stale ? 0 : Math.min(active.idleAgents, active.agents.size),
+            startTimestamp: this.activeSince,
+        };
+        if (!stale && status === "thinking" && active.thinkingStartedAt !== undefined) {
+            state.thinkingSeconds = Math.max(0, Math.floor((now - active.thinkingStartedAt) / 1000));
+        }
+        const model = !active.hasHookActivity && this.defaultModel ? this.defaultModel : this.effectiveModel(active);
+        if (model)
+            state.model = model;
+        const effort = !active.hasHookActivity && this.defaultEffort ? this.defaultEffort : active.effort ?? this.defaultEffort;
+        if (effort)
+            state.effort = effort;
+        if (active.fastMode !== undefined)
+            state.fastMode = active.fastMode;
+        // The account usage endpoint is authoritative when available. Some Claude clients emit
+        // placeholder zeroes in statusline input, which would otherwise display a false 100% left.
+        const limits = mergeLimits(active.statuslineLimits, this.usageLimits, true);
+        if (limits)
+            state.limits = limits;
+        if (active.usage) {
+            state.usage = active.usage;
+            const byModel = active.usageByModel;
+            if (byModel && Object.keys(byModel).length > 0) {
+                const breakdown = costForUsageByModel(byModel);
+                state.costBreakdown = breakdown;
+                state.costUsd = breakdown.total;
+            }
+            else if (model?.id) {
+                const breakdown = costBreakdown(model.id, active.usage);
+                state.costBreakdown = breakdown;
+                state.costUsd = breakdown.total;
+            }
+        }
+        const monthlyUsage = active.remote ? this.remoteMonthlyUsage : this.localMonthlyUsage;
+        if (monthlyUsage)
+            state.monthlyUsage = monthlyUsage;
+        return state;
+    }
+}

package/dist/claude/tool-labels.js

@@ -0,0 +1,55 @@
+function basename(input) {
+    if (typeof input !== "string" || input.trim() === "")
+        return "a file";
+    const normalized = input.replace(/\\/g, "/").replace(/\/+$/, "");
+    const segment = normalized.slice(normalized.lastIndexOf("/") + 1);
+    return segment === "" ? "a file" : segment;
+}
+function filePath(toolInput) {
+    if (!toolInput)
+        return undefined;
+    return toolInput.file_path ?? toolInput.notebook_path ?? toolInput.path;
+}
+const STATIC_LABELS = {
+    Grep: "Searching files",
+    Glob: "Searching files",
+    Bash: "Running a command",
+    PowerShell: "Running a command",
+    Agent: "Delegating to agents",
+    WebSearch: "Searching the web",
+    WebFetch: "Browsing the web",
+    TaskCreate: "Managing tasks",
+    TaskUpdate: "Managing tasks",
+    TaskList: "Managing tasks",
+    TaskGet: "Managing tasks",
+    TaskStop: "Managing tasks",
+    TodoWrite: "Managing tasks",
+    Skill: "Running a skill",
+    SlashCommand: "Running a skill",
+    EnterPlanMode: "Planning",
+    ExitPlanMode: "Planning",
+    AskUserQuestion: "Waiting for input",
+    Workflow: "Orchestrating agents",
+    Monitor: "Watching background work",
+    TaskOutput: "Watching background work",
+};
+export function toolLabel(toolName, toolInput) {
+    if (!toolName)
+        return "Working";
+    if (toolName.startsWith("mcp__")) {
+        const server = toolName.split("__")[1];
+        return server ? `Using ${server}` : "Working";
+    }
+    switch (toolName) {
+        case "Read":
+            return `Reading ${basename(filePath(toolInput))}`;
+        case "Edit":
+        case "NotebookEdit":
+            return `Editing ${basename(filePath(toolInput))}`;
+        case "Write":
+            return `Writing ${basename(filePath(toolInput))}`;
+        default:
+            break;
+    }
+    return STATIC_LABELS[toolName] ?? "Working";
+}