vibestreak 0.1.2 → 0.3.0

package/README.md

@@ -5,10 +5,10 @@ with AI agents and the commits you shipped with them, ranked on consistency,
 not spend. Profiles and the leaderboard: https://vibestreak.kingsbridge-consultancy.com
 
 ```bash
-npx vibestreak login --token PASTE_YOUR_TOKEN   # token from Settings → Machines
-npx vibestreak emails scan                      # add every address you commit as
-npx vibestreak sync
-npx vibestreak autosync on                      # background syncs + evening streak check
+npx vibestreak                                  # sign in through the browser, sync, offer autosync
+npx vibestreak setup --token PASTE_YOUR_TOKEN   # or: everything with the defaults, no questions
+npx vibestreak emails scan                      # addresses from your other accounts
+npx vibestreak pause 3d                         # background syncs and the nudge off for a while
 ```
 
 All commands: https://vibestreak.kingsbridge-consultancy.com/cli

package/bin/vibestreak.mjs

@@ -1,21 +1,35 @@
 #!/usr/bin/env node
+import { createInterface } from 'node:readline/promises'
 import { fileURLToPath } from 'node:url'
 import { parseArgs } from 'node:util'
 
 import { autosyncStatus, clock, installAutosync, nextRun, removeAutosync, SYNC_TIMES } from '../src/autosync.mjs'
 import { NUDGE_DEFAULT, notify, nudgeAction, nudgeText, nudgeTimeOf, parseNudgeTime, shouldNudge } from '../src/nudge.mjs'
-import { collect, sinceDate, summarize } from '../src/collect.mjs'
+import { collect, sinceDate, summarize, syncSince } from '../src/collect.mjs'
 import { CONFIG_PATH, loadConfig, saveConfig } from '../src/config.mjs'
-import { DEFAULT_ROOTS, globalEmail, scanEmails } from '../src/git.mjs'
+import { configuredEmails, DEFAULT_ROOTS, globalEmail, scanEmails } from '../src/git.mjs'
+import { deviceLogin } from '../src/login.mjs'
+import { parsePause, pausedUntil, untilText } from '../src/pause.mjs'
+import { boardView, dashboardView, profileView, todayView } from '../src/views.mjs'
 
 const BRAND = process.env.VIBESTREAK_BRAND ?? 'vibestreak'
 const DEFAULT_SERVER = process.env.VIBESTREAK_SERVER ?? 'https://vibestreak.kingsbridge-consultancy.com'
 
 const HELP = `${BRAND} — share your AI coding heatmap: what you shipped, and how steadily.
 
+  ${BRAND}                           your streak, heatmap and rank at a glance
+                                     (the first time: sets this machine up)
+  ${BRAND} me                        your profile: streak, heatmap, totals
+  ${BRAND} profile <handle>          someone else's public profile
+  ${BRAND} board [today|7d|30d|90d|all] [consistency|shipped|streak|tokens] [tool]
+                                     the leaderboard (--from/--to for your own dates)
+  ${BRAND} today                     who is coding with AI today; streaks at risk
+
   ${BRAND} collect [--json]          preview what would be sent (nothing leaves the machine)
-  ${BRAND} login --token <t> [--server <url>]
-                                     link this machine (token from your settings page)
+  ${BRAND} setup [--token <t>]       link, sync and turn on autosync and the nudge
+                                     with the defaults, asking nothing
+  ${BRAND} login                     link this machine in the browser
+                                     (or --token <t> from your settings page)
   ${BRAND} sync [--quiet]            collect and upload daily totals
   ${BRAND} emails [scan|add <e>|remove <e>]
                                      the addresses you commit as (all of your accounts)
@@ -26,6 +40,9 @@ const HELP = `${BRAND} — share your AI coding heatmap: what you shipped, and h
   ${BRAND} nudge [on|off|test]       an evening notification when your streak is
                                      about to end (on with autosync); alone, its status
   ${BRAND} nudge at 21:45            when it checks (17:00 to 23:30; default 20:30)
+  ${BRAND} pause [1h|3d|tomorrow]    pause background syncs and the nudge (up to 7
+                                     days; default until tomorrow 06:00)
+  ${BRAND} resume                    end a pause now
   ${BRAND} whoami                    the profile this machine syncs to
 
 Reads: Claude Code, Codex, Cursor, Copilot (CLI and VS Code), Gemini CLI,
@@ -39,7 +56,7 @@ All commands, with examples: ${DEFAULT_SERVER}/cli`
 const fmt = n => n.toLocaleString('en-US')
 
 async function api(config, path, init = {}) {
-  if (!config.server || !config.token) throw new Error(`Not linked yet: run \`${BRAND} login --token <token>\`.`)
+  if (!config.server || !config.token) throw new Error(`Not linked yet: run \`${BRAND} login\`.`)
   const response = await fetch(new URL(path, config.server), {
     ...init,
     headers: { authorization: `Bearer ${config.token}`, 'content-type': 'application/json', ...init.headers },
@@ -58,14 +75,47 @@ async function main() {
       token: { type: 'string' },
       server: { type: 'string' },
       since: { type: 'string' },
+      full: { type: 'boolean' },
       help: { type: 'boolean', short: 'h' },
+      from: { type: 'string' },
+      to: { type: 'string' },
+      limit: { type: 'string' },
+      // Set by the background jobs, so a pause skips them and nothing else.
+      scheduled: { type: 'boolean' },
+      yes: { type: 'boolean', short: 'y' },
     },
   })
-  const [command = 'help', ...rest] = positionals
+  const [command = 'dashboard', ...rest] = positionals
   const config = await loadConfig()
   const log = (...args) => values.quiet || console.log(...args)
 
   if (command === 'help' || values.help) return console.log(HELP)
+  const columns = process.stdout.columns || 100
+  const server = config.server ?? DEFAULT_SERVER
+
+  if (command === 'dashboard') {
+    // Plain `vibestreak`: the dashboard once linked; before that, setup (or,
+    // with no one at the keyboard, how to start).
+    if (!config.token) {
+      if (!process.stdin.isTTY || !process.stdout.isTTY) return console.log(`${HELP}\n\nGet started: ${server.replace(/\/$/, '')}/cli`)
+      return setup(config, values, { ask: !values.yes })
+    }
+    const me = await api(config, '/api/v1/me')
+    return dashboardView({ server, token: config.token, handle: me.handle, columns })
+  }
+  if (command === 'me') {
+    const me = await api(config, '/api/v1/me')
+    return profileView({ server, token: config.token, handle: me.handle, columns })
+  }
+  if (command === 'profile') {
+    if (!rest[0]) throw new Error(`Whose? \`${BRAND} profile <handle>\` (yours: \`${BRAND} me\`).`)
+    return profileView({ server, token: config.token, handle: rest[0].replace(/^@/, ''), columns })
+  }
+  if (command === 'board') {
+    const you = config.token ? (await api(config, '/api/v1/me').catch(() => null))?.handle : undefined
+    return boardView({ server, words: rest, values, you, columns })
+  }
+  if (command === 'today') return todayView({ server })
 
   if (command === 'emails') {
     const [action, email] = rest
@@ -96,19 +146,25 @@ async function main() {
     return console.log((config.roots ?? DEFAULT_ROOTS).join('\n'))
   }
 
-  if (command === 'login') {
-    if (!values.token) return console.log(`Get a token on ${values.server ?? config.server ?? DEFAULT_SERVER}/settings, then:\n  ${BRAND} login --token <token>`)
-    config.server = values.server ?? config.server ?? DEFAULT_SERVER
-    config.token = values.token
-    const me = await api(config, '/api/v1/me')
-    if (!config.emails.length) {
-      const first = await globalEmail()
-      if (first) config.emails = [first]
-    }
+  if (command === 'login') return login(config, values)
+  if (command === 'setup') return setup(config, values, { ask: false })
+
+  if (command === 'pause') {
+    const until = parsePause(rest[0])
+    config.pausedUntil = until.toISOString()
     await saveConfig(config)
-    console.log(`Linked ${config.machineName} to ${me.handle} (${me.profileUrl}).`)
-    console.log(`Commit addresses: ${config.emails.join(', ') || 'none'}; run \`${BRAND} emails scan\` to add your other accounts.`)
-    return
+    await refreshJobs(config)
+    return console.log(
+      `Paused until ${untilText(until)}: no background syncs or streak nudge until then.` +
+        ` The first sync after it uploads everything you did meanwhile. \`${BRAND} resume\` ends it sooner.`,
+    )
+  }
+  if (command === 'resume') {
+    const was = pausedUntil(config)
+    delete config.pausedUntil
+    await saveConfig(config)
+    await refreshJobs(config)
+    return console.log(was ? `Resumed: background syncs${config.nudge === false ? '' : ' and the nudge'} run again from the next scheduled time.` : 'Not paused.')
   }
 
   if (command === 'whoami') {
@@ -116,7 +172,11 @@ async function main() {
     return console.log(`${me.handle} · ${me.profileUrl}\nGitHub: ${me.github.join(', ')}\nMachine: ${config.machineName}`)
   }
 
-  if (command === 'collect' || command === 'sync') return sync(config, values, log, command === 'sync')
+  if (command === 'collect' || command === 'sync') {
+    const until = values.scheduled && pausedUntil(config)
+    if (until) return console.log(`${new Date().toISOString()} paused until ${until.toISOString()}; skipped`)
+    return sync(config, values, log, command === 'sync')
+  }
 
   if (command === 'status') return status(config)
 
@@ -146,6 +206,8 @@ async function main() {
       return console.log(`Sent a test notification (your streak: ${streak.current} days; ${streak.activeToday ? 'active today' : 'not active yet today'}).`)
     }
     // `nudge run`, the evening job: sync, then nudge if the streak would end at midnight.
+    const until = pausedUntil(config)
+    if (until) return console.log(`${new Date().toISOString()} paused until ${until.toISOString()}; skipped`)
     const result = await sync(config, values, log, true)
     if (shouldNudge(result.streak, config)) {
       await notify(nudgeText(result.streak))
@@ -176,6 +238,63 @@ async function main() {
   process.exitCode = 1
 }
 
+// Links this machine: in the browser by default, or with a token from the
+// settings page (for machines without one).
+async function login(config, values, { addresses = true } = {}) {
+  config.server = values.server ?? config.server ?? DEFAULT_SERVER
+  if (values.token) config.token = values.token
+  else config.token = (await deviceLogin({ server: config.server, machine: config.machineName })).token
+  const me = await api(config, '/api/v1/me')
+  if (!config.emails.length) {
+    const first = await globalEmail()
+    if (first) config.emails = [first]
+  }
+  await saveConfig(config)
+  console.log(`Linked ${config.machineName} to @${me.handle} (${me.profileUrl}).`)
+  if (addresses) console.log(`Commit addresses: ${config.emails.join(', ') || 'none'}; \`${BRAND} emails scan\` finds your other accounts' addresses.`)
+  return me
+}
+
+// Everything a machine needs, with the defaults: linked (in the browser, or
+// with --token), the commit addresses from git config, the usual repo
+// folders, a first sync, and autosync with the evening nudge. The first plain
+// `npx vibestreak` asks about autosync; `setup` asks nothing.
+async function setup(config, values, { ask: interactive }) {
+  console.log(`${BRAND}: your AI coding heatmap and streak, from this machine's history.\n`)
+  console.log('Nothing but daily counts leaves this machine: never prompts, code, file paths or repo names.')
+  console.log(`(\`${BRAND} collect\` previews it all without sending anything.)\n`)
+  await login(config, values, { addresses: false })
+  const found = await configuredEmails(config.roots ?? DEFAULT_ROOTS)
+  config.emails = [...new Set([...config.emails, ...found])]
+  await saveConfig(config)
+  console.log(`Counting commits by ${config.emails.join(', ') || 'no address yet'} (from git config) and your GitHub accounts' noreply addresses.`)
+  console.log('\nFirst sync: reading your history (a minute for a big one)…')
+  await sync(config, values, console.log, true)
+  const yes = !interactive || (await ask(`\nKeep it up to date in the background (${SYNC_TIMES.map(clock).join(', ')}) and nudge you at ${clock(nudgeTimeOf(config))} when your streak is about to end? [Y/n] `))
+  if (yes) {
+    const result = await installAutosync(fileURLToPath(import.meta.url), { nudge: config.nudge !== false, nudgeTime: nudgeTimeOf(config) })
+    config.autosync = result.installed
+    await saveConfig(config)
+    console.log(result.installed ? `On: syncing via ${result.using}. \`${BRAND} pause\` or \`${BRAND} autosync off\` any time.` : result.hint)
+  } else console.log(`Off. \`${BRAND} sync\` updates it, or \`${BRAND} autosync on\` later.`)
+  console.log(`\nDone. \`${BRAND}\` shows your streak. Commit from other addresses too? \`${BRAND} emails scan\` lists them. \`${BRAND} help\` lists everything.`)
+}
+
+async function ask(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+  try {
+    return !/^n/i.test((await rl.question(question)).trim())
+  } finally {
+    rl.close()
+  }
+}
+
+// The background jobs run a copy of the CLI kept in the config folder: a
+// pause or resume refreshes it, so the jobs run code that knows about pauses.
+async function refreshJobs(config) {
+  if (config.autosync) await installAutosync(fileURLToPath(import.meta.url), { nudge: config.nudge !== false, nudgeTime: nudgeTimeOf(config) })
+}
+
 // Collects this machine's totals and, for a sync, uploads them; the server
 // answers with where the streak stands (the nudge's input).
 async function sync(config, values, log, isSync) {
@@ -186,7 +305,7 @@ async function sync(config, values, log, isSync) {
     if (first) emails.push(first)
   }
   const started = Date.now()
-  const payload = await collect({ config: { ...config, emails }, salt: me?.salt ?? config.localSalt, since: values.since })
+  const payload = await collect({ config: { ...config, emails }, salt: me?.salt ?? config.localSalt, since: isSync ? syncSince(config, values) : values.since })
   if (values.json) return console.log(JSON.stringify(payload, null, 2))
   const s = summarize(payload)
   log(`${s.activeDays} active days since ${payload.since} (${((Date.now() - started) / 1000).toFixed(1)}s)`)
@@ -197,7 +316,9 @@ async function sync(config, values, log, isSync) {
   if (!isSync) return log(`\nNothing was sent. \`${BRAND} sync\` uploads these totals.`)
   const result = await api(config, '/api/v1/upload', { method: 'POST', body: JSON.stringify(payload) })
   config.lastSync = new Date().toISOString()
+  config.lastSyncServer = config.server
   config.lastSyncSummary = { days: result.days, commits: result.commits, repos: s.repos }
+  if (result.underReview) console.log(`Your profile is under review and off the boards for now: see ${new URL('/settings#trust', config.server)}`)
   await saveConfig(config)
   // Always one line, quiet or not: the background sync's log is how a person sees it ran.
   const streak = result.streak ? ` · streak ${result.streak.current}d${result.streak.activeToday ? '' : ' (not yet today)'}` : ''
@@ -214,7 +335,7 @@ const at = ({ at, day }) => `${day} ${clock([at.getHours(), at.getMinutes()])}`
 
 // The server's view of the streak, or why it can't be had (not linked, offline).
 async function serverStatus(config) {
-  if (!config.server || !config.token) return { error: `not linked: run \`${BRAND} login --token PASTE_YOUR_TOKEN\`` }
+  if (!config.server || !config.token) return { error: `not linked: run \`${BRAND} login\`` }
   try {
     return await api(config, '/api/v1/me')
   } catch (error) {
@@ -238,7 +359,9 @@ async function nudgeStatus(config) {
   console.log(`Last nudge  ${config.lastNudge ?? 'never'}`)
   if (me.error) return console.log(`Tonight     unknown (${me.error})`)
   const s = me.streak
-  const tonight = !on ? 'no check' : s.activeToday ? 'no nudge: you were active today' : s.current > 0 ? (config.lastNudge === s.today ? 'already nudged today' : `will nudge at ${time} unless you code with AI first`) : 'no nudge: no live streak'
+  const paused = pausedUntil(config)
+  if (paused) console.log(`Paused      until ${untilText(paused)}`)
+  const tonight = !on ? 'no check' : paused && paused > nextRun([nudgeTimeOf(config)]).at ? 'no check: paused' : s.activeToday ? 'no nudge: you were active today' : s.current > 0 ? (config.lastNudge === s.today ? 'already nudged today' : `will nudge at ${time} unless you code with AI first`) : 'no nudge: no live streak'
   console.log(`Streak      ${streakLine(s)}`)
   console.log(`Tonight     ${tonight}`)
 }
@@ -253,6 +376,8 @@ async function status(config) {
   row('Last sync', config.lastSync ? `${ago(config.lastSync)}${last ? ` · ${last.days} days, ${last.commits} commits from ${last.repos} repos` : ''}` : `never: run \`${BRAND} sync\``)
   if (!me.error) row('Streak', streakLine(me.streak))
   row('Autosync', scheduled.on ? `on (${scheduled.using}) · next sync ${at(nextRun(SYNC_TIMES))}` : `off: \`${BRAND} autosync on\` syncs at ${SYNC_TIMES.map(clock).join(', ')}`)
+  const paused = pausedUntil(config)
+  if (paused) row('Paused', `until ${untilText(paused)}: background syncs and the nudge skip their runs (\`${BRAND} resume\` ends it)`)
   const nudgeOn = config.nudge !== false && scheduled.nudge
   row('Nudge', nudgeOn ? `on · checks at ${clock(nudgeTimeOf(config))} · last nudged ${config.lastNudge ?? 'never'}` : config.nudge === false ? 'off' : 'off (needs autosync)')
   const github = me.error ? 0 : (me.emails?.length ?? 0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibestreak",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Your AI coding streak: a heatmap of the days you coded with Claude Code, Codex, Cursor, Copilot, Gemini and OpenCode, and the commits you shipped with them. Sends daily totals only.",
   "keywords": ["claude-code", "codex", "cursor", "copilot", "gemini", "opencode", "ai-coding", "heatmap", "streak", "leaderboard", "cli"],
   "homepage": "https://vibestreak.kingsbridge-consultancy.com/cli",

package/src/autosync.mjs

@@ -26,8 +26,8 @@ const logPath = () => join(configDir(), 'sync.log')
 // The jobs to schedule: a sync at each sync time, and the evening nudge at
 // the person's chosen time.
 export const jobs = (nudge, nudgeTime = NUDGE_DEFAULT) => [
-  { name: 'sync', args: ['sync', '--quiet'], times: SYNC_TIMES },
-  ...(nudge ? [{ name: 'nudge', args: ['nudge', 'run', '--quiet'], times: [nudgeTime] }] : []),
+  { name: 'sync', args: ['sync', '--quiet', '--scheduled'], times: SYNC_TIMES },
+  ...(nudge ? [{ name: 'nudge', args: ['nudge', 'run', '--quiet', '--scheduled'], times: [nudgeTime] }] : []),
 ]
 
 // A CLI run through npx lives in npm's cache, which can be cleared; a

package/src/claude.mjs

@@ -38,7 +38,7 @@ export async function collectClaude({ root = join(homedir(), '.claude', 'project
     return days.get(date)
   }
 
-  for await (const path of walk(root, '.jsonl')) {
+  for await (const path of walk(root, '.jsonl', since)) {
     for await (const line of lines(path)) {
       const role = ROLE.exec(line)?.[1]
       if (!role) continue

package/src/codex.mjs

@@ -24,7 +24,7 @@ export async function collectCodex({ root = join(homedir(), '.codex'), since } =
   const seenSessions = new Set()
 
   for (const folder of ['sessions', 'archived_sessions']) {
-    for await (const path of walk(join(root, folder), '.jsonl')) {
+    for await (const path of walk(join(root, folder), '.jsonl', since)) {
       let session
       let model
       let last = { input: 0, cached: 0, output: 0 }

package/src/collect.mjs

@@ -9,8 +9,19 @@ import { collectOpenCode } from './opencode.mjs'
 
 export const PAYLOAD_VERSION = 1
 
-// How far back a sync reaches: a year and a bit, the most a heatmap shows.
-export const sinceDate = (days = 400) => dayKey(new Date(Date.now() - days * 864e5))
+// How far back a sync reaches: a machine's first sync sends a year and a
+// bit (the most a heatmap shows); after that the server takes only the last
+// week from it (its history lock), so later syncs send just that.
+export const FULL_DAYS = 400
+export const RECENT_DAYS = 7
+export const sinceDate = (days = FULL_DAYS) => dayKey(new Date(Date.now() - days * 864e5))
+
+// Where this machine's next sync starts: a full history the first time (or
+// on --full, or after linking to another server), the last week after that.
+export function syncSince(config, { full = false, since } = {}) {
+  if (since) return since
+  return full || !config.lastSync || config.lastSyncServer !== config.server ? sinceDate(FULL_DAYS) : sinceDate(RECENT_DAYS)
+}
 
 // Everything one machine sends: per-day totals per tool, and its commits as
 // keyed hashes. No prompt, code, path, repo name or commit message is read

package/src/files.mjs

@@ -1,8 +1,10 @@
-import { open, readdir } from 'node:fs/promises'
+import { open, readdir, stat } from 'node:fs/promises'
 import { join } from 'node:path'
 
-// Every file under `root` whose name ends in `suffix`, symbolic links not followed.
-export async function* walk(root, suffix) {
+// Every file under `root` whose name ends in `suffix`, symbolic links not
+// followed; with `since` (YYYY-MM-DD), only files changed on or after that
+// day (a file untouched since can hold nothing newer).
+export async function* walk(root, suffix, since) {
   let entries
   try {
     entries = await readdir(root, { withFileTypes: true })
@@ -11,11 +13,19 @@ export async function* walk(root, suffix) {
   }
   for (const entry of entries) {
     const path = join(root, entry.name)
-    if (entry.isDirectory()) yield* walk(path, suffix)
-    else if (entry.isFile() && entry.name.endsWith(suffix)) yield path
+    if (entry.isDirectory()) yield* walk(path, suffix, since)
+    else if (entry.isFile() && entry.name.endsWith(suffix)) {
+      if (since && (await stat(path).catch(() => undefined))?.mtime < localMidnight(since)) continue
+      yield path
+    }
   }
 }
 
+const localMidnight = day => {
+  const [y, m, d] = day.split('-').map(Number)
+  return new Date(y, m - 1, d)
+}
+
 const CHUNK = 4 * 1024 * 1024
 const NEWLINE = 10
 

package/src/git.mjs

@@ -136,6 +136,21 @@ export async function scanEmails({ roots, since }) {
   return [...counts].sort((a, b) => b[1] - a[1])
 }
 
+// The addresses this person commits as, by their own git config: the global
+// one, and any a repo sets for itself (a work address in work repos). Other
+// people's addresses in the same repos are never picked up this way.
+export async function configuredEmails(roots = DEFAULT_ROOTS) {
+  const local = await Promise.all(
+    (await findRepos(roots)).map(repo =>
+      run('git', ['-C', repo, 'config', '--local', '--get', 'user.email']).then(
+        r => r.stdout.trim(),
+        () => '',
+      ),
+    ),
+  )
+  return [...new Set([await globalEmail(), ...local].filter(e => e && e.includes('@')))]
+}
+
 export async function globalEmail() {
   try {
     return (await run('git', ['config', '--global', 'user.email'])).stdout.trim() || undefined

package/src/google.mjs

@@ -27,7 +27,7 @@ const dayMap = tool => {
 // tool calls and tokens (`input` includes the cached part, split out here).
 export async function collectGeminiCli({ root = join(GEMINI(), 'tmp'), since } = {}) {
   const { day, list } = dayMap('gemini')
-  for await (const path of walk(root, '.json')) {
+  for await (const path of walk(root, '.json', since)) {
     if (!/[/\\]chats[/\\]/.test(path)) continue
     let chat
     try {
@@ -74,7 +74,7 @@ const seconds = buffer => {
 
 export async function collectAntigravity({ root = join(GEMINI(), 'antigravity', 'conversations'), since } = {}) {
   const { day, list } = dayMap('antigravity')
-  for await (const path of walk(root, '.db')) {
+  for await (const path of walk(root, '.db', since)) {
     const id = path
     const steps = await query(path, 'SELECT step_type AS type, hex(metadata) AS meta FROM steps')
     let lastDate

package/src/login.mjs

@@ -0,0 +1,45 @@
+import { spawn } from 'node:child_process'
+
+// Opens a page in the default browser; false when there's no way to (a
+// server, a container), and the person opens the printed link themselves.
+export function openBrowser(url, platform = process.platform) {
+  const [command, args] =
+    platform === 'darwin' ? ['open', [url]] : platform === 'win32' ? ['rundll32', ['url.dll,FileProtocolHandler', url]] : ['xdg-open', [url]]
+  return new Promise(resolve => {
+    try {
+      const child = spawn(command, args, { stdio: 'ignore', detached: true, windowsHide: true })
+      child.on('error', () => resolve(false))
+      child.on('spawn', () => {
+        child.unref()
+        resolve(true)
+      })
+    } catch {
+      resolve(false)
+    }
+  })
+}
+
+const pause = ms => new Promise(resolve => setTimeout(resolve, ms))
+
+// Browser sign-in: the server hands out a code, the person approves it on
+// the site (signing in with GitHub first if need be), and the token comes back
+// to the secret only this process holds. Nothing to copy or paste.
+export async function deviceLogin({ server, machine, log = console.log, open = openBrowser, fetchImpl = fetch, sleep = pause }) {
+  const post = (path, body) => fetchImpl(new URL(path, server), { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) })
+  const started = await post('/api/v1/device', { machine })
+  if (!started.ok) throw new Error(`Couldn't start sign-in (${started.status}); try again, or use a token from ${new URL('/settings', server)}.`)
+  const { code, secret, verifyUrl, interval = 2, expiresIn = 600 } = await started.json()
+  const opened = await open(verifyUrl)
+  log(`${opened ? 'Opening your browser to link this machine' : 'Open this page to link this machine'}: ${verifyUrl}`)
+  log(`Check it shows ${code}, then approve. Waiting…`)
+  const deadline = Date.now() + expiresIn * 1000
+  while (Date.now() < deadline) {
+    await sleep(interval * 1000)
+    const response = await post('/api/v1/device/token', { secret }).catch(() => null)
+    if (!response || response.status === 202 || response.status === 429 || response.status >= 500) continue
+    const body = await response.json().catch(() => ({}))
+    if (response.ok && body.token) return body
+    throw new Error(body.error ?? `Sign-in failed (${response.status}).`)
+  }
+  throw new Error('Sign-in timed out; run login again.')
+}

package/src/opencode.mjs

@@ -73,7 +73,7 @@ export async function collectOpenCode({ dir = OPENCODE_DIR(), since } = {}) {
     }
     return n
   }
-  for await (const path of walk(join(storage, 'message'), '.json')) {
+  for await (const path of walk(join(storage, 'message'), '.json', since)) {
     let m
     try {
       m = JSON.parse(await readFile(path, 'utf8'))

package/src/pause.mjs

@@ -0,0 +1,40 @@
+// Pausing the background jobs: the scheduled syncs and the evening nudge skip
+// their runs until a set time, then carry on by themselves. A pause is held
+// to 7 days, the window a sync catches up afterwards (older days can't be
+// changed), so nothing done during it is lost: it is uploaded on resume.
+export const MAX_PAUSE_DAYS = 7
+export const MORNING = 6
+
+// `1h`…`168h`, `1d`…`7d`, or `tomorrow` (the default: until 06:00 tomorrow,
+// before the first sync of the day).
+export function parsePause(word = 'tomorrow', from = new Date()) {
+  const w = String(word).trim().toLowerCase()
+  if (w === 'tomorrow' || w === 'today') {
+    const until = new Date(from)
+    until.setDate(until.getDate() + 1)
+    until.setHours(MORNING, 0, 0, 0)
+    return until
+  }
+  const match = /^(\d+)\s*(h|hours?|d|days?)$/.exec(w)
+  if (!match) throw new Error(`Pause for how long? \`1h\`, \`3d\` or \`tomorrow\` (up to ${MAX_PAUSE_DAYS} days).`)
+  const hours = Number(match[1]) * (match[2].startsWith('d') ? 24 : 1)
+  if (hours < 1 || hours > MAX_PAUSE_DAYS * 24) {
+    throw new Error(`A pause lasts 1 hour to ${MAX_PAUSE_DAYS} days: a sync afterwards catches up only the last ${MAX_PAUSE_DAYS}. For longer, \`autosync off\`.`)
+  }
+  return new Date(from.getTime() + hours * 3600e3)
+}
+
+// The time background runs resume, while a pause lasts.
+export const pausedUntil = (config, at = new Date()) => {
+  const until = config.pausedUntil ? new Date(config.pausedUntil) : undefined
+  return until && until > at ? until : undefined
+}
+
+export const untilText = (until, at = new Date()) => {
+  const time = until.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: false })
+  const sameDay = until.toDateString() === at.toDateString()
+  const tomorrow = new Date(at)
+  tomorrow.setDate(tomorrow.getDate() + 1)
+  const day = sameDay ? 'today' : until.toDateString() === tomorrow.toDateString() ? 'tomorrow' : until.toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric' })
+  return `${day} ${time}`
+}

package/src/view.mjs

@@ -0,0 +1,138 @@
+import { dayKey } from './days.mjs'
+
+// Drawing in the terminal: the site's blue heatmap in coloured squares, its
+// orange for work shipped with AI, plain characters where colour is off.
+
+const BLUES = ['#0d3a63', '#1a5fa3', '#2f81f7', '#79c0ff']
+const EMPTY = '#2a323d'
+const SHIP = '#f2994a'
+const MUTED = '#8b949e'
+
+// How much colour the terminal takes: none (NO_COLOR, piped output, a dumb
+// terminal), 256 colours, or full colour (COLORTERM says so; Windows Terminal).
+export function colorLevel(stream = process.stdout, env = process.env) {
+  if ('NO_COLOR' in env) return 0
+  if (env.FORCE_COLOR === '0') return 0
+  if (env.FORCE_COLOR) return env.FORCE_COLOR === '1' ? 2 : 3
+  if (!stream.isTTY || env.TERM === 'dumb') return 0
+  if (/truecolor|24bit/i.test(env.COLORTERM ?? '') || env.WT_SESSION) return 3
+  return 2
+}
+
+const rgb = hex => [1, 3, 5].map(i => parseInt(hex.slice(i, i + 2), 16))
+const to256 = ([r, g, b]) => 16 + 36 * Math.round((r / 255) * 5) + 6 * Math.round((g / 255) * 5) + Math.round((b / 255) * 5)
+
+export function painter(level = colorLevel()) {
+  const fg = hex => (level === 3 ? `\x1b[38;2;${rgb(hex).join(';')}m` : level === 2 ? `\x1b[38;5;${to256(rgb(hex))}m` : '')
+  const wrap = (open, text) => (level ? `${open}${text}\x1b[0m` : text)
+  return {
+    level,
+    color: (hex, text) => wrap(fg(hex), text),
+    bold: text => wrap('\x1b[1m', text),
+    dim: text => wrap(fg(MUTED), text),
+    ship: text => wrap(fg(SHIP), text),
+  }
+}
+
+// One day's cell: a coloured square by shade (with an orange dot after it
+// when something shipped with AI), or plain characters without colour.
+const PLAIN = ['░', '▒', '▓', '█']
+export function cell(p, shade, shipped) {
+  if (shade === null) return '  '
+  const mark = shipped ? (p.level ? p.ship('•') : '*') : ' '
+  if (p.level === 0) return (shade < 0 ? '·' : PLAIN[shade]) + mark
+  return p.color(shade < 0 ? EMPTY : BLUES[shade], '■') + mark
+}
+
+const value = d => (d ? (d.messages ?? 0) + (d.aiCommits ?? 0) * 20 : 0)
+const active = d => !!d && ((d.messages ?? 0) > 0 || (d.aiCommits ?? 0) > 0)
+
+// Shades by quartile of the person's own active days, as on the site.
+export function shader(days, from, to) {
+  const sorted = Object.entries(days)
+    .filter(([date, d]) => date >= from && date <= to && active(d))
+    .map(([, d]) => value(d))
+    .sort((a, b) => a - b)
+  const at = q => sorted[Math.floor(q * (sorted.length - 1))] ?? 0
+  const cuts = [at(0.25), at(0.5), at(0.75)]
+  return d => (!active(d) ? -1 : value(d) <= cuts[0] ? 0 : value(d) <= cuts[1] ? 1 : value(d) <= cuts[2] ? 2 : 3)
+}
+
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+const addDays = (key, n) => {
+  const [y, m, d] = key.split('-').map(Number)
+  return dayKey(new Date(y, m - 1, d + n))
+}
+const weekday = key => {
+  const [y, m, d] = key.split('-').map(Number)
+  return new Date(y, m - 1, d).getDay()
+}
+
+// The heatmap: Sunday-first columns from the first active day (or as many
+// weeks as fit), month names above, Mon/Wed/Fri down the side.
+export function heatmap(p, days, today, { columns = 80, first } = {}) {
+  const maxWeeks = Math.max(4, Math.floor((columns - 5) / 2))
+  const earliest = addDays(today, -(maxWeeks * 7 - 1) - weekday(today))
+  const from = first && first > earliest ? first : earliest
+  const start = addDays(from, -weekday(from))
+  const weeks = []
+  for (let day = start; day <= today; day = addDays(day, 7)) weeks.push(Array.from({ length: 7 }, (_, i) => addDays(day, i)))
+  const shade = shader(days, from, today)
+  // A month's name sits over its first week. When it would collide with the
+  // previous name, the previous one (a month shown for a week at most) gives way.
+  const labels = []
+  let lastMonth = -1
+  weeks.forEach((week, w) => {
+    const shown = week.find(d => d >= from) ?? week[0]
+    const month = Number(shown.slice(5, 7)) - 1
+    if (month !== lastMonth && w <= weeks.length - 2) {
+      const previous = labels.at(-1)
+      if (previous && w - previous.w < 2) labels.pop()
+      labels.push({ w, name: MONTHS[month] })
+    }
+    lastMonth = month
+  })
+  let header = '     '
+  for (const { w, name } of labels) if (header.length <= 5 + w * 2) header = header.padEnd(5 + w * 2) + name
+  const rows = ['', 'Mon', '', 'Wed', '', 'Fri', ''].map((label, d) => {
+    const cells = weeks.map(week => {
+      const date = week[d]
+      if (date < from || date > today) return '  '
+      const day = days[date]
+      return cell(p, shade(day), (day?.aiCommits ?? 0) > 0)
+    })
+    return `${p.dim(label.padEnd(4))} ${cells.join('')}`
+  })
+  const legend = `     ${p.dim('less')} ${[-1, 0, 1, 2, 3].map(s => cell(p, s, false)).join('')}${p.dim('more')}   ${p.level ? p.ship('•') : '*'} ${p.dim('shipped with AI')}`
+  return [p.dim(header), ...rows, legend].join('\n')
+}
+
+// The last four weeks in one line, from a board row's 12-week strip.
+export function recent(p, strip, length = 28) {
+  return strip
+    .flat()
+    .filter(s => s !== -2)
+    .slice(-length)
+    .map(s => cell(p, s, false).trimEnd() || ' ')
+    .join('')
+}
+
+export const compact = n =>
+  n >= 1e12 ? `${(n / 1e12).toFixed(1)}T` : n >= 1e9 ? `${(n / 1e9).toFixed(1)}B` : n >= 1e6 ? `${(n / 1e6).toFixed(1)}M` : n >= 1e4 ? `${(n / 1e3).toFixed(1)}K` : n.toLocaleString('en-US')
+
+export const TOOL_NAMES = {
+  claude: 'Claude Code',
+  codex: 'Codex',
+  cursor: 'Cursor',
+  copilot: 'Copilot',
+  gemini: 'Gemini CLI',
+  antigravity: 'Antigravity',
+  opencode: 'OpenCode',
+}
+
+// Pads text that may hold colour codes to a visible width.
+export const visible = text => text.replace(/\x1b\[[0-9;]*m/g, '')
+export const pad = (text, width, right = false) => {
+  const gap = ' '.repeat(Math.max(0, width - [...visible(text)].length))
+  return right ? gap + text : text + gap
+}

package/src/views.mjs

@@ -0,0 +1,130 @@
+import { compact, heatmap, pad, painter, recent, TOOL_NAMES } from './view.mjs'
+
+// The read-only commands: your profile and others', the board, today, and
+// the dashboard plain `vibestreak` shows. Each fetches the public API (with
+// the machine's token where it has one, so a hidden profile's owner still
+// sees it) and draws for the terminal's width.
+
+const fmt = n => Number(n ?? 0).toLocaleString('en-US')
+const plural = (n, one, many = `${one}s`) => `${fmt(n)} ${n === 1 ? one : many}`
+const toolList = tools => (tools ?? []).map(t => TOOL_NAMES[t] ?? t).join(', ')
+
+const PERIODS = ['today', '7d', '30d', '90d', 'all']
+const METRICS = ['consistency', 'shipped', 'streak', 'tokens']
+const TOOLS = Object.keys(TOOL_NAMES)
+
+async function getJson(server, path, token) {
+  const response = await fetch(new URL(path, server), { headers: token ? { authorization: `Bearer ${token}` } : {} })
+  const body = await response.json().catch(() => ({}))
+  if (response.status === 404) throw new Error('No such public profile.')
+  if (!response.ok) throw new Error(body.error ?? `${response.status} ${response.statusText}`)
+  return body
+}
+
+function streakLine(p, profile) {
+  const s = profile.summary.streak
+  const today = profile.activeToday ? p.color('#3fb950', '✓ active today') : s.current > 0 ? p.ship('streak ends at midnight') : p.dim('no live streak')
+  const level = profile.level ? `${p.color('#2f81f7', '◆')} ${profile.level}` : ''
+  const next = profile.next ? p.dim(` · ${plural(profile.next.remaining, 'day')} to ${profile.next.name}`) : ''
+  return `${p.bold(`${fmt(s.current)}-day streak`)} ${p.dim(`(best ${fmt(s.longest)})`)}  ${today}  ${level}${next}`
+}
+
+// `vibestreak me` and `vibestreak profile <handle>`.
+export async function profileView({ server, token, handle, columns }) {
+  const p = painter()
+  const profile = await getJson(server, `/api/v1/users/${encodeURIComponent(handle)}.json`, token)
+  const s = profile.summary
+  const out = [
+    `${p.bold(`@${profile.handle}`)}  ${p.dim(toolList(profile.tools))}`,
+    streakLine(p, profile),
+    '',
+    heatmap(p, profile.days, profile.today, { columns, first: s.first }),
+    '',
+    `${p.bold(fmt(s.activeDays))} active days${s.first ? p.dim(` since ${s.first}`) : ''}   ${p.ship(fmt(s.aiCommits))} commits shipped with AI ${p.dim(`on ${fmt(s.shippedDays)} days`)}`,
+    `${fmt(s.messages)} messages · ${fmt(s.toolCalls)} tool calls · ${compact(s.input + s.output + s.cacheRead + s.cacheWrite)} tokens${s.busiest ? p.dim(`   busiest day ${s.busiest.date}, ${fmt(s.busiest.messages)} messages`) : ''}`,
+    p.dim(profile.profileUrl),
+  ]
+  console.log(out.join('\n'))
+}
+
+// Board options from words or flags: `board 7d shipped claude`, `--from … --to …`.
+export function boardQuery(words, values) {
+  const params = new URLSearchParams()
+  for (const word of words.map(w => w.toLowerCase())) {
+    if (PERIODS.includes(word)) params.set('period', word)
+    else if (METRICS.includes(word)) params.set('metric', word)
+    else if (TOOLS.includes(word)) params.set('tool', word)
+    else throw new Error(`"${word}" is not a period (${PERIODS.join(', ')}), a ranking (${METRICS.join(', ')}) or a tool (${TOOLS.join(', ')}).`)
+  }
+  if (values.from || values.to) {
+    if (!values.from || !values.to) throw new Error('A custom range needs both --from and --to (YYYY-MM-DD).')
+    params.set('from', values.from)
+    params.set('to', values.to)
+    params.delete('period')
+  }
+  return params
+}
+
+const METRIC_LABEL = { consistency: 'active days', shipped: 'commits shipped with AI', streak: 'current streak', tokens: 'tokens' }
+
+// `vibestreak board`: the top ten, a four-week strip per person, and your
+// own row pinned below when you rank lower.
+export async function boardView({ server, words, values, you, columns }) {
+  const p = painter()
+  const params = boardQuery(words, values)
+  params.set('limit', String(values.limit ?? 10))
+  if (you) params.set('you', you)
+  const b = await getJson(server, `/api/v1/board?${params}`)
+  const period = b.range ? `${b.range.from} → ${b.range.to}` : { today: 'today', all: 'all time' }[b.period] ?? `last ${b.period}`
+  console.log(`${p.bold('Leaderboard')} ${p.dim(`· ${METRIC_LABEL[b.metric]} · ${period}${b.tool ? ` · ${TOOL_NAMES[b.tool]}` : ''} · ${plural(b.total, 'developer')}`)}`)
+  if (!b.rows.length) return console.log(p.dim('Nobody here yet for these days.'))
+  const wide = columns >= 96
+  const handleWidth = Math.min(22, Math.max(8, ...b.rows.map(r => r.handle.length + 1)))
+  const header = [pad('#', 4), pad('developer', handleWidth + 1), wide ? pad('last 4 weeks', 29) : '', pad('active', 7, true), pad('streak', 8, true), pad('shipped', 9, true), pad('tokens', 8, true)].join(' ')
+  console.log(p.dim(header))
+  const line = r => {
+    const me = you && r.handle.toLowerCase() === you.toLowerCase()
+    const name = pad(`@${r.handle}`, handleWidth + 1)
+    return [
+      pad(String(r.rank), 4),
+      me ? p.bold(name) : name,
+      wide ? pad(recent(p, r.strip), 29) : '',
+      pad(fmt(r.activeDays), 7, true),
+      pad(`${fmt(r.streak)}d`, 8, true),
+      pad(p.ship(fmt(r.aiCommits)), 9, true),
+      pad(compact(r.tokens), 8, true),
+    ].join(' ') + (me ? p.dim('  ← you') : '')
+  }
+  for (const r of b.rows) console.log(line(r))
+  if (b.you && b.you.rank > b.rows.length) console.log(`${p.dim('  …')}\n${line(b.you)}`)
+  console.log(p.dim(`\nMore: vibestreak board [today|7d|30d|90d|all] [consistency|shipped|streak|tokens] [tool]   ·   ${new URL('/', server)}`))
+}
+
+// `vibestreak today`: who is coding with AI today, and whose streak ends at midnight.
+export async function todayView({ server }) {
+  const p = painter()
+  const t = await getJson(server, '/api/v1/today')
+  console.log(`${p.color('#3fb950', '●')} ${p.bold(plural(t.active.length, 'developer'))} coding with AI today ${p.dim(`(of ${fmt(t.developers)})`)}`)
+  for (const r of t.active.slice(0, 15)) console.log(`  @${pad(r.handle, 22)} ${pad(`${fmt(r.streak)}d`, 6, true)}  ${p.dim(toolList(r.tools))}`)
+  if (t.atRisk.length) {
+    console.log(`\n${p.ship(`${plural(t.atRisk.length, 'streak')} at risk`)} ${p.dim('· ends at their midnight')}`)
+    for (const r of t.atRisk.slice(0, 10)) console.log(`  @${pad(r.handle, 22)} ${pad(p.ship(`${fmt(r.streak)}d`), 6, true)}`)
+  }
+}
+
+// Plain `vibestreak`: your streak, the last twelve weeks, your rank, and
+// what to run next.
+export async function dashboardView({ server, token, handle, columns }) {
+  const p = painter()
+  const [profile, b] = await Promise.all([
+    getJson(server, `/api/v1/users/${encodeURIComponent(handle)}.json`, token),
+    getJson(server, `/api/v1/board?limit=0&you=${encodeURIComponent(handle)}`).catch(() => null),
+  ])
+  const rank = b?.you ? `#${b.you.rank} of ${fmt(b.total)} ${p.dim('· 30 days, consistency')}` : p.dim('not on the public board')
+  console.log(`${p.bold(`@${profile.handle}`)}  ${rank}`)
+  console.log(streakLine(p, profile))
+  console.log('')
+  console.log(heatmap(p, profile.days, profile.today, { columns: Math.min(columns, 31), first: profile.summary.first }))
+  console.log('')
+  console.log(p.dim('vibestreak me · board · today · status · help'))
+}