claude-discover 1.10.4 → 1.10.6

package/bin/claude/statusline.mjs

@@ -1,125 +1,125 @@
-#!/usr/bin/env node
-// Claude Code status line, installed by StatuslineSwitch. Reads the hook JSON from stdin and
-// prints one colored line — model and effort, context usage, token totals, rate-limit windows:
-//   [Opus 4.8 high] Context: ▓▓▓░░░░░░░ 32% used (45.2k, 87% cached)  |  Tokens: 1.2M total (+45.2k, 3 turns)  |  Daily: 42% used (resets in 2h 30m)
-
-import { readFileSync } from 'node:fs'
-import { styleText } from 'node:util'
-
-
-// Formatting
-const THRESHOLDS = { // (white, yellow, red)
-  context: [0, 100_000, 250_000],
-  limit:   [0, 60, 90],
-  cache:   [90, 60, 0],
-  tokens:  [0, 250_000, 1_000_000],
-  session: [0, 3_000_000, 8_000_000],
-  turns:   [0, 10, 25],
-}
-
-const NO_COLOR = process.env.NO_COLOR !== undefined // standard opt-out; styleText can't honor it for piped output, so gate here
-
-function colorize(kind, text, value = 0) {
-  const bounds = THRESHOLDS[kind]
-  const n = bounds.filter(b => value >= b).length
-  const TIERS  = [null, 'yellow', 'red'] // indexed by severity tier
-  const idx = bounds[0] < bounds.at(-1) ? n - 1 : bounds.length - n
-  const color = TIERS[idx]
-  // validateStream:false forces codes through the pipe (statusline output isn't a TTY)
-  return color && !NO_COLOR ? styleText(color, text, { validateStream: false }) : text
-}
-
-
-// Collect stdin data
-const data = JSON.parse(readFileSync(0, 'utf-8')) // fd 0 = stdin
-const modelName = data.model?.display_name?.replace('Claude ', '') || '?'
-const effort    = data.effort?.level // absent when the model doesn't support effort
-const parts = []
-
-
-
-// Context window
-const ctx = data.context_window || {}
-const total = ctx.context_window_size || 0
-if (total) {
-  const usage = ctx.current_usage || {}
-  const hit  = usage.cache_read_input_tokens || 0
-  const used = hit + (usage.cache_creation_input_tokens || 0) + (usage.input_tokens || 0)
-  const pct  = Math.round((used / total) * 100)
-  const cpct = used ? Math.floor((hit * 100) / used) : 0
-  const filled = Math.floor(pct / 10)
-  const bar    = '▓'.repeat(filled) + '░'.repeat(10 - filled)
-  const head   = colorize('context', `${bar} ${pct}% used`, used)
-  const tokens = colorize('context', `${(used / 1000).toFixed(1)}k`, used)
-  const cached = used ? colorize('cache', `${cpct}% cached`, cpct) : `${cpct}% cached`
-  parts.push(`Context: ${head} (${tokens}, ${cached})`)
-}
-
-
-
-// Total tokens (per session and per reply loop)
-function agentLoopUsage(transcriptPath) { // Read the transcript JSONL and sum API usage for the current agent loop and the whole session.
-  const lines   = readFileSync(transcriptPath, 'utf-8').split(/\r?\n/).filter(Boolean)
-  let loop      = { total: 0, turns: 0 } // last prompt-reply breakdown
-  const session = { total: 0, turns: 0 } // whole-session breakdown
-  let seen = new Set() // One API response spans multiple lines (one per content block), each repeating the usage block, so dedupe by message.id.
-
-  for (const line of lines) {
-    let e
-    try { e = JSON.parse(line) } catch { continue } // the transcript may be mid-append — skip a half-written line
-    const msg = e.message || {}
-
-    if (e.type === 'user' && !e.isMeta) {
-      const isToolReply = Array.isArray(msg.content) && msg.content.some(b => b.type === 'tool_result')
-      if (!isToolReply) { // real user prompt = new loop
-        loop = { total: 0, turns: 0 }
-        seen = new Set()
-      }
-    } else if (e.type === 'assistant' && !seen.has(msg.id)) {
-      seen.add(msg.id)
-      const u = msg.usage || {}
-      const tokens = (u.input_tokens || 0) + (u.output_tokens || 0) + (u.cache_creation_input_tokens || 0) + (u.cache_read_input_tokens || 0)
-      for (const d of [loop, session]) {
-        d.total += tokens
-        d.turns += 1
-      }
-    }
-  }
-  return [loop, session]
-}
-
-if (data.transcript_path) {
-  const [loop, session] = agentLoopUsage(data.transcript_path)
-  const fmt = n => n >= 1_000_000 ? `${(n / 1_000_000).toFixed(1)}M` : `${(n / 1000).toFixed(1)}k`
-  const tokensS = colorize('tokens',  fmt(loop.total),    loop.total)
-  const sessS   = colorize('session', fmt(session.total), session.total)
-  const turnsS  = colorize('turns', `${loop.turns} turn${loop.turns !== 1 ? 's' : ''}`, loop.turns)
-  parts.push(`Tokens: ${sessS} total (+${tokensS}, ${turnsS})`)
-}
-
-
-
-// Rate limits (5-hour and weekly windows)
-function fmtReset(resetsAt) { // Format remaining time until a unix-epoch reset, e.g. "2h 30m" (null if no timestamp).
-  if (!resetsAt) return null
-  const secs = Math.max(0, Math.floor(Number(resetsAt)) - Math.floor(Date.now() / 1000))
-  const min  = Math.floor(secs / 60) % 60
-  const hrs  = Math.floor(secs / 3600) % 24
-  const days = Math.floor(secs / 86400)
-  if (days) return `${days}d ${hrs}h`
-  if (hrs)  return `${hrs}h ${min}m`
-  return `${min}m`
-}
-
-const rl = data.rate_limits || {}
-for (const [label, window] of [['Daily', rl.five_hour], ['Weekly', rl.seven_day]]) {
-  if (!window) continue
-  const pct      = Math.floor(window.used_percentage || 0)
-  const reset    = fmtReset(window.resets_at)
-  const resetStr = reset ? ` (resets in ${reset})` : ''
-  parts.push(`${label}: ${colorize('limit', `${pct}% used${resetStr}`, pct)}`)
-}
-
-
-// Status line
-process.stdout.write(`[${modelName}${effort ? ` ${effort}` : ''}] ` + parts.join('  |  ') + '\n')
+#!/usr/bin/env node
+// Claude Code status line, installed by StatuslineSwitch. Reads the hook JSON from stdin and
+// prints one colored line — model and effort, context usage, token totals, rate-limit windows:
+//   [Opus 4.8 high] Context: ▓▓▓░░░░░░░ 32% used (45.2k, 87% cached)  |  Tokens: 1.2M total (+45.2k, 3 turns)  |  Daily: 42% used (resets in 2h 30m)
+
+import { readFileSync } from 'node:fs'
+import { styleText } from 'node:util'
+
+
+// Formatting
+const THRESHOLDS = { // (white, yellow, red)
+  context: [0, 100_000, 250_000],
+  limit:   [0, 60, 90], // keep in sync with src/renderer/utils/thresholds.js
+  cache:   [90, 60, 0],
+  tokens:  [0, 250_000, 1_000_000],
+  session: [0, 3_000_000, 8_000_000],
+  turns:   [0, 10, 25],
+}
+
+const NO_COLOR = process.env.NO_COLOR !== undefined // standard opt-out; styleText can't honor it for piped output, so gate here
+
+function colorize(kind, text, value = 0) {
+  const bounds = THRESHOLDS[kind]
+  const n = bounds.filter(b => value >= b).length
+  const TIERS  = [null, 'yellow', 'red'] // indexed by severity tier
+  const idx = bounds[0] < bounds.at(-1) ? n - 1 : bounds.length - n
+  const color = TIERS[idx]
+  // validateStream:false forces codes through the pipe (statusline output isn't a TTY)
+  return color && !NO_COLOR ? styleText(color, text, { validateStream: false }) : text
+}
+
+
+// Collect stdin data
+const data = JSON.parse(readFileSync(0, 'utf-8')) // fd 0 = stdin
+const modelName = data.model?.display_name?.replace('Claude ', '') || '?'
+const effort    = data.effort?.level // absent when the model doesn't support effort
+const parts = []
+
+
+
+// Context window
+const ctx = data.context_window || {}
+const total = ctx.context_window_size || 0
+if (total) {
+  const usage = ctx.current_usage || {}
+  const hit  = usage.cache_read_input_tokens || 0
+  const used = hit + (usage.cache_creation_input_tokens || 0) + (usage.input_tokens || 0)
+  const pct  = Math.round((used / total) * 100)
+  const cpct = used ? Math.floor((hit * 100) / used) : 0
+  const filled = Math.floor(pct / 10)
+  const bar    = '▓'.repeat(filled) + '░'.repeat(10 - filled)
+  const head   = colorize('context', `${bar} ${pct}% used`, used)
+  const tokens = colorize('context', `${(used / 1000).toFixed(1)}k`, used)
+  const cached = used ? colorize('cache', `${cpct}% cached`, cpct) : `${cpct}% cached`
+  parts.push(`Context: ${head} (${tokens}, ${cached})`)
+}
+
+
+
+// Total tokens (per session and per reply loop)
+function agentLoopUsage(transcriptPath) { // Read the transcript JSONL and sum API usage for the current agent loop and the whole session.
+  const lines   = readFileSync(transcriptPath, 'utf-8').split(/\r?\n/).filter(Boolean)
+  let loop      = { total: 0, turns: 0 } // last prompt-reply breakdown
+  const session = { total: 0, turns: 0 } // whole-session breakdown
+  let seen = new Set() // One API response spans multiple lines (one per content block), each repeating the usage block, so dedupe by message.id.
+
+  for (const line of lines) {
+    let e
+    try { e = JSON.parse(line) } catch { continue } // the transcript may be mid-append — skip a half-written line
+    const msg = e.message || {}
+
+    if (e.type === 'user' && !e.isMeta) {
+      const isToolReply = Array.isArray(msg.content) && msg.content.some(b => b.type === 'tool_result')
+      if (!isToolReply) { // real user prompt = new loop
+        loop = { total: 0, turns: 0 }
+        seen = new Set()
+      }
+    } else if (e.type === 'assistant' && !seen.has(msg.id)) {
+      seen.add(msg.id)
+      const u = msg.usage || {}
+      const tokens = (u.input_tokens || 0) + (u.output_tokens || 0) + (u.cache_creation_input_tokens || 0) + (u.cache_read_input_tokens || 0)
+      for (const d of [loop, session]) {
+        d.total += tokens
+        d.turns += 1
+      }
+    }
+  }
+  return [loop, session]
+}
+
+if (data.transcript_path) {
+  const [loop, session] = agentLoopUsage(data.transcript_path)
+  const fmt = n => n >= 1_000_000 ? `${(n / 1_000_000).toFixed(1)}M` : `${(n / 1000).toFixed(1)}k`
+  const tokensS = colorize('tokens',  fmt(loop.total),    loop.total)
+  const sessS   = colorize('session', fmt(session.total), session.total)
+  const turnsS  = colorize('turns', `${loop.turns} turn${loop.turns !== 1 ? 's' : ''}`, loop.turns)
+  parts.push(`Tokens: ${sessS} total (+${tokensS}, ${turnsS})`)
+}
+
+
+
+// Rate limits (5-hour and weekly windows)
+function fmtReset(resetsAt) { // Format remaining time until a unix-epoch reset, e.g. "2h 30m" (null if no timestamp).
+  if (!resetsAt) return null
+  const secs = Math.max(0, Math.floor(Number(resetsAt)) - Math.floor(Date.now() / 1000))
+  const min  = Math.floor(secs / 60) % 60
+  const hrs  = Math.floor(secs / 3600) % 24
+  const days = Math.floor(secs / 86400)
+  if (days) return `${days}d ${hrs}h`
+  if (hrs)  return `${hrs}h ${min}m`
+  return `${min}m`
+}
+
+const rl = data.rate_limits || {}
+for (const [label, window] of [['Daily', rl.five_hour], ['Weekly', rl.seven_day]]) {
+  if (!window) continue
+  const pct      = Math.floor(window.used_percentage || 0)
+  const reset    = fmtReset(window.resets_at)
+  const resetStr = reset ? ` (resets in ${reset})` : ''
+  parts.push(`${label}: ${colorize('limit', `${pct}% used${resetStr}`, pct)}`)
+}
+
+
+// Status line
+process.stdout.write(`[${modelName}${effort ? ` ${effort}` : ''}] ` + parts.join('  |  ') + '\n')

package/bin/claude-discover.mjs

@@ -3,8 +3,8 @@
 // Electron binary at the package root, whose package.json main is out/main/main.js.
 import { spawn } from 'node:child_process'
 import { existsSync } from 'node:fs'
+import { access, constants } from 'node:fs/promises'
 import { fileURLToPath } from 'node:url'
-import electron from 'electron' // under plain node the electron package exports its binary path
 
 const appDir = fileURLToPath(new URL('..', import.meta.url))
 if (!existsSync(new URL('../out/main/main.js', import.meta.url))) {
@@ -12,5 +12,36 @@ if (!existsSync(new URL('../out/main/main.js', import.meta.url))) {
   process.exit(1)
 }
 
+
+if (process.platform === 'linux') { // @linux
+  // Importing electron downloads its binary on first run, which can't unzip into a root-owned `sudo npm i -g` install,
+  // so it's imported dynamically, only after this check (a static import is hoisted and would run first)
+
+  const electronDir = new URL('.', import.meta.resolve('electron'))
+  const isWritable = await access(electronDir, constants.W_OK).then(() => true, () => false)
+  if (!existsSync(new URL('path.txt', electronDir)) && !isWritable) {
+    console.error(`
+Electron can't finish installing — its folder isn't writable by your user.
+
+Global npm packages shouldn't need sudo. The recommended setup is Node from a version
+manager like nvm, which keeps global npm packages in your home folder:
+
+  sudo npm uninstall -g claude-discover
+  wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.8/install.sh | bash
+
+Then open a new terminal and run:
+
+  nvm install --lts
+  npm install -g claude-discover
+  claude-discover
+
+See https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally`)
+    process.exit(1)
+  }
+}
+
+
+const { default: electron } = await import('electron') // under plain node the electron package exports its binary path
+
 spawn(electron, [appDir, ...process.argv.slice(2)], { stdio: 'inherit' })
   .on('close', code => process.exit(code ?? 0))

package/bin/update.mjs

@@ -1,42 +1,42 @@
-// Updates an `npm i -g` install from outside it. AutoUpdate starts it detached as the app quits:
-// Windows locks the app's running electron.exe, so npm can only replace the package once the app is gone.
-
-import { spawn, spawnSync } from 'node:child_process'
-import path from 'node:path'
-import { setTimeout as sleep } from 'node:timers/promises'
-import { parseArgs } from 'node:util'
-
-
-// ── 1. CLI, then wait for the app to exit ────────────────────────────────────
-
-const { values, positionals: [pid, version] } = parseArgs({
-  allowPositionals: true,
-  options: {
-    'no-reopen': { type: 'boolean' },
-    'help':      { type: 'boolean', short: 'h' },
-  },
-})
-
-if (values.help || !version) {
-  console.error('Usage: node bin/update.mjs <pid> <version> [--no-reopen]')
-  process.exit(1)
-}
-
-while (true) {
-  try {
-    process.kill(Number(pid), 0)
-  } catch (err) {
-    if (err.code !== 'EPERM') break // EPERM: alive, just not ours to signal
-  }
-  await sleep(200)
-}
-
-
-// ── 2. Update and reopen ─────────────────────────────────────────────────────
-
-const { status } = spawnSync(`npm i -g claude-discover@${version} --loglevel=http`, { shell: true, stdio: 'inherit' })
-if (status !== 0) await sleep(5_000) // leaves npm's error readable before the window closes
-
-// Reopen even after a failed update; dev passes --no-reopen, as its Vite renderer died with the app
-const globalBin = path.join(spawnSync('npm root -g', { shell: true, encoding: 'utf8' }).stdout.trim(), 'claude-discover/bin/claude-discover.mjs')
-if (!values['no-reopen']) spawn(process.execPath, [globalBin], { detached: true, stdio: 'ignore' }).unref()
+// Updates an `npm i -g` install from outside it. AutoUpdate starts it detached as the app quits:
+// Windows locks the app's running electron.exe, so npm can only replace the package once the app is gone.
+
+import { spawn, spawnSync } from 'node:child_process'
+import path from 'node:path'
+import { setTimeout as sleep } from 'node:timers/promises'
+import { parseArgs } from 'node:util'
+
+
+// ── 1. CLI, then wait for the app to exit ────────────────────────────────────
+
+const { values, positionals: [pid, version] } = parseArgs({
+  allowPositionals: true,
+  options: {
+    'no-reopen': { type: 'boolean' },
+    'help':      { type: 'boolean', short: 'h' },
+  },
+})
+
+if (values.help || !version) {
+  console.error('Usage: node bin/update.mjs <pid> <version> [--no-reopen]')
+  process.exit(1)
+}
+
+while (true) {
+  try {
+    process.kill(Number(pid), 0)
+  } catch (err) {
+    if (err.code !== 'EPERM') break // EPERM: alive, just not ours to signal
+  }
+  await sleep(200)
+}
+
+
+// ── 2. Update and reopen ─────────────────────────────────────────────────────
+
+const { status } = spawnSync(`npm i -g claude-discover@${version} --loglevel=http`, { shell: true, stdio: 'inherit' })
+if (status !== 0) await sleep(5_000) // leaves npm's error readable before the window closes
+
+// Reopen even after a failed update; dev passes --no-reopen, as its Vite renderer died with the app
+const globalBin = path.join(spawnSync('npm root -g', { shell: true, encoding: 'utf8' }).stdout.trim(), 'claude-discover/bin/claude-discover.mjs')
+if (!values['no-reopen']) spawn(process.execPath, [globalBin], { detached: true, stdio: 'ignore' }).unref()