@gotcos/glasses-server 6.1.0

package/server/routes/diag.ts

@@ -0,0 +1,115 @@
+// POST /api/diag/client — Client-side diagnostic log sink.
+//
+// Accepts JSON blobs from the COS Glasses WebView and appends them to a
+// JSONL file for post-crash analysis. Unauth'd (same whitelist as /health)
+// so it works during the boot-time heartbeat before the wizard has supplied
+// an API token.
+//
+// Shipped in v5.3.4 to debug the "45-chunk mystery crash" (2026-04-11).
+// Volume is expected to be tiny: ~6 heartbeats/minute during meetings + a
+// handful of error events on failures. The server caps file size at 10 MB
+// and rotates to `.1` when full (keeps only 1 rotation — this is a
+// debug-only facility, not a long-term archive).
+
+import { Router } from 'express'
+import { writeFileSync, existsSync, mkdirSync, appendFileSync, statSync, renameSync } from 'node:fs'
+import { resolve, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url))
+import { dataPath } from '../lib/data-dir.js'
+const DIAG_DIR = dataPath()
+const DIAG_FILE = resolve(DIAG_DIR, 'client-diagnostics.jsonl')
+const MAX_FILE_BYTES = 10 * 1024 * 1024  // 10 MB cap
+
+if (!existsSync(DIAG_DIR)) mkdirSync(DIAG_DIR, { recursive: true })
+if (!existsSync(DIAG_FILE)) writeFileSync(DIAG_FILE, '')
+
+export const diagRouter = Router()
+
+// In-memory rate limit: max 30 entries per 10 s window per sessionId (or anon).
+// Prevents a runaway error loop from flooding the log.
+const rateWindows = new Map<string, { windowStart: number; count: number }>()
+const RATE_WINDOW_MS = 10_000
+const RATE_MAX_PER_WINDOW = 30
+
+function rateLimited(key: string): boolean {
+  const now = Date.now()
+  const bucket = rateWindows.get(key)
+  if (!bucket || now - bucket.windowStart > RATE_WINDOW_MS) {
+    rateWindows.set(key, { windowStart: now, count: 1 })
+    return false
+  }
+  bucket.count++
+  return bucket.count > RATE_MAX_PER_WINDOW
+}
+
+function rotateIfOversized(): void {
+  try {
+    const stats = statSync(DIAG_FILE)
+    if (stats.size > MAX_FILE_BYTES) {
+      const rotated = DIAG_FILE + '.1'
+      renameSync(DIAG_FILE, rotated)
+      writeFileSync(DIAG_FILE, '')
+      console.log(`[diag] Rotated ${DIAG_FILE} → ${rotated} (was ${stats.size} bytes)`)
+    }
+  } catch { /* best-effort */ }
+}
+
+diagRouter.post('/diag/client', async (req, res) => {
+  const body = req.body as Record<string, unknown>
+
+  // Must have a timestamp and an event name — everything else is optional
+  const ts = typeof body.ts === 'number' ? body.ts : Date.now()
+  const level = typeof body.level === 'string' ? body.level : 'info'
+  const event = typeof body.event === 'string' ? body.event : 'unknown'
+  const sessionId = typeof body.sessionId === 'string' ? body.sessionId : null
+  const data = (body.data && typeof body.data === 'object') ? body.data : {}
+
+  // Reject orphan heartbeats from zombie clients (session was deleted/saved already).
+  // 410 Gone tells client to stop hitting this endpoint and reset its session state.
+  if (sessionId && event === 'heartbeat') {
+    try {
+      const { isSessionDeleted } = await import('./transcribe-stream.js')
+      if (isSessionDeleted(sessionId)) {
+        return res.status(410).json({ error: 'session_deleted', sessionId })
+      }
+    } catch { /* import failure: fall through to normal logging */ }
+  }
+
+  // Rate limit per sessionId (or remote address as fallback)
+  const rateKey = sessionId || req.ip || 'anon'
+  if (rateLimited(rateKey)) {
+    return res.status(429).json({ error: 'rate_limited' })
+  }
+
+  // Rotate if oversized (cheap — stat call + optional rename)
+  rotateIfOversized()
+
+  const line = JSON.stringify({
+    ts,
+    level,
+    event,
+    sessionId,
+    data,
+    server_received: Date.now(),
+  }) + '\n'
+
+  try {
+    appendFileSync(DIAG_FILE, line)
+    res.status(204).end()
+  } catch (err: any) {
+    console.error(`[diag] Failed to append: ${err?.message ?? err}`)
+    res.status(500).json({ error: 'write_failed' })
+  }
+})
+
+// GET /api/diag/health — quick check that the diag endpoint is reachable.
+// Also returns current file size so clients can verify writes are landing.
+diagRouter.get('/diag/health', (_req, res) => {
+  let size = 0
+  try {
+    size = statSync(DIAG_FILE).size
+  } catch { /* file missing is OK, will be created on next POST */ }
+  res.json({ ok: true, file: DIAG_FILE, size })
+})

package/server/routes/display.ts

@@ -0,0 +1,65 @@
+// GET /api/display-stream — SSE endpoint for glasses display sync
+// Any connected glasses client receives real-time query responses
+// regardless of which interface submitted the query
+
+import { Router } from 'express'
+import { onDisplay, emitDisplay } from '../lib/display-bus.js'
+
+export const displayRouter = Router()
+
+// Replay buffer — last N events so reconnecting clients don't miss in-flight data
+const REPLAY_BUFFER_SIZE = 20
+let eventId = 0
+const replayBuffer: Array<{ id: number; type: string; data: string }> = []
+
+displayRouter.get('/display-stream', (req, res) => {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive',
+    'X-Accel-Buffering': 'no',
+    'Access-Control-Allow-Origin': '*',  // Even Hub WebView loads from file:// — needs explicit CORS
+  })
+  res.flushHeaders()
+
+  // Tell EventSource to retry quickly on disconnect (3s instead of browser default ~5-10s)
+  res.write('retry: 3000\n\n')
+
+  // Replay missed events if client sends Last-Event-ID (browser does this automatically)
+  const lastId = parseInt(req.headers['last-event-id'] as string, 10)
+  if (!isNaN(lastId) && lastId > 0) {
+    const missed = replayBuffer.filter(e => e.id > lastId)
+    for (const e of missed) {
+      res.write(`id: ${e.id}\nevent: ${e.type}\ndata: ${e.data}\n\n`)
+    }
+    if (missed.length > 0) {
+      console.log(`[display-bus] Replayed ${missed.length} events for reconnecting client (from id ${lastId})`)
+    }
+  }
+
+  // Keepalive ping every 15s — more aggressive to survive meshnet/proxy timeouts
+  const ping = setInterval(() => {
+    try { res.write(': keepalive\n\n') } catch { /* client gone */ }
+  }, 15_000)
+
+  const unsub = onDisplay((event) => {
+    eventId++
+    const data = JSON.stringify(event.data)
+    // Buffer for replay
+    replayBuffer.push({ id: eventId, type: event.type, data })
+    if (replayBuffer.length > REPLAY_BUFFER_SIZE) replayBuffer.shift()
+    // Send with id for Last-Event-ID tracking
+    try { res.write(`id: ${eventId}\nevent: ${event.type}\ndata: ${data}\n\n`) } catch { /* client gone */ }
+  })
+
+  req.on('close', () => {
+    clearInterval(ping)
+    unsub()
+  })
+})
+
+// POST /api/display-session — broadcast session restore to glasses (cross-surface sync)
+displayRouter.post('/display-session', (req, res) => {
+  emitDisplay({ type: 'session_restore', data: req.body })
+  res.json({ ok: true })
+})

package/server/routes/health.ts

@@ -0,0 +1,128 @@
+import { Router } from 'express'
+import { execFile } from 'node:child_process'
+import { statSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { COS_SCRIPTS_DIR, COS_MODE, PYTHON_BIN } from '../lib/python-bridge.js'
+import { serverMetrics } from '../index.js'
+import { isSileroAvailable } from '../lib/vad-silero.js'
+import { getAvailableCliSessionId } from '../lib/claude-bridge.js'
+import { isWhisperLocalAvailable, getWhisperHealth } from '../lib/whisper-local.js'
+import { getOpenAIWhisperBudgetState } from '../lib/openai-whisper-budget.js'
+import { getKeyStatus } from '../lib/openai-key.js'
+
+export const healthRouter = Router()
+
+healthRouter.get('/health', async (_req, res) => {
+  const checks: Record<string, string | number> = {
+    status: 'ok',
+    mode: COS_MODE ? 'cos' : 'standalone',
+    server: 'ok',
+    python: 'unknown',
+    claude: 'unknown',
+    codex: 'unknown',
+    uptime_seconds: Math.floor((Date.now() - serverMetrics.startedAt) / 1000),
+    request_count: serverMetrics.requestCount,
+  }
+
+  // Feature detection flags
+  let claudeAvailable = false
+  let codexAvailable = false
+
+  // Check Python venv (COS mode only)
+  if (PYTHON_BIN) {
+    try {
+      await new Promise<void>((resolve, reject) => {
+        execFile(PYTHON_BIN!, ['--version'], { timeout: 5000 }, (err, stdout) => {
+          if (err) return reject(err)
+          checks.python = stdout.trim()
+          resolve()
+        })
+      })
+    } catch {
+      checks.python = 'error'
+    }
+  } else {
+    checks.python = 'standalone'
+  }
+
+  // Check claude CLI
+  try {
+    await new Promise<void>((resolve, reject) => {
+      execFile('claude', ['--version'], { timeout: 5000 }, (err, stdout) => {
+        if (err) return reject(err)
+        checks.claude = stdout.trim()
+        claudeAvailable = true
+        resolve()
+      })
+    })
+  } catch {
+    checks.claude = 'error'
+  }
+
+  // Check Codex CLI. The desktop CLI can print benign PATH warnings to stderr,
+  // so version extraction uses stdout + stderr and looks for the codex-cli line.
+  try {
+    await new Promise<void>((resolve, reject) => {
+      execFile('codex', ['--version'], { timeout: 5000 }, (err, stdout, stderr) => {
+        if (err) return reject(err)
+        const combined = `${stdout}\n${stderr}`.trim()
+        const versionLine = combined.split('\n').map(line => line.trim()).find(line => /^codex(?:-cli)?\s+/i.test(line))
+        checks.codex = versionLine ?? combined.split('\n')[0] ?? 'available'
+        codexAvailable = true
+        resolve()
+      })
+    })
+  } catch {
+    checks.codex = 'error'
+  }
+
+  // Check session cache freshness (COS mode only)
+  if (COS_SCRIPTS_DIR) {
+    try {
+      const cacheFile = resolve(COS_SCRIPTS_DIR, '.session_index_cache_COS-Glasses.json')
+      checks.last_cache_write = statSync(cacheFile).mtime.toISOString()
+    } catch {
+      checks.last_cache_write = 'missing'
+    }
+  }
+
+  checks.silero_vad = isSileroAvailable() ? 'active' : 'disabled'
+
+  // Include CLI session ID if available (pre-warmed or active)
+  const cliSid = getAvailableCliSessionId()
+  if (cliSid) checks.cli_session_id = cliSid
+
+  // Feature summary for client capability detection.
+  // v5.9.5 — voice.hasKey reflects the centralized resolver (env > saved file >
+  // COS scripts .env), not just process.env, so a key configured via the
+  // Settings panel correctly reports voice as available without a server
+  // restart. The nested voice block also exposes the source so future wizard
+  // work can decide whether to prompt for a key.
+  const keyStatus = getKeyStatus()
+  const features = {
+    claude: claudeAvailable,
+    codex: codexAvailable,
+    voice: keyStatus.hasKey,
+    cos_pipeline: COS_MODE,
+    whisper: isWhisperLocalAvailable(),
+    iphoneAsrCandidates: process.env.COS_IOS_ASR_CANDIDATES === '1',
+  }
+  const voice = {
+    hasKey: keyStatus.hasKey,
+    keySource: keyStatus.source,
+  }
+
+  // Whisper-server health + cloud budget — exposed so glasses + dashboards can
+  // see whether we're at risk of falling to cloud and how much budget remains.
+  const whisper_health = getWhisperHealth()
+  const openai_whisper_budget = getOpenAIWhisperBudgetState()
+
+  res.json({ ...checks, features, voice, whisper_health, openai_whisper_budget })
+})
+
+// GET /api/cli-session — returns current CLI session ID for cross-device resume
+healthRouter.get('/cli-session', (req, res) => {
+  const cosSessionId = req.query.sid as string | undefined
+  const cliSid = getAvailableCliSessionId(cosSessionId)
+  res.json({ cliSessionId: cliSid ?? null })
+})