@gotcos/glasses-server 6.1.0

package/server/lib/codex-run-ledger.ts

@@ -0,0 +1,298 @@
+import crypto from 'node:crypto'
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { COS_SCRIPTS_DIR } from './python-bridge.js'
+import { CODEX_ENGINE_SESSION_TTL_MS, type CodexTrustMode } from './codex-engine-sessions.js'
+import {
+  CODEX_HIGH_REASONING_EFFORT,
+  CODEX_MODEL_ID,
+  type CodexModelPreference,
+} from '../../shared/model-preference.js'
+import { dataPath } from './data-dir.js'
+
+const DEFAULT_MAX_RUNS = 100
+const DEFAULT_TTL_MS = 7 * 24 * 60 * 60_000
+const ERROR_PREVIEW_CHARS = 160
+const RUNNING_STALE_MS = 30 * 60_000
+
+function getProcessStartedAtMs(): number {
+  return Date.now() - Math.floor(process.uptime() * 1000)
+}
+
+export type CodexRunStatus =
+  | 'running'
+  | 'completed'
+  | 'failed'
+  | 'cancelled'
+  | 'client_disconnected'
+
+export interface CodexRunRecord {
+  runId: string
+  cosSessionId: string
+  codexThreadId?: string
+  status: CodexRunStatus
+  createdAt: string
+  updatedAt: string
+  model: CodexModelPreference
+  cliModel: string
+  reasoningEffort: string
+  cwd: string
+  ephemeral: boolean
+  resumed?: boolean
+  trustMode: CodexTrustMode
+  expiresAt?: string
+  resumeCommand?: string
+  queryPreview?: string
+  outputPreview?: string
+  errorCode?: string
+  errorPreview?: string
+  durationMs?: number
+  exitCode?: number | null
+}
+
+interface CodexRunEvent {
+  runId: string
+  ts: string
+  patch: Partial<CodexRunRecord>
+}
+
+export interface CodexRunConfig {
+  cliModel: string
+  reasoningEffort: string
+  persistenceEnabled: boolean
+  cwd: string
+  trustMode: CodexTrustMode
+  engineSessionTtlMinutes: number
+  historyLimit: number
+  historyTtlDays: number
+  contentPreviewsEnabled: boolean
+}
+
+export function isCodexPersistenceEnabled(): boolean {
+  return process.env.COS_CODEX_PERSIST_SESSIONS !== '0'
+}
+
+export function areCodexContentPreviewsEnabled(): boolean {
+  return process.env.COS_CODEX_RUN_CONTENT_PREVIEWS === '1'
+}
+
+export function getCodexExecutionCwd(): string {
+  const configured = process.env.CODEX_GLASSES_WORKDIR?.trim()
+  if (configured) return resolve(configured)
+  if (COS_SCRIPTS_DIR) return resolve(COS_SCRIPTS_DIR, '..', '..')
+  // Last resort when neither CODEX_GLASSES_WORKDIR nor COS_SCRIPTS_DIR is set:
+  // the server's own working dir (codex glasses is an optional, env-configured feature).
+  return process.cwd()
+}
+
+export function getCodexTrustMode(): CodexTrustMode {
+  return process.env.COS_CODEX_SANDBOX === 'workspace-write' ? 'workspace-write' : 'read-only'
+}
+
+export function getCodexRunConfig(): CodexRunConfig {
+  return {
+    cliModel: CODEX_MODEL_ID,
+    reasoningEffort: CODEX_HIGH_REASONING_EFFORT,
+    persistenceEnabled: isCodexPersistenceEnabled(),
+    cwd: getCodexExecutionCwd(),
+    trustMode: getCodexTrustMode(),
+    engineSessionTtlMinutes: Math.round(CODEX_ENGINE_SESSION_TTL_MS / 60_000),
+    historyLimit: getMaxRuns(),
+    historyTtlDays: Math.round(getTtlMs() / (24 * 60 * 60_000)),
+    contentPreviewsEnabled: areCodexContentPreviewsEnabled(),
+  }
+}
+
+export function getCodexLedgerPath(): string {
+  return resolve(process.env.COS_CODEX_RUN_LEDGER_FILE || dataPath('codex-runs.jsonl'))
+}
+
+function getMaxRuns(): number {
+  const raw = Number(process.env.COS_CODEX_RUN_LEDGER_MAX ?? DEFAULT_MAX_RUNS)
+  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : DEFAULT_MAX_RUNS
+}
+
+function getTtlMs(): number {
+  const rawDays = Number(process.env.COS_CODEX_RUN_LEDGER_TTL_DAYS ?? 7)
+  return Number.isFinite(rawDays) && rawDays > 0 ? rawDays * 24 * 60 * 60_000 : DEFAULT_TTL_MS
+}
+
+function appendEvent(event: CodexRunEvent): void {
+  try {
+    const path = getCodexLedgerPath()
+    mkdirSync(dirname(path), { recursive: true })
+    appendFileSync(path, JSON.stringify(event) + '\n')
+  } catch (err) {
+    console.warn('[codex-run-ledger] write skipped:', err)
+  }
+}
+
+function readEvents(): CodexRunEvent[] {
+  const path = getCodexLedgerPath()
+  if (!existsSync(path)) return []
+  try {
+    const events: CodexRunEvent[] = []
+    for (const line of readFileSync(path, 'utf-8')
+      .split('\n')
+      .map(line => line.trim())
+      .filter(Boolean)) {
+      try {
+        const event = JSON.parse(line) as CodexRunEvent
+        if (typeof event.runId === 'string' && typeof event.ts === 'string' && typeof event.patch === 'object') {
+          events.push(event)
+        }
+      } catch {
+        // Skip torn/corrupt JSONL rows; valid prior records should stay visible.
+      }
+    }
+    return events
+  } catch {
+    return []
+  }
+}
+
+function hydrateRuns(): CodexRunRecord[] {
+  const runs = new Map<string, CodexRunRecord>()
+  const order = new Map<string, number>()
+  let eventIndex = 0
+  for (const event of readEvents()) {
+    eventIndex += 1
+    const existing = runs.get(event.runId)
+    const next = { ...(existing ?? {}), ...event.patch, runId: event.runId } as CodexRunRecord
+    if (next.codexThreadId && !next.resumeCommand) {
+      next.resumeCommand = `codex exec resume ${next.codexThreadId}`
+    }
+    runs.set(event.runId, next)
+    order.set(event.runId, eventIndex)
+  }
+
+  const cutoff = Date.now() - getTtlMs()
+  return Array.from(runs.values())
+    .filter(run => run.createdAt && Date.parse(run.updatedAt || run.createdAt) >= cutoff)
+    .map(run => {
+      const updatedMs = Date.parse(run.updatedAt || run.createdAt)
+      const predatesCurrentProcess = updatedMs < getProcessStartedAtMs() - 1000
+      if (run.status === 'running' && (predatesCurrentProcess || Date.now() - updatedMs > RUNNING_STALE_MS)) {
+        const interruptedRun: CodexRunRecord = {
+          ...run,
+          status: 'client_disconnected',
+          errorCode: run.errorCode ?? 'codex.interrupted',
+        }
+        return interruptedRun
+      }
+      return run
+    })
+    .sort((a, b) => {
+      const byCreated = Date.parse(b.createdAt) - Date.parse(a.createdAt)
+      if (byCreated !== 0) return byCreated
+      return (order.get(b.runId) ?? 0) - (order.get(a.runId) ?? 0)
+    })
+    .slice(0, getMaxRuns())
+}
+
+export function redactForCodexLedger(value: string, maxChars = ERROR_PREVIEW_CHARS): string {
+  return value
+    .replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, '[email]')
+    .replace(/\b(?:sk|sess|ghp|github_pat|glpat)-[A-Za-z0-9_\-]{12,}\b/g, '[token]')
+    .replace(/\bBearer\s+[A-Za-z0-9._\-]{12,}\b/gi, 'Bearer [token]')
+    .replace(/[A-Za-z0-9+/=]{80,}/g, '[blob]')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, maxChars)
+}
+
+export function classifyCodexError(message: string): string {
+  const text = message.toLowerCase()
+  if (/command not found|enoent|not found/.test(text)) return 'codex.cli_unavailable'
+  if (/permission|denied|sandbox|read-only|operation not permitted/.test(text)) return 'codex.permission_denied'
+  if (/auth|login|sign in|unauthorized|forbidden|token/.test(text)) return 'codex.auth_error'
+  if (/timeout|timed out|wall clock|no output/.test(text)) return 'codex.timeout'
+  if (/exit\s+\d+/.test(text)) return 'codex.nonzero_exit'
+  return 'codex.error'
+}
+
+export function extractCodexThreadId(event: any): string | undefined {
+  const type = String(event?.type ?? '').toLowerCase()
+  if (!/(thread|session).*(started|created)|^(thread|session)\.started$/.test(type)) return undefined
+  const candidate = event?.thread_id ?? event?.threadId ?? event?.session_id ?? event?.sessionId ?? event?.id
+  return typeof candidate === 'string' && candidate.length > 0 ? candidate : undefined
+}
+
+export function startCodexRun(input: {
+  cosSessionId: string
+  model: CodexModelPreference
+  cwd: string
+  ephemeral: boolean
+  resumed?: boolean
+  trustMode?: CodexTrustMode
+  codexThreadId?: string
+  expiresAt?: string
+  query: string
+}): CodexRunRecord {
+  const now = new Date().toISOString()
+  const run: CodexRunRecord = {
+    runId: `codex-${crypto.randomUUID().slice(0, 8)}`,
+    cosSessionId: input.cosSessionId,
+    status: 'running',
+    createdAt: now,
+    updatedAt: now,
+    model: input.model,
+    cliModel: CODEX_MODEL_ID,
+    reasoningEffort: CODEX_HIGH_REASONING_EFFORT,
+    cwd: input.cwd,
+    ephemeral: input.ephemeral,
+    resumed: input.resumed,
+    trustMode: input.trustMode ?? getCodexTrustMode(),
+    codexThreadId: input.codexThreadId,
+    expiresAt: input.expiresAt,
+  }
+  if (areCodexContentPreviewsEnabled()) {
+    run.queryPreview = redactForCodexLedger(input.query)
+  }
+  appendEvent({ runId: run.runId, ts: now, patch: run })
+  return run
+}
+
+export function updateCodexRun(runId: string, patch: Partial<Omit<CodexRunRecord, 'runId' | 'createdAt'>>): CodexRunRecord | null {
+  const ts = new Date().toISOString()
+  const safePatch = { ...patch, updatedAt: ts }
+  if (safePatch.codexThreadId && !safePatch.resumeCommand) {
+    safePatch.resumeCommand = `codex exec resume ${safePatch.codexThreadId}`
+  }
+  appendEvent({ runId, ts, patch: safePatch })
+  return getCodexRun(runId)
+}
+
+export function finishCodexRun(runId: string, input: {
+  status: Exclude<CodexRunStatus, 'running'>
+  startedAtMs: number
+  output?: string
+  error?: string
+  exitCode?: number | null
+}): CodexRunRecord | null {
+  const patch: Partial<CodexRunRecord> = {
+    status: input.status,
+    durationMs: Math.max(0, Date.now() - input.startedAtMs),
+    exitCode: input.exitCode,
+  }
+  if (input.output && areCodexContentPreviewsEnabled()) {
+    patch.outputPreview = redactForCodexLedger(input.output)
+  }
+  if (input.error) {
+    patch.errorCode = classifyCodexError(input.error)
+    if (areCodexContentPreviewsEnabled()) {
+      patch.errorPreview = redactForCodexLedger(input.error)
+    }
+  }
+  return updateCodexRun(runId, patch)
+}
+
+export function listCodexRuns(limit = 20, cosSessionId?: string): CodexRunRecord[] {
+  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.min(Math.floor(limit), getMaxRuns()) : 20
+  const runs = hydrateRuns()
+  return (cosSessionId ? runs.filter(run => run.cosSessionId === cosSessionId) : runs).slice(0, safeLimit)
+}
+
+export function getCodexRun(runId: string): CodexRunRecord | null {
+  return hydrateRuns().find(run => run.runId === runId) ?? null
+}

package/server/lib/context-builder.ts

@@ -0,0 +1,210 @@
+// Context builder — assembles profile + live COS data into system prompt
+// Caches context for 60s to avoid hammering Python scripts every query
+
+import { callPython, COS_MODE } from './python-bridge.js'
+import { getOwnerName } from './profile.js'
+
+interface ContextCache {
+  content: string
+  timestamp: number
+}
+
+const CACHE_TTL_MS = 600_000  // 10 minutes — context only injected when query needs it
+const CACHE_REFRESH_MS = 600_000  // 10 minutes — background refresh interval
+let contextCache: ContextCache | null = null
+let refreshInterval: ReturnType<typeof setInterval> | null = null
+
+const COS_ROUTING_CONTEXT = `PIPELINE ROUTING:
+This glasses header is only routing and display context.
+Treat your configured COS pipeline as canonical for identity, schedule, tasks, and people context.
+Do not infer facts from this glasses header. If this header conflicts with pipeline data, follow the pipeline.`
+
+function formatCalendarContext(cal: any): string {
+  const lines: string[] = []
+
+  if (cal.is_in_meeting && cal.current_event) {
+    lines.push(`NOW: ${cal.current_event.title}`)
+    if (cal.current_event.matched_person) {
+      lines.push(`  with ${cal.current_event.matched_person}`)
+    }
+  }
+
+  if (cal.next_event) {
+    const mins = cal.minutes_until_next
+    const when = mins != null && mins < 120 ? `in ${mins}m` : cal.next_event.start_time
+    lines.push(`NEXT: ${cal.next_event.title} (${when})`)
+    if (cal.next_event.matched_person) {
+      lines.push(`  with ${cal.next_event.matched_person}`)
+    }
+  } else {
+    lines.push('No more meetings today')
+  }
+
+  lines.push(`${cal.meetings_remaining_count ?? 0} meetings remaining today`)
+
+  return lines.join('\n')
+}
+
+function formatTaskContext(tasks: Record<string, any[]>): string {
+  const urgent: string[] = []
+  let totalOpen = 0
+
+  for (const domain of Object.keys(tasks)) {
+    for (const t of tasks[domain]) {
+      if (!t.is_checked) {
+        totalOpen++
+        if (t.priority === 'high' || t.priority === 'urgent') {
+          urgent.push(`[${domain}] ${t.description}`)
+        }
+      }
+    }
+  }
+
+  const lines = [`${totalOpen} open tasks total`]
+  if (urgent.length > 0) {
+    lines.push(`Urgent/High priority:`)
+    for (const u of urgent.slice(0, 5)) {
+      lines.push(`  - ${u}`)
+    }
+  }
+
+  return lines.join('\n')
+}
+
+async function fetchLiveContext(): Promise<string> {
+  const parts: string[] = []
+
+  // Fetch calendar and tasks in parallel
+  const [calResult, taskResult] = await Promise.allSettled([
+    callPython(['calendar']),
+    callPython(['tasks']),
+  ])
+
+  if (calResult.status === 'fulfilled') {
+    parts.push('CALENDAR:\n' + formatCalendarContext(calResult.value))
+  } else {
+    parts.push('CALENDAR: unavailable')
+  }
+
+  if (taskResult.status === 'fulfilled') {
+    parts.push('TASKS:\n' + formatTaskContext(taskResult.value as Record<string, any[]>))
+  } else {
+    parts.push('TASKS: unavailable')
+  }
+
+  return parts.join('\n\n')
+}
+
+/**
+ * Pre-warm the context cache at server start so the first query is instant.
+ * Called from index.ts after server boots.
+ */
+export async function prewarmContext(): Promise<void> {
+  try {
+    const start = Date.now()
+    const content = await fetchLiveContext()
+    contextCache = { content, timestamp: Date.now() }
+    console.log(`[context] Pre-warmed context cache in ${Date.now() - start}ms (TTL: ${CACHE_TTL_MS / 1000}s)`)
+  } catch (err) {
+    console.error('[context] Pre-warm failed:', err)
+  }
+
+  // Background refresh — keeps cache perpetually warm so queries NEVER block on fetch
+  if (!refreshInterval) {
+    refreshInterval = setInterval(async () => {
+      try {
+        const content = await fetchLiveContext()
+        contextCache = { content, timestamp: Date.now() }
+        console.log(`[context] Background refresh complete`)
+      } catch (err) {
+        console.error('[context] Background refresh failed (keeping stale cache):', err)
+      }
+    }, CACHE_REFRESH_MS)
+  }
+}
+
+/**
+ * Get cached context instantly — NEVER blocks on Python fetch.
+ * Returns whatever is in cache (even stale), or a minimal fallback.
+ * Used by G2 agent where speed > freshness.
+ */
+export function getCachedContextInstant(): string {
+  return contextCache?.content ?? 'Live context unavailable — cache warming'
+}
+
+/**
+ * Build the lightweight G2 system prompt — minimal for speed.
+ * General-purpose assistant, mostly personal life, occasional business context.
+ * Used by G2 agent queries and CLI pre-warm.
+ */
+export function buildLightweightSystemPrompt(query: string, historyPrompt: string): string {
+  const needsContext = /\b(schedule|calendar|meeting|task|tasks|today|tomorrow|next meeting|who do i meet|what's next|direct report|team)\b/i.test(query)
+
+  const name = getOwnerName().split(' ')[0]
+  const base = `You are ${name}'s personal assistant on Even G2 smart glasses. You are NOT a work productivity tool — you are a general-purpose voice assistant like Siri or Alexa, but smarter. Answer anything ${name} asks: sports scores, trivia, recipes, weather, news, personal questions, recommendations, math, history, science, pop culture, or anything else. Never deflect with "let's get back to work" or steer toward business topics.
+Plain text only — no markdown, no asterisks, no bullets. Aim for 300-600 chars on quick answers; up to ~2000 chars when depth helps (synthesis, multi-part questions, detailed how-to). Glasses scroll continuously — no need to over-compress. Pad nothing; if a question deserves 200 chars, give 200.
+If the query seems incomplete or cut off mid-sentence (e.g. "What's my", "Can you check", "Tell me about the"), ask ${name} to repeat or finish his thought rather than guessing what he meant. This is common with voice input on glasses.`
+
+  if (needsContext) {
+    const cachedContext = getCachedContextInstant()
+    return `${base}
+${cachedContext}
+${historyPrompt}`
+  }
+
+  return `${base}${historyPrompt ? '\n' + historyPrompt : ''}`
+}
+
+/**
+ * Build the lightweight prompt for pre-warming (no query to match against, include context).
+ */
+export function buildPrewarmSystemPrompt(): string {
+  const cachedContext = getCachedContextInstant()
+  const name = getOwnerName().split(' ')[0]
+  return `You are ${name}'s personal assistant on Even G2 smart glasses. You are NOT a work productivity tool — you are a general-purpose voice assistant. Answer anything: sports, trivia, news, personal questions, recommendations, whatever. Never deflect with "let's get back to work." Plain text only. Aim for 300-600 chars on quick answers; up to ~2000 chars when depth helps. Glasses scroll continuously.
+If the query seems incomplete or cut off mid-sentence, ask ${name} to repeat or finish his thought rather than guessing.
+${cachedContext}`
+}
+
+export async function buildSystemPrompt(conversationHistory: string): Promise<string> {
+  // Check cache
+  let liveContext: string
+  if (contextCache && Date.now() - contextCache.timestamp < CACHE_TTL_MS) {
+    liveContext = contextCache.content
+  } else {
+    try {
+      liveContext = await fetchLiveContext()
+      contextCache = { content: liveContext, timestamp: Date.now() }
+    } catch {
+      liveContext = contextCache?.content ?? 'Live context unavailable'
+    }
+  }
+
+  const ownerName = getOwnerName()
+  return `You are COS (Chief of Staff), ${ownerName}'s AI assistant running on Even G2 smart glasses.
+
+DISPLAY CONSTRAINTS:
+576x288px glasses display. Body scrolls continuously via firmware — write naturally with depth where it helps. Aim for 300-600 chars on quick answers; up to ~2000 chars when depth genuinely helps (synthesis, multi-part questions, detailed how-to). Pad nothing; if a question deserves 200 chars, give 200.
+Plain text only — no markdown, no bullets, no headers, no asterisks.
+Lead with the most actionable information. Be direct. Short sentences for quick answers; full sentences for explanations.
+If listing items, use numbered lines (1. 2. 3.) — no upper limit but prefer 3-5 for scannability.
+Never say "here is" or "I found" — just give the answer.
+
+${COS_MODE ? COS_ROUTING_CONTEXT + '\n\n' : ''}CURRENT CONTEXT:
+${liveContext}
+${conversationHistory}
+
+BEHAVIOR:
+- Answer questions about the user's schedule and tasks using live context above.
+- For questions about team, reporting lines, roles, relationship history, or engagement style, rely on COS canonical sources instead of the glasses header.
+- For current events, news, or information not in your context, search the web.
+- When the user shares a photo, read the image file and describe what you see concisely. Answer any specific questions about the image. Keep descriptions under 200 characters unless asked for detail.
+- Aim for the right length, not the shortest. Quick Q&A → 200-600 chars. Synthesis / multi-part → up to ~2000. Glasses body scrolls continuously; no penalty for depth that earns its keep.
+- Be the best chief of staff — proactive, concise, no fluff.
+- You have conversation history from this session above. Use it to maintain context across turns.
+- Exchanges above are labeled with the user's global message numbers (e.g., [Msg 165]). When the user says "message 165", it refers to that exchange. Use these numbers when referencing past messages.
+- Only recent exchanges are shown — gaps in numbering mean older messages are outside the context window. If asked about a message not shown, suggest the user say "recall message N" to bring it into context.
+- If a REFERENCED MESSAGE section is present, use that as the authoritative content for any user-referenced message.
+- When you see [Photo context] entries in conversation history, those are summaries of earlier photo analyses. Use them for continuity but note you cannot see the original image — if asked for new detail, request a new photo.
+- Never say you cannot see previous messages — the history is provided above.`
+}