claude-discover 1.9.2 → 1.9.5

package/bin/claude/statusline.mjs

@@ -1,13 +1,7 @@
 #!/usr/bin/env node
-//
-// Claude Code status line. Reads the hook JSON from stdin and prints one colored line
-// summarizing the model, context-window usage, token totals, and rate-limit windows.
-// Installed as the `statusLine` command from the app: StatusBar → Status line → Activate
-// (see src/main/services/switchers/StatuslineSwitch.js).
-//
-// Example output:
-//   [Opus 4.8] Context: ▓▓▓░░░░░░░ 32% used (45.2k, 87% cached)  |  Tokens: 1.2M total (+45.2k, 3 turns)  |  Usage limit: 42% used (resets in 2h 30m)  |  Weekly limit: 18% used (resets in 3d 4h)
-//
+// Claude Code status line, installed by StatuslineSwitch. Reads the hook JSON from stdin and
+// prints one colored line — model, context usage, token totals, rate-limit windows:
+//   [Opus 4.8] Context: ▓▓▓░░░░░░░ 32% used (45.2k, 87% cached)  |  Tokens: 1.2M total (+45.2k, 3 turns)  |  Usage limit: 42% used (resets in 2h 30m)
 
 import { readFileSync } from 'node:fs'
 import { styleText } from 'node:util'

package/bin/proxy.mjs

@@ -1,15 +1,13 @@
 // Local logging proxy for Claude Code's API traffic — captures what transcripts never record
 // (system prompt, tool definitions, injected reminders, request params) plus the raw responses.
-// Claude Code is pointed at it via env.ANTHROPIC_BASE_URL (installed by the app's StatusBar
-// Activate button); started manually with `npm run proxy`. Capture must never fail or delay a request — errors go
-// to ~/.claude-discover/proxy.error.log instead of the client.
+// Capture must never fail or delay a request: errors go to ~/.claude-discover/proxy.error.log.
 //
-// Usage: node bin/proxy.mjs [--restart] — port/upstream/dir come from proxy.config.js ($CLAUDE_DISCOVER_* env overrides used only by tests)
+// Usage: node bin/proxy.mjs [--restart] — config in proxy.config.js. ProxySwitch runs it as a
+// login service (LoginService) and points Claude Code here via env.ANTHROPIC_BASE_URL.
 
 import fs from 'node:fs'
 import path from 'node:path'
 import http from 'node:http'
-import { spawn } from 'node:child_process'
 import https from 'node:https'
 import zlib from 'node:zlib'
 import crypto from 'node:crypto'
@@ -56,34 +54,42 @@ function createProxy({ upstream, onExchange, onError, errorBody }) {
       delete headers['accept-encoding']
     }
 
-    const up = mod.request(new URL(req.url, upstream), { method: req.method, headers }, upRes => {
-      const resHeaders = { ...upRes.headers }
-      delete resHeaders['transfer-encoding'] // node re-frames the piped body itself
-      delete resHeaders.connection
-      res.writeHead(upRes.statusCode, resHeaders)
-      const chunks = []
-      upRes.on('data', c => chunks.push(c))
-      upRes.pipe(res)
-      // 'close' fires after 'end' and also on an aborted stream — a truncated body is still captured
-      upRes.on('close', () => {
-        finish(upRes.statusCode, upRes.headers, decode(upRes.headers['content-encoding'], Buffer.concat(chunks)))
-        if (!upRes.complete) res.destroy() // upstream died mid-body — surface the reset so the client can retry
+    let up, resent = false
+    const send = () => {
+      up = mod.request(new URL(req.url, upstream), { method: req.method, headers }, upRes => {
+        const resHeaders = { ...upRes.headers }
+        delete resHeaders['transfer-encoding'] // node re-frames the piped body itself
+        delete resHeaders.connection
+        res.writeHead(upRes.statusCode, resHeaders)
+        const chunks = []
+        upRes.on('data', c => chunks.push(c))
+        upRes.pipe(res)
+        // 'close' fires after 'end' and also on an aborted stream — a truncated body is still captured
+        upRes.on('close', () => {
+          finish(upRes.statusCode, upRes.headers, decode(upRes.headers['content-encoding'], Buffer.concat(chunks)))
+          if (!upRes.complete) res.destroy() // upstream died mid-body — surface the reset so the client can retry
+        })
       })
-    })
-    // Client gone mid-exchange — tear down upstream too; headersSent means upstream responded and its 'close' captures the partial body, otherwise log the attempt here (up.destroy() emits no 'error')
+      const cur = up
+      cur.on('error', err => {
+        if (done) return // our own up.destroy() below surfaces here as a 'socket hang up' — the client left, upstream is fine
+        // A pooled keep-alive socket the server closed just before we picked it: nothing reached upstream, so re-sending once is safe (Node's documented reusedSocket case)
+        if (cur.reusedSocket && err.code === 'ECONNRESET' && !resent) { resent = true; return send() }
+        onError(err, `${req.method} ${req.url} → ${upstream.host}`)
+        finish()
+        if (res.headersSent) return res.destroy() // mid-stream failure — never append an error body to a partially-piped response
+        res.writeHead(502, { 'content-type': 'application/json' })
+        res.end(errorBody(err))
+      })
+      cur.end(requestBody)
+    }
+    // Client gone mid-exchange — tear down upstream too; headersSent means upstream responded and its 'close' captures the partial body, otherwise log the attempt here
     res.on('close', () => {
       if (done) return
-      up.destroy()
       if (!res.headersSent) finish()
+      up.destroy()
     })
-    up.on('error', err => {
-      onError(err, `${req.method} ${req.url} → ${upstream.host}`)
-      finish()
-      if (res.headersSent) return res.destroy() // mid-stream failure — never append an error body to a partially-piped response
-      res.writeHead(502, { 'content-type': 'application/json' })
-      res.end(errorBody(err))
-    })
-    up.end(requestBody)
+    send()
   })
 }
 
@@ -228,35 +234,13 @@ function logError(err, context) {
 }
 
 const isMain = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href
-if (process.parentPort) {
-  // Forked as an Electron utility process (ProxySwitch): Chromium gives those a clean handle
-  // table, unlike the app's main process whose children inherit the dev CDP server's socket on
-  // Windows and keep its port bound after the app quits. Utility processes die with the app,
-  // so re-spawn detached from here (as node — no system `node` required) and relay an early
-  // exit code back as a message until the app kills this relay.
-  const child = spawn(process.execPath, process.argv.slice(1), {
-    detached: true, stdio: 'ignore', windowsHide: true,
-    env: { ...process.env, ELECTRON_RUN_AS_NODE: '1' },
-  })
-  child.once('exit', code => { process.parentPort.postMessage(code); process.exit(0) })
-}
-else if (isMain) {
+if (isMain) {
   const args = parseArgs({
     options: {
       restart: { type: 'boolean' }, // replace an already-running instance instead of exiting
     }
   })
   const upstream = new URL(UPSTREAM)
-  // Fail fast when the upstream is unreachable — a clear exit beats a proxy that 502s every request.
-  // Runs before --restart so a working instance is never replaced by a broken one. Exit code 2 is
-  // recognized by the app's ProxySwitch ("cannot reach upstream").
-  try {
-    await fetch(new URL('/v1/models', upstream), { signal: AbortSignal.timeout(5000) })
-  } catch (err) {
-    console.error(`Cannot reach ${upstream.origin} (${err?.cause?.code || err?.cause?.message || err?.name || err})`)
-    logError(err, `startup check → ${upstream.origin}`)
-    process.exit(2)
-  }
   const server = createProxy({
     upstream: upstream,
     onExchange: logRequest,
@@ -277,5 +261,8 @@ else if (isMain) {
     logError(err)
     process.exit(1)
   })
+  // Never die on a stray exception — log it and keep serving
+  process.on('uncaughtException', err => logError(err, 'uncaught exception'))
+  process.on('unhandledRejection', err => logError(err, 'unhandled rejection'))
   server.listen(PORT, HOST, () => console.log(`Capture proxy listening on ${PROXY_URL} → ${upstream.origin}\nLogging requests to ${REQUESTS_DIR}`))
 }