vibestreak 0.2.0 → 0.3.1

package/CHANGELOG.md

@@ -0,0 +1,45 @@
+# Changelog
+
+Any version runs with `npx vibestreak@<version>`; `npx vibestreak@latest autosync on`
+moves the background sync to the newest one.
+
+## 0.3.1 (2026-10-25)
+
+- `vibestreak --version` (or `-v`), and the version in `help` and `status`.
+- Says when a newer version is out: after `vibestreak`, `sync` and in `status`.
+- Sends its version with each sync. Settings shows each machine's version, and
+  the server can turn away versions too old to count correctly, with the
+  command that updates them.
+
+## 0.3.0 (2026-10-25)
+
+- First run: plain `npx vibestreak` signs in through the browser (no token to
+  copy), syncs, and offers background sync and the evening nudge.
+- `vibestreak setup [--token <t>]`: all of that with the defaults and no
+  questions; commit addresses come from git config.
+- `vibestreak login` signs in through the browser; `--token` still works.
+- `vibestreak pause [1h|3d|tomorrow]` and `resume`: the background syncs and
+  nudge skip their runs for up to 7 days, and nothing is lost.
+
+## 0.2.0 (2026-10-25)
+
+- `vibestreak` shows a dashboard: streak, level, a 12-week heatmap and your rank.
+- `vibestreak me`, `profile <handle>`, `board`, `today` in the terminal.
+- Syncs after the first one send only the last 7 days: about 3 seconds.
+
+## 0.1.2 (2026-10-25)
+
+- `vibestreak nudge at <time>`: when the evening streak check runs (17:00 to
+  23:30; 20:30 by default).
+
+## 0.1.1 (2026-10-25)
+
+- `vibestreak status`; plain `vibestreak nudge` shows the nudge's status.
+- The evening job runs `nudge run` (older schedules keep working).
+
+## 0.1.0 (2026-10-25)
+
+- First release: reads Claude Code, Codex, Cursor, Copilot (CLI and VS Code),
+  Gemini CLI, Antigravity and OpenCode history and git; syncs daily totals.
+- Background sync on macOS (launchd), Linux (systemd or cron) and Windows
+  (Task Scheduler), with the evening streak nudge.

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,4 +1,5 @@
 #!/usr/bin/env node
+import { createInterface } from 'node:readline/promises'
 import { fileURLToPath } from 'node:url'
 import { parseArgs } from 'node:util'
 
@@ -6,15 +7,19 @@ import { autosyncStatus, clock, installAutosync, nextRun, removeAutosync, SYNC_T
 import { NUDGE_DEFAULT, notify, nudgeAction, nudgeText, nudgeTimeOf, parseNudgeTime, shouldNudge } from '../src/nudge.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 { updateCommand, updateNotice, VERSION } from '../src/version.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.
+const HELP = `${BRAND} ${VERSION} — 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]
@@ -22,8 +27,10 @@ const HELP = `${BRAND} — share your AI coding heatmap: what you shipped, and h
   ${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)
@@ -34,7 +41,11 @@ 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
+  ${BRAND} --version                 this CLI's version
 
 Reads: Claude Code, Codex, Cursor, Copilot (CLI and VS Code), Gemini CLI,
 Antigravity and OpenCode history, and git.
@@ -47,10 +58,10 @@ 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 },
+    headers: { authorization: `Bearer ${config.token}`, 'content-type': 'application/json', 'x-vibestreak-cli': VERSION, 'user-agent': `${BRAND}/${VERSION}`, ...init.headers },
   })
   const body = await response.json().catch(() => ({}))
   if (!response.ok) throw new Error(body.error ?? `${response.status} ${response.statusText}`)
@@ -71,6 +82,10 @@ async function main() {
       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' },
+      version: { type: 'boolean', short: 'v' },
     },
   })
   const [command = 'dashboard', ...rest] = positionals
@@ -78,14 +93,20 @@ async function main() {
   const log = (...args) => values.quiet || console.log(...args)
 
   if (command === 'help' || values.help) return console.log(HELP)
+  if (command === 'version' || values.version) return console.log(VERSION)
   const columns = process.stdout.columns || 100
   const server = config.server ?? DEFAULT_SERVER
 
   if (command === 'dashboard') {
-    // Plain `vibestreak`: the dashboard once linked; before that, how to start.
-    if (!config.token) return console.log(`${HELP}\n\nGet started: ${server.replace(/\/$/, '')}/cli`)
+    // 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 })
+    await dashboardView({ server, token: config.token, handle: me.handle, columns })
+    return notice(config, me.cli)
   }
   if (command === 'me') {
     const me = await api(config, '/api/v1/me')
@@ -130,19 +151,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') {
@@ -150,7 +177,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)
 
@@ -180,6 +211,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))
@@ -210,6 +243,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) {
@@ -238,9 +328,16 @@ async function sync(config, values, log, isSync) {
   // 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)'}` : ''
   console.log(`${config.lastSync} uploaded ${result.days} days, ${result.commits} commits from ${s.repos} repos${streak} → ${result.profileUrl}`)
+  if (!values.quiet) notice(config, result.cli)
   return result
 }
 
+// Says so when a newer CLI is out (the server checks npm).
+function notice(config, cli) {
+  const line = updateNotice(cli, { brand: BRAND, autosync: config.autosync })
+  if (line) console.log(`\n${line}`)
+}
+
 const ago = iso => {
   if (!iso) return 'never'
   const minutes = Math.round((Date.now() - Date.parse(iso)) / 60000)
@@ -250,7 +347,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) {
@@ -274,7 +371,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}`)
 }
@@ -289,10 +388,14 @@ 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)
   row('Addresses', `${config.emails.join(', ') || 'none'}${github ? ` · +${github} from GitHub` : ''}`)
+  const update = me.error ? undefined : updateNotice(me.cli, { brand: BRAND, autosync: config.autosync })
+  row('Version', update ? `${VERSION} · ${me.cli.latest} is out: ${updateCommand(BRAND, config.autosync)}` : `${VERSION}${me.cli?.latest ? ' (latest)' : ''}`)
   row('Config', CONFIG_PATH)
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibestreak",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "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",
@@ -8,7 +8,7 @@
   "author": "Kingsbridge Consultancy LLC <support@kingsbridge-consultancy.com>",
   "type": "module",
   "bin": { "vibestreak": "bin/vibestreak.mjs" },
-  "files": ["bin", "src", "README.md", "LICENSE"],
+  "files": ["bin", "src", "README.md", "CHANGELOG.md", "LICENSE"],
   "engines": { "node": ">=22.13" },
   "os": ["darwin", "linux", "win32"],
   "scripts": { "test": "node --test test/*.test.mjs" }

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/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/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/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/version.mjs

@@ -0,0 +1,21 @@
+import { readFileSync } from 'node:fs'
+
+export const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version
+
+// Release versions only (x.y.z): negative when a is older than b.
+export function compareVersions(a, b) {
+  const pa = String(a).split('.').map(Number)
+  const pb = String(b).split('.').map(Number)
+  for (let i = 0; i < 3; i++) if ((pa[i] || 0) !== (pb[i] || 0)) return (pa[i] || 0) - (pb[i] || 0)
+  return 0
+}
+
+// One line when the server says a newer CLI is out; nothing otherwise. With
+// autosync on, the update command also moves the background jobs to it.
+export function updateNotice(cli, { brand = 'vibestreak', autosync = false, current = VERSION } = {}) {
+  if (!cli?.latest || compareVersions(current, cli.latest) >= 0) return undefined
+  return `${brand} ${cli.latest} is out (this is ${current}): ${updateCommand(brand, autosync)}.`
+}
+
+export const updateCommand = (brand, autosync) =>
+  autosync ? `\`npx ${brand}@latest autosync on\` updates the background sync to it` : `\`npx ${brand}@latest\` runs it`