claude-rpc 0.13.1 → 0.13.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-rpc",
-  "version": "0.13.1",
+  "version": "0.13.3",
   "description": "Discord Rich Presence for Claude Code — live model, project, tokens, and lifetime stats driven by Claude Code's hook system.",
   "type": "module",
   "license": "MIT",

package/src/cli.js

@@ -1125,7 +1125,31 @@ function profileEnable(on) {
   userCfg.profile = next;
   writeFileSync(CONFIG_PATH, JSON.stringify(userCfg, null, 2));
   console.log(`${c.green}✓${c.reset} leaderboard publishing ${on ? 'enabled' : 'disabled'}`);
-  if (on) console.log(`  ${c.dim}your stats publish on the next daemon flush. run ${c.reset}${c.cyan}claude-rpc profile verify${c.reset}${c.dim} to earn the ✓.${c.reset}`);
+  if (on) {
+    console.log(`  ${c.dim}publish now with ${c.reset}${c.cyan}claude-rpc profile publish${c.reset}${c.dim} (or wait for the next daemon flush).${c.reset}`);
+    console.log(`  ${c.dim}earn the ✓ with ${c.reset}${c.cyan}claude-rpc profile verify${c.reset}${c.dim}.${c.reset}`);
+  }
+}
+
+// One-shot publish so you appear on the board immediately, instead of waiting
+// for the daemon's next flush.
+async function profilePublish() {
+  const cfg = loadConfig();
+  if (!lb.profileIsPublishable(cfg.profile || {})) {
+    return fail('enable the profile first', {
+      hint: 'claude-rpc profile set --handle <name> && claude-rpc profile on', code: EX_BAD_STATE,
+    });
+  }
+  const { flushProfile } = await import('./community.js');
+  console.log(`${c.dim}publishing @${cfg.profile.handle} to the board…${c.reset}`);
+  const r = await flushProfile(cfg);
+  if (r.ok) {
+    console.log(`${c.green}✓${c.reset} published — see it at ${c.cyan}https://claude-rpc.vercel.app/u/${encodeURIComponent(cfg.profile.handle)}${c.reset}`);
+  } else if (r.reason === 'rate-limited') {
+    console.log(`${c.yellow}!${c.reset} rate-limited — already published in the last minute; the board has you.`);
+  } else {
+    return fail(`publish failed: ${r.reason}${r.error ? ' (' + r.error + ')' : ''}`, { code: EX_SYS_ERROR });
+  }
 }
 
 // GitHub verification: ask the worker for a one-time token, publish it in a
@@ -1155,29 +1179,47 @@ async function profileVerify() {
   };
 
   try {
+    // Make sure the profile row exists server-side before we verify it, so
+    // verification works regardless of whether `profile publish` was run first.
+    if (lb.profileIsPublishable(profile)) {
+      const { flushProfile } = await import('./community.js');
+      await flushProfile(cfg);
+    }
     console.log(`${c.dim}requesting a verification token…${c.reset}`);
     const start = await post('/verify/start', { instanceId: community.instanceId, githubUser: profile.githubUser });
     if (!start.json?.token) return fail(`verify/start failed: ${start.json?.error || start.status}`, { code: EX_SYS_ERROR });
     const token = start.json.token;
 
     const { publishGistFile } = await import('./gist.js');
-    console.log(`${c.dim}publishing a proof gist as @${profile.githubUser}…${c.reset}`);
-    await publishGistFile({
-      svg: `claude-rpc leaderboard verification for @${profile.githubUser}\n${token}\n`,
+    console.log(`${c.dim}publishing a public proof gist…${c.reset}`);
+    const gist = await publishGistFile({
+      svg: `claude-rpc leaderboard verification\n${token}\n`,
       filename: 'claude-rpc-verify.txt',
       description: 'claude-rpc profile verification',
       isPublic: true,
     });
 
-    console.log(`${c.dim}asking the server to confirm…${c.reset}`);
-    // Small delay so the gist is visible to GitHub's API before we check.
-    await new Promise((r) => setTimeout(r, 2500));
-    const check = await post('/verify/check', { instanceId: community.instanceId });
+    // Hand the worker the gist ID so it fetches that gist directly (no
+    // gist-list lag) and reads the real owner — instant, and the owner becomes
+    // the verified identity regardless of what --github was set to.
+    console.log(`${c.dim}confirming with the server…${c.reset}`);
+    const check = await post('/verify/check', { instanceId: community.instanceId, gistId: gist.id });
     if (check.json?.verified) {
-      console.log(`${c.green}✓${c.reset} verified as @${profile.githubUser} — you'll show the ✓ on the board.`);
+      const who = check.json.githubUser || gist.owner || profile.githubUser;
+      // Persist the authoritative owner so the local profile + future publishes
+      // match what got verified.
+      if (who && who !== profile.githubUser) {
+        const userCfg = readJson(CONFIG_PATH, {});
+        userCfg.profile = { ...(userCfg.profile || {}), githubUser: who };
+        writeFileSync(CONFIG_PATH, JSON.stringify(userCfg, null, 2));
+      }
+      console.log(`${c.green}✓${c.reset} verified as @${who} — you'll show the ✓ on the board.`);
+      if (who && profile.githubUser && who.toLowerCase() !== profile.githubUser.toLowerCase()) {
+        console.log(`  ${c.dim}(your gist is owned by @${who}, so the profile now uses that account.)${c.reset}`);
+      }
     } else {
-      console.log(`${c.yellow}!${c.reset} not confirmed yet: ${check.json?.error || check.status}`);
-      console.log(`  ${c.dim}the gist may take a moment to propagate — re-run ${c.reset}${c.cyan}claude-rpc profile verify${c.reset}${c.dim} shortly.${c.reset}`);
+      console.log(`${c.yellow}!${c.reset} not confirmed: ${check.json?.error || check.status}`);
+      console.log(`  ${c.dim}make sure the gist is public, then re-run ${c.reset}${c.cyan}claude-rpc profile verify${c.reset}${c.dim}.${c.reset}`);
     }
   } catch (e) {
     return fail(`verification failed: ${e.message}`, {
@@ -1193,8 +1235,9 @@ async function doProfile(argv) {
   if (sub === 'on') return profileEnable(true);
   if (sub === 'off') return profileEnable(false);
   if (sub === 'verify') return profileVerify();
+  if (sub === 'publish') return profilePublish();
   fail(`unknown profile subcommand: ${sub}`, {
-    hint: 'try: profile [status|set|on|off|verify]',
+    hint: 'try: profile [status|set|on|off|verify|publish]',
     code: EX_USER_ERROR,
   });
 }
@@ -1336,7 +1379,7 @@ function help() {
     ['public',    'Un-mark the current directory'],
     ['privacy',   'Show resolved visibility for the current directory'],
     ['community', 'Opt in/out of anonymous community totals (on|off|status|report)'],
-    ['profile',   'Public leaderboard identity — set handle/name/github (status|set|on|off)'],
+    ['profile',   'Public leaderboard identity (status|set|on|off|publish|verify)'],
     ['doctor',    'Run a diagnostic checklist — common-failure triage (--fix to auto-repair)'],
     ['tail',      'Tail the daemon log file'],
     ['daemon',    'Run daemon in foreground (debug)'],

package/src/community.js

@@ -26,7 +26,6 @@ import { VERSION } from './version.js';
 import { profileIsPublishable } from './leaderboard.js';
 
 const CURSOR_PATH = join(STATE_DIR, 'community-cursor.json');
-const PROFILE_CURSOR_PATH = join(STATE_DIR, 'profile-cursor.json');
 
 export function readCursor(path = CURSOR_PATH) {
   if (!existsSync(path)) return { sessions: 0, tokens: 0, ts: 0 };
@@ -87,25 +86,20 @@ function totalTokens(aggregate) {
     + (aggregate?.cacheWriteTokens || 0);
 }
 
-export function readProfileCursor(path = PROFILE_CURSOR_PATH) {
-  const base = { sessions: 0, tokens: 0, activeMs: 0, ts: 0 };
-  if (!existsSync(path)) return base;
-  try { return { ...base, ...JSON.parse(readFileSync(path, 'utf8')) }; }
-  catch { return base; }
-}
-
-export function buildProfilePayload(aggregate, profileCfg, cursor, { instanceId, now = Date.now() }) {
-  const sessions = aggregate?.sessions || 0;
-  const tokens = totalTokens(aggregate);
-  const activeMs = aggregate?.activeMs || 0;
+// A profile reports ABSOLUTE lifetime totals (not deltas). It's per-user and
+// keyed by the instanceId, so the server just stores the latest value — no
+// cursor, no double-count risk, and the board matches your real aggregate
+// exactly. (Deltas were wrong here: the first publish carried the entire
+// lifetime total, which blew past the per-report caps for any established user.)
+export function buildProfilePayload(aggregate, profileCfg, { instanceId, now = Date.now() }) {
   return {
     instanceId,
     handle: profileCfg.handle,
     displayName: profileCfg.displayName || null,
     githubUser: profileCfg.githubUser || null,
-    sessionsDelta: Math.max(0, sessions - (cursor.sessions || 0)),
-    tokensDelta:   Math.max(0, tokens   - (cursor.tokens   || 0)),
-    activeMsDelta: Math.max(0, activeMs  - (cursor.activeMs || 0)),
+    tokens: totalTokens(aggregate),
+    sessions: aggregate?.sessions || 0,
+    activeMs: aggregate?.activeMs || 0,
     streak: aggregate?.streak || 0,
     version: VERSION,
     osFamily: osFamily(),
@@ -115,7 +109,6 @@ export function buildProfilePayload(aggregate, profileCfg, cursor, { instanceId,
 
 export async function flushProfile(cfg, {
   aggregatePath = AGGREGATE_PATH,
-  cursorPath = PROFILE_CURSOR_PATH,
   fetchImpl = globalThis.fetch,
 } = {}) {
   const profile = cfg?.profile || {};
@@ -130,9 +123,7 @@ export async function flushProfile(cfg, {
   try { aggregate = JSON.parse(readFileSync(aggregatePath, 'utf8')); }
   catch { return { ok: false, reason: 'unreadable-aggregate' }; }
 
-  const cursor = readProfileCursor(cursorPath);
-  const payload = buildProfilePayload(aggregate, profile, cursor, { instanceId });
-
+  const payload = buildProfilePayload(aggregate, profile, { instanceId });
   const url = community.endpoint.replace(/\/+$/, '') + '/profile';
   let res;
   try {
@@ -148,16 +139,7 @@ export async function flushProfile(cfg, {
     if (res.status === 429) return { ok: false, reason: 'rate-limited' };
     return { ok: false, reason: `http-${res.status}` };
   }
-
-  // Advance the cursor only on acceptance (same reasoning as flushCommunity).
-  writeCursor({
-    sessions: (cursor.sessions || 0) + payload.sessionsDelta,
-    tokens:   (cursor.tokens   || 0) + payload.tokensDelta,
-    activeMs: (cursor.activeMs || 0) + payload.activeMsDelta,
-    ts: payload.ts,
-  }, cursorPath);
-
-  return { ok: true, delta: { sessions: payload.sessionsDelta, tokens: payload.tokensDelta, activeMs: payload.activeMsDelta } };
+  return { ok: true, totals: { tokens: payload.tokens, sessions: payload.sessions, activeMs: payload.activeMs } };
 }
 
 // Single best-effort flush. Returns { ok, reason, delta? } — never throws.

package/src/daemon.js

@@ -627,8 +627,8 @@ async function runCommunityFlush() {
     }
     if (config.profile?.enabled) {
       const pr = await flushProfile(config);
-      if (pr.ok && pr.delta) {
-        log(`profile: published @${config.profile.handle} (+${pr.delta.tokens} tokens)`);
+      if (pr.ok && pr.totals) {
+        log(`profile: published @${config.profile.handle} (${pr.totals.tokens} tokens)`);
       } else if (!pr.ok && pr.reason !== 'rate-limited' && pr.reason !== 'disabled') {
         log(`profile: ${pr.reason}${pr.error ? ' (' + pr.error + ')' : ''}`);
       }

package/src/version.js

@@ -11,7 +11,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ROOT } from './paths.js';
 
-const BAKED = '0.13.1';
+const BAKED = '0.13.3';
 
 function readPkgVersion() {
   try {