@gotcos/glasses-server 6.1.0

package/server/lib/openai-whisper-budget.ts

@@ -0,0 +1,170 @@
+// OpenAI Whisper API daily budget — hard $5/day ceiling.
+//
+// When whisper-server stalls, callers fall to transcribeViaCloud / transcribeCloud
+// (OpenAI Whisper API, $0.006/min). Without a cap, a hung whisper-server during
+// a long meeting could bill hundreds of dollars silently — every chunk shipped
+// straight to OpenAI until someone notices.
+//
+// This module enforces a per-LOCAL-DAY hard cap. `assertOpenAIWhisperBudget()`
+// throws BEFORE any OpenAI call if we're already over. `recordOpenAIWhisperUsage()`
+// is called AFTER a successful call with the audio duration (seconds), so the
+// ledger only counts billable audio (not retries that never reached the API).
+//
+// Cost: Whisper API is billed per second, rounded up, at $0.006/min
+// = $0.0001 / second. $5 cap = 50,000 seconds = 833 min = 13.9 h of audio.
+//
+// State is persisted atomically to server/data/openai-whisper-budget.json.
+// Reset is lazy: when a read finds a date != today's localDay(), it starts fresh.
+// No setInterval, no rollover timers — midnight just means the next read returns
+// a zeroed state.
+
+import { existsSync } from 'node:fs'
+import { resolve, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { atomicWriteFileSync, loadJsonOrQuarantine } from './atomic-fs.js'
+import { localDay } from './local-day.js'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+import { dataPath } from './data-dir.js'
+const BUDGET_FILE = dataPath('openai-whisper-budget.json')
+
+/** OpenAI Whisper API pricing (2024-2025): $0.006 per minute of audio, billed to the second. */
+export const USD_PER_MINUTE = 0.006
+export const USD_PER_SECOND = USD_PER_MINUTE / 60
+
+/** Daily hard cap in USD. Tunable via env (OPENAI_WHISPER_DAILY_CAP_USD) — default $5. */
+export const DAILY_USD_CAP = Number(process.env.OPENAI_WHISPER_DAILY_CAP_USD ?? 5)
+
+/** Warn threshold — logs once when we cross this fraction of the cap. */
+const WARN_FRACTION = 0.8
+
+export class OpenAIWhisperBudgetExhaustedError extends Error {
+  public readonly spentTodayUsd: number
+  public readonly capUsd: number
+  public readonly secondsToday: number
+  public readonly callsToday: number
+
+  constructor(state: BudgetState) {
+    const msg =
+      `OpenAI Whisper daily budget exhausted: $${state.usdToday.toFixed(4)}/$${DAILY_USD_CAP.toFixed(2)} ` +
+      `(${state.secondsToday.toFixed(0)}s of audio across ${state.callsToday} calls today). ` +
+      `Cause: whisper-server is unhealthy — fix it before transcription resumes. ` +
+      `Recovery: pkill -9 -f whisper-server && restart cos-glasses server (auto-restarts model).`
+    super(msg)
+    this.name = 'OpenAIWhisperBudgetExhaustedError'
+    this.spentTodayUsd = state.usdToday
+    this.capUsd = DAILY_USD_CAP
+    this.secondsToday = state.secondsToday
+    this.callsToday = state.callsToday
+  }
+}
+
+interface BudgetState {
+  /** Local-tz YYYY-MM-DD — when this doesn't equal localDay() on next read, we reset. */
+  date: string
+  /** Cumulative audio seconds billed today. */
+  secondsToday: number
+  /** Number of successful cloud calls today (diagnostics). */
+  callsToday: number
+  /** Derived: USD spent today. Recomputed on every write from secondsToday. */
+  usdToday: number
+  /** Whether we've already logged the 80% warning today (so we don't spam). */
+  warnedAt80: boolean
+}
+
+function fresh(): BudgetState {
+  return { date: localDay(), secondsToday: 0, callsToday: 0, usdToday: 0, warnedAt80: false }
+}
+
+function read(): BudgetState {
+  if (!existsSync(BUDGET_FILE)) return fresh()
+  const r = loadJsonOrQuarantine<BudgetState>(BUDGET_FILE)
+  if (r.status !== 'ok') return fresh()
+  if (r.data.date !== localDay()) return fresh() // new day, zero ledger
+  return r.data
+}
+
+function write(state: BudgetState): void {
+  try {
+    atomicWriteFileSync(BUDGET_FILE, JSON.stringify(state, null, 2))
+  } catch (err) {
+    // Non-fatal — worst case we slightly under-count next read and over-spend a few cents.
+    console.error('[openai-whisper-budget] Failed to persist budget state:', err)
+  }
+}
+
+/**
+ * Estimate audio duration in seconds from a raw buffer. Used BEFORE the OpenAI
+ * call so we can reject over-budget calls without making them.
+ *
+ * Accuracy: exact for our 16 kHz / 16-bit / mono WAV (subtract 44-byte header,
+ * divide by 32000 bytes/sec). For WebM/other formats (rare — the dictation path
+ * uses WAV), approximates byteLength / 32000 which over-estimates = conservative
+ * for billing. Never under-estimates silently.
+ */
+export function estimateAudioSeconds(audioBuffer: Buffer): number {
+  if (audioBuffer.length < 4) return 0
+  const isWav = audioBuffer.toString('ascii', 0, 4) === 'RIFF'
+  const dataBytes = isWav ? Math.max(0, audioBuffer.length - 44) : audioBuffer.length
+  return dataBytes / 32000 // 16 kHz × 16-bit × mono = 32000 bytes/sec
+}
+
+/**
+ * Throw BEFORE making any OpenAI Whisper call if today's budget is already spent.
+ * Caller must handle OpenAIWhisperBudgetExhaustedError — typical behaviour is to
+ * surface a loud error to the client (500 / "cloud transcription unavailable, fix
+ * whisper-server") instead of silently returning empty text.
+ */
+export function assertOpenAIWhisperBudget(): void {
+  const state = read()
+  if (state.usdToday >= DAILY_USD_CAP) {
+    throw new OpenAIWhisperBudgetExhaustedError(state)
+  }
+}
+
+/**
+ * Record a successful cloud transcription. `audioSeconds` should be the
+ * duration of the audio we sent to OpenAI (not the latency of the response).
+ */
+export function recordOpenAIWhisperUsage(audioSeconds: number): void {
+  if (audioSeconds <= 0) return
+  const state = read()
+  const before = state.usdToday
+  state.secondsToday += audioSeconds
+  state.callsToday += 1
+  state.usdToday = state.secondsToday * USD_PER_SECOND
+
+  const warnThreshold = DAILY_USD_CAP * WARN_FRACTION
+  if (before < warnThreshold && state.usdToday >= warnThreshold && !state.warnedAt80) {
+    console.warn(
+      `[openai-whisper-budget] WARN — $${state.usdToday.toFixed(4)}/$${DAILY_USD_CAP.toFixed(2)} ` +
+      `(${((state.usdToday / DAILY_USD_CAP) * 100).toFixed(0)}%) today across ${state.callsToday} calls. ` +
+      `If whisper-server is stalled, fix it now to avoid the hard cap.`,
+    )
+    state.warnedAt80 = true
+  }
+
+  if (state.usdToday >= DAILY_USD_CAP) {
+    console.error(
+      `[openai-whisper-budget] HARD CAP REACHED — $${state.usdToday.toFixed(4)}/$${DAILY_USD_CAP.toFixed(2)} today. ` +
+      `All further OpenAI Whisper calls will throw until local midnight.`,
+    )
+  }
+
+  write(state)
+}
+
+/** Status snapshot for diagnostics / health endpoints. */
+export function getOpenAIWhisperBudgetState(): BudgetState & {
+  capUsd: number
+  remainingUsd: number
+  percentUsed: number
+} {
+  const state = read()
+  return {
+    ...state,
+    capUsd: DAILY_USD_CAP,
+    remainingUsd: Math.max(0, DAILY_USD_CAP - state.usdToday),
+    percentUsed: Math.round((state.usdToday / DAILY_USD_CAP) * 100),
+  }
+}

package/server/lib/profile.ts

@@ -0,0 +1,94 @@
+// Profile loader — reads user identity from .cos-profile.json (gitignored)
+// Falls back to generic defaults for users who haven't configured a profile
+
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { atomicWriteFileSync } from './atomic-fs.js'
+
+const APP_ROOT = resolve(import.meta.dirname, '../..')
+// Single canonical path — used by BOTH the reader and the writer so a glossary
+// PUT can never write to a different file than the cache reads from. Lazy +
+// env-overridable (COS_PROFILE_PATH) so tests can target a temp file.
+function profilePath(): string {
+  return process.env.COS_PROFILE_PATH || resolve(APP_ROOT, '.cos-profile.json')
+}
+
+let profileCache: Record<string, unknown> | null = null
+
+function loadProfile(): Record<string, unknown> {
+  if (profileCache) return profileCache
+  try {
+    profileCache = JSON.parse(readFileSync(profilePath(), 'utf-8'))
+    return profileCache!
+  } catch {
+    profileCache = {}
+    return profileCache
+  }
+}
+
+/** Null the in-memory profile cache so the next read reloads from disk.
+ *  Call after any write to .cos-profile.json (e.g. the glossary PUT). This is
+ *  the ROOT cache every getter reads through — busting it is necessary but NOT
+ *  sufficient: the decoder snapshots in whisper-local.ts (resetDecoderCaches)
+ *  must be cleared too. */
+export function clearProfileCache(): void {
+  profileCache = null
+}
+
+/** Read-modify-write merge of top-level fields into .cos-profile.json.
+ *  Reads the CURRENT file fresh (not the cache) so untouched keys
+ *  (domain_keywords, system_prompt_context, owner_name, ...) are preserved,
+ *  writes atomically, then busts the cache. Returns the merged profile. */
+export function updateProfileFields(patch: Record<string, unknown>): Record<string, unknown> {
+  let current: Record<string, unknown> = {}
+  try {
+    current = JSON.parse(readFileSync(profilePath(), 'utf-8')) as Record<string, unknown>
+  } catch {
+    current = {} // missing/corrupt — start fresh; merge still proceeds
+  }
+  const merged = { ...current, ...patch }
+  atomicWriteFileSync(profilePath(), JSON.stringify(merged, null, 2))
+  clearProfileCache()
+  return merged
+}
+
+export function loadProfileField(field: string, fallback: string): string {
+  const profile = loadProfile()
+  const value = profile[field]
+  return typeof value === 'string' ? value : fallback
+}
+
+export function getOwnerName(): string {
+  return loadProfileField('owner_name', 'User')
+}
+
+/** Short speaker label for the glasses wearer, used by diarization to fast-path
+ *  the owner's voiceprint. Defaults to 'Me'. Configure via owner_speaker_label. */
+export function getOwnerSpeakerLabel(): string {
+  return loadProfileField('owner_speaker_label', 'Me')
+}
+
+export function getVocabulary(): string[] {
+  const profile = loadProfile()
+  return Array.isArray(profile.vocabulary) ? profile.vocabulary as string[] : []
+}
+
+export function getSystemContext(): string {
+  return loadProfileField('system_prompt_context', '')
+}
+
+export function getDomainKeywords(): Record<string, string[]> {
+  const profile = loadProfile()
+  const dk = profile.domain_keywords
+  return (dk && typeof dk === 'object') ? dk as Record<string, string[]> : {}
+}
+
+/** Editable negative/cleanup rules (whole:/strip:/replace:/flag:) authored via
+ *  the glossary PUT. Parsed + applied by hallucination-filter.ts. Returns the
+ *  raw rule lines; non-string entries are dropped defensively. */
+export function getNegativeRules(): string[] {
+  const profile = loadProfile()
+  return Array.isArray(profile.negative_rules)
+    ? (profile.negative_rules as unknown[]).filter((r): r is string => typeof r === 'string')
+    : []
+}

package/server/lib/python-bridge.ts

@@ -0,0 +1,84 @@
+import { execFile } from 'node:child_process'
+import { resolve } from 'node:path'
+import { existsSync } from 'node:fs'
+
+// Optional COS pipeline bridge.
+//
+// Standalone (default): COS_SCRIPTS_DIR is unset, callPython() resolves to an
+// empty/no-op result, and the server runs as glasses + Claude only.
+//
+// Full pipeline (optional): power users running the COS Starter Kit set
+// COS_SCRIPTS_DIR to their `operations/scripts` directory. If a Python venv and
+// cos_api_bridge.py are present there, live tasks/calendar/etc. are sourced from
+// it. No COS source ships in this package — it shells out to the user's own.
+
+export const COS_SCRIPTS_DIR: string | null = process.env.COS_SCRIPTS_DIR
+  ? resolve(process.env.COS_SCRIPTS_DIR)
+  : null
+
+/** True when the full COS pipeline directory is configured. */
+export const COS_MODE = !!COS_SCRIPTS_DIR
+
+if (!COS_SCRIPTS_DIR) {
+  console.log('[COS] Standalone mode — glasses + Claude only (set COS_SCRIPTS_DIR for the full pipeline)')
+}
+
+export const PYTHON_BIN: string | null = COS_SCRIPTS_DIR ? resolve(COS_SCRIPTS_DIR, 'venv/bin/python3') : null
+const BRIDGE_SCRIPT: string | null = COS_SCRIPTS_DIR ? resolve(COS_SCRIPTS_DIR, 'cos_api_bridge.py') : null
+
+// The optional Python bridge is available only when the user points us at a real
+// COS pipeline that ships the venv + bridge script. Standalone installs never
+// have these, so callPython() degrades to a no-op.
+const pythonAvailable = !!(COS_SCRIPTS_DIR && existsSync(PYTHON_BIN!) && existsSync(BRIDGE_SCRIPT!))
+
+if (pythonAvailable) {
+  console.log('[python-bridge] COS pipeline detected — sourcing live context')
+} else if (COS_SCRIPTS_DIR) {
+  console.log('[python-bridge] COS_SCRIPTS_DIR set but cos_api_bridge.py not found — running without live context')
+}
+
+/**
+ * Call the optional COS data bridge. Returns live data only when a full COS
+ * pipeline is configured; otherwise resolves to an empty/no-op result so the
+ * context builder degrades gracefully on a standalone install.
+ */
+export function callPython(args: string[], timeoutMs = 30_000): Promise<unknown> {
+  if (pythonAvailable) {
+    return callPythonDirect(args, timeoutMs)
+  }
+  return Promise.resolve(standaloneNoop(args))
+}
+
+/** Empty shapes that the context builder tolerates (no crash, no live data). */
+function standaloneNoop(args: string[]): unknown {
+  switch (args[0]) {
+    case 'calendar': return { events: [] }
+    case 'tasks': return {}
+    case 'threads': return []
+    case 'memory': return []
+    case 'badges': return {}
+    default: return {}
+  }
+}
+
+/** Full Python bridge — requires the user's venv + cos_api_bridge.py. */
+function callPythonDirect(args: string[], timeoutMs: number): Promise<unknown> {
+  return new Promise((resolvePromise, reject) => {
+    execFile(
+      PYTHON_BIN!,
+      [BRIDGE_SCRIPT!, ...args],
+      { cwd: COS_SCRIPTS_DIR!, timeout: timeoutMs, maxBuffer: 1024 * 1024 },
+      (err, stdout, stderr) => {
+        if (err) {
+          const msg = stderr?.trim() || err.message
+          return reject(new Error(`python-bridge: ${msg}`))
+        }
+        try {
+          resolvePromise(JSON.parse(stdout))
+        } catch {
+          reject(new Error(`python-bridge: invalid JSON output`))
+        }
+      }
+    )
+  })
+}

package/server/lib/response-cache.ts

@@ -0,0 +1,138 @@
+// Predictive response cache — instant responses for common G2 queries
+// Bypasses Claude CLI entirely for pattern-matched queries using cached COS context.
+// TTFB: ~10ms vs ~1-3s through Claude.
+
+import { getCachedContextInstant } from './context-builder.js'
+import { getOwnerName, loadProfileField } from './profile.js'
+
+interface CacheResult {
+  text: string
+  pattern: string
+}
+
+// Narrow match list — one-liners only. Over-matching degrades experience.
+const PATTERNS: Array<{ regex: RegExp; name: string; handler: (query: string) => string | null }> = [
+  {
+    regex: /^(what('?s| is) (the )?)?time\??$|^what time is it\??$/i,
+    name: 'time',
+    handler: () => {
+      const now = new Date()
+      return now.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true })
+    },
+  },
+  {
+    regex: /^what('?s| is) (the )?(date|day)( today)?\??$|^what day is it\??$/i,
+    name: 'date',
+    handler: () => {
+      const now = new Date()
+      return now.toLocaleDateString('en-US', { weekday: 'long', month: 'long', day: 'numeric', year: 'numeric' })
+    },
+  },
+  {
+    regex: /^(what('?s| is) my )?(next meeting|next call)\??$/i,
+    name: 'next_meeting',
+    handler: () => {
+      const ctx = getCachedContextInstant()
+      if (!ctx || ctx.includes('unavailable')) return null
+      const nextMatch = ctx.match(/NEXT:\s*(.+)/i)
+      if (!nextMatch) {
+        if (ctx.includes('No more meetings')) return 'No more meetings today.'
+        return null
+      }
+      return nextMatch[1].trim()
+    },
+  },
+  {
+    regex: /^(what('?s| is) my )?(schedule|calendar|meetings)( today)?\??$/i,
+    name: 'schedule',
+    handler: () => {
+      const ctx = getCachedContextInstant()
+      if (!ctx || ctx.includes('unavailable')) return null
+      // Extract the CALENDAR section
+      const calMatch = ctx.match(/CALENDAR:\n([\s\S]*?)(?:\n\n|$)/)
+      if (!calMatch) return null
+      return calMatch[1].trim()
+    },
+  },
+  {
+    regex: /^(how many )?(open )?tasks?\??$/i,
+    name: 'task_count',
+    handler: () => {
+      const ctx = getCachedContextInstant()
+      if (!ctx || ctx.includes('unavailable')) return null
+      const taskMatch = ctx.match(/(\d+) open tasks? total/)
+      if (!taskMatch) return null
+      return `${taskMatch[1]} open tasks.`
+    },
+  },
+  {
+    regex: /^(who am i|who is \w+|tell me about myself)\??$/i,
+    name: 'who_am_i',
+    handler: () => {
+      const name = getOwnerName()
+      const context = loadProfileField('system_prompt_context', '')
+      if (context) return `You're ${name}. ${context}`
+      return `You're ${name}. Configure .cos-profile.json for more context.`
+    },
+  },
+  {
+    regex: /^(hey|hi|hello|yo|sup|what's up|hey even)[\s!.]*$/i,
+    name: 'greeting',
+    handler: () => {
+      const name = getOwnerName().split(' ')[0]  // First name only
+      const hour = new Date().getHours()
+      if (hour < 12) return `Good morning, ${name}.`
+      if (hour < 17) return `Good afternoon, ${name}.`
+      return `Good evening, ${name}.`
+    },
+  },
+  {
+    regex: /^(thanks|thank you|thx|ty|appreciate it|got it|ok|okay|cool|great|perfect)[\s!.]*$/i,
+    name: 'acknowledgment',
+    handler: () => {
+      return "Anytime."
+    },
+  },
+  {
+    regex: /^what('?s| is) (\d+)\s*[\+\-\*x×]\s*(\d+)\??$/i,
+    name: 'basic_math',
+    handler: (query: string) => {
+      const m = query.match(/(\d+)\s*([\+\-\*x×])\s*(\d+)/i)
+      if (!m) return null
+      const a = parseInt(m[1], 10)
+      const b = parseInt(m[3], 10)
+      const op = m[2]
+      let result: number
+      switch (op) {
+        case '+': result = a + b; break
+        case '-': result = a - b; break
+        case '*': case 'x': case '×': result = a * b; break
+        default: return null
+      }
+      return `${a} ${op === 'x' || op === '×' ? '×' : op} ${b} = ${result}`
+    },
+  },
+]
+
+/**
+ * Try to answer a query instantly from cached context.
+ * Returns null if the query doesn't match any cached pattern.
+ */
+export function tryInstantResponse(query: string): CacheResult | null {
+  const q = query.trim()
+  // Skip long queries — they're unlikely to be simple lookups
+  if (q.length > 60) return null
+
+  for (const { regex, name, handler } of PATTERNS) {
+    if (regex.test(q)) {
+      const text = handler(q)
+      if (text) {
+        return { text, pattern: name }
+      }
+      // Pattern matched but handler returned null (e.g., cache stale) — fall through to Claude
+      return null
+    }
+  }
+
+  return null
+}