@gotcos/glasses-server 6.16.0 → 6.16.2

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

@@ -0,0 +1,300 @@
+import crypto from 'node:crypto'
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { CURSOR_ENGINE_SESSION_TTL_MS } from './cursor-engine-sessions.js'
+import {
+  CURSOR_GROK_MODEL,
+  type CursorModelPreference,
+} from '../../shared/model-preference.js'
+import {
+  getCursorModelCatalogSnapshot,
+  resolveCursorModelOption,
+} from './cursor-model-catalog.js'
+import { getCodexExecutionCwd } from './codex-run-ledger.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 CursorRunStatus =
+  | 'running'
+  | 'completed'
+  | 'failed'
+  | 'cancelled'
+  | 'client_disconnected'
+
+export interface CursorRunRecord {
+  runId: string
+  turnId?: string
+  clientJobId?: string
+  cosSessionId: string
+  cursorChatId?: string
+  status: CursorRunStatus
+  createdAt: string
+  updatedAt: string
+  model: CursorModelPreference
+  cliModel: string
+  cwd: string
+  resumed?: boolean
+  expiresAt?: string
+  resumeCommand?: string
+  queryPreview?: string
+  outputPreview?: string
+  errorCode?: string
+  errorPreview?: string
+  durationMs?: number
+  exitCode?: number | null
+  messageEra?: string
+  globalMsgNum?: number
+  hasPersistedTerminalPatch?: boolean
+}
+
+interface CursorRunEvent {
+  runId: string
+  ts: string
+  patch: Partial<CursorRunRecord>
+}
+
+export interface CursorRunConfig {
+  cliModel: string
+  catalogSource: string
+  availableModels: Array<{ preference: CursorModelPreference; model: string; displayName: string }>
+  persistenceEnabled: boolean
+  cwd: string
+  engineSessionTtlMinutes: number
+  historyLimit: number
+  historyTtlDays: number
+  contentPreviewsEnabled: boolean
+}
+
+export function isCursorPersistenceEnabled(): boolean {
+  return process.env.COS_CURSOR_PERSIST_SESSIONS !== '0'
+}
+
+export function areCursorContentPreviewsEnabled(): boolean {
+  return process.env.COS_CURSOR_RUN_CONTENT_PREVIEWS === '1'
+}
+
+/** Same workspace resolver as Codex — Cursor --workspace uses this path. */
+export function getCursorExecutionCwd(): string {
+  return getCodexExecutionCwd()
+}
+
+export function getCursorRunConfig(): CursorRunConfig {
+  const catalog = getCursorModelCatalogSnapshot()
+  const grok = resolveCursorModelOption(CURSOR_GROK_MODEL)
+  return {
+    cliModel: grok?.id || 'cursor-cli-default',
+    catalogSource: catalog.source,
+    availableModels: catalog.options.map(option => ({
+      preference: option.preference,
+      model: option.id || 'cursor-cli-default',
+      displayName: option.displayName,
+    })),
+    persistenceEnabled: isCursorPersistenceEnabled(),
+    cwd: getCursorExecutionCwd(),
+    engineSessionTtlMinutes: Math.round(CURSOR_ENGINE_SESSION_TTL_MS / 60_000),
+    historyLimit: getMaxRuns(),
+    historyTtlDays: Math.round(getTtlMs() / (24 * 60 * 60_000)),
+    contentPreviewsEnabled: areCursorContentPreviewsEnabled(),
+  }
+}
+
+export function getCursorLedgerPath(): string {
+  return resolve(process.env.COS_CURSOR_RUN_LEDGER_FILE || resolve(import.meta.dirname, '..', 'data', 'cursor-runs.jsonl'))
+}
+
+function getMaxRuns(): number {
+  const raw = Number(process.env.COS_CURSOR_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_CURSOR_RUN_LEDGER_TTL_DAYS ?? 7)
+  return Number.isFinite(rawDays) && rawDays > 0 ? rawDays * 24 * 60 * 60_000 : DEFAULT_TTL_MS
+}
+
+function appendEvent(event: CursorRunEvent): void {
+  try {
+    const path = getCursorLedgerPath()
+    mkdirSync(dirname(path), { recursive: true })
+    appendFileSync(path, JSON.stringify(event) + '\n')
+  } catch (err) {
+    console.warn('[cursor-run-ledger] write skipped:', err)
+  }
+}
+
+function readEvents(): CursorRunEvent[] {
+  const path = getCursorLedgerPath()
+  if (!existsSync(path)) return []
+  try {
+    const events: CursorRunEvent[] = []
+    for (const line of readFileSync(path, 'utf-8')
+      .split('\n')
+      .map(line => line.trim())
+      .filter(Boolean)) {
+      try {
+        const event = JSON.parse(line) as CursorRunEvent
+        if (typeof event.runId === 'string' && typeof event.ts === 'string' && typeof event.patch === 'object') {
+          events.push(event)
+        }
+      } catch {
+        // Skip torn/corrupt JSONL rows.
+      }
+    }
+    return events
+  } catch {
+    return []
+  }
+}
+
+function hydrateRuns(): CursorRunRecord[] {
+  const runs = new Map<string, CursorRunRecord>()
+  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 CursorRunRecord
+    if (next.cursorChatId && !next.resumeCommand) {
+      next.resumeCommand = `agent --resume ${next.cursorChatId}`
+    }
+    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)) {
+        return {
+          ...run,
+          status: 'client_disconnected' as const,
+          errorCode: run.errorCode ?? 'cursor.interrupted',
+        }
+      }
+      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 redactForCursorLedger(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|keycurs)-[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 classifyCursorError(message: string): string {
+  const text = message.toLowerCase()
+  if (/command not found|enoent|not found|agent binary/.test(text)) return 'cursor.cli_unavailable'
+  if (/permission|denied|sandbox|read-only|operation not permitted/.test(text)) return 'cursor.permission_denied'
+  if (/auth|login|sign in|unauthorized|forbidden|token|(?:api|http|error)\s*(?:error)?\s*[:=-]?\s*(?:401|403)\b/.test(text)) {
+    return 'cursor.auth_error'
+  }
+  if (/timeout|timed out|wall clock|no output/.test(text)) return 'cursor.timeout'
+  if (/exit\s+\d+/.test(text)) return 'cursor.nonzero_exit'
+  return 'cursor.error'
+}
+
+export function startCursorRun(input: {
+  turnId?: string
+  clientJobId?: string
+  cosSessionId: string
+  model: CursorModelPreference
+  cwd: string
+  resumed?: boolean
+  cursorChatId?: string
+  expiresAt?: string
+  query: string
+  cliModel?: string
+  messageEra?: string
+  globalMsgNum?: number
+}): CursorRunRecord {
+  const now = new Date().toISOString()
+  const run: CursorRunRecord = {
+    runId: `cursor-${crypto.randomUUID().slice(0, 8)}`,
+    turnId: input.turnId,
+    clientJobId: input.clientJobId,
+    cosSessionId: input.cosSessionId,
+    status: 'running',
+    createdAt: now,
+    updatedAt: now,
+    model: input.model,
+    cliModel: input.cliModel ?? (resolveCursorModelOption(input.model)?.id || 'cursor-cli-default'),
+    cwd: input.cwd,
+    resumed: input.resumed,
+    cursorChatId: input.cursorChatId,
+    expiresAt: input.expiresAt,
+    messageEra: input.messageEra,
+    globalMsgNum: input.globalMsgNum,
+    hasPersistedTerminalPatch: false,
+  }
+  if (areCursorContentPreviewsEnabled()) {
+    run.queryPreview = redactForCursorLedger(input.query)
+  }
+  appendEvent({ runId: run.runId, ts: now, patch: run })
+  return run
+}
+
+export function updateCursorRun(runId: string, patch: Partial<Omit<CursorRunRecord, 'runId' | 'createdAt'>>): CursorRunRecord | null {
+  const ts = new Date().toISOString()
+  const safePatch = { ...patch, updatedAt: ts }
+  if (safePatch.cursorChatId && !safePatch.resumeCommand) {
+    safePatch.resumeCommand = `agent --resume ${safePatch.cursorChatId}`
+  }
+  appendEvent({ runId, ts, patch: safePatch })
+  return getCursorRun(runId)
+}
+
+export function finishCursorRun(runId: string, input: {
+  status: Exclude<CursorRunStatus, 'running'>
+  startedAtMs: number
+  output?: string
+  error?: string
+  exitCode?: number | null
+}): CursorRunRecord | null {
+  const patch: Partial<CursorRunRecord> = {
+    status: input.status,
+    hasPersistedTerminalPatch: true,
+    durationMs: Math.max(0, Date.now() - input.startedAtMs),
+    exitCode: input.exitCode,
+  }
+  if (input.output && areCursorContentPreviewsEnabled()) {
+    patch.outputPreview = redactForCursorLedger(input.output)
+  }
+  if (input.error) {
+    patch.errorCode = classifyCursorError(input.error)
+    if (areCursorContentPreviewsEnabled()) {
+      patch.errorPreview = redactForCursorLedger(input.error)
+    }
+  }
+  return updateCursorRun(runId, patch)
+}
+
+export function listCursorRuns(limit = 20, cosSessionId?: string): CursorRunRecord[] {
+  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 getCursorRun(runId: string): CursorRunRecord | null {
+  return hydrateRuns().find(run => run.runId === runId) ?? null
+}

package/server/lib/hallucination-filter.ts

@@ -343,7 +343,7 @@ function getVocabEchoMatcher(): RegExp {
   // Only UNAMBIGUOUS terms trigger an echo drop: multi-word phrases ("POS Nation",
   // "IT Retail", "Jeremy Sokolic") and brand-shaped single tokens with an internal
   // capital or digit ("POSNation", "CaratIQ", "Jewel360"). Plain single-word tokens
-  // ("Austin", "Miles", "Ukaoma") are common words / ambiguous and are EXCLUDED —
+  // Common words and ambiguous proper nouns are deliberately excluded —
   // they carry too much false-drop risk for an always-on list rule.
   const terms = [...raw].filter(t => {
     if (t.length < 2) return false

package/server/lib/model-router.ts

@@ -1,5 +1,6 @@
 import { callClaudeStreaming, type CallOptions, type StreamCallbacks } from './claude-bridge.js'
 import { callCodexStreaming } from './codex-bridge.js'
+import { callCursorStreaming } from './cursor-bridge.js'
 import {
   getOrCreateSession,
   getSessionModel,
@@ -7,7 +8,18 @@ import {
   type ModelPreference,
   type PromptReference,
 } from './conversation.js'
-import { DEFAULT_MODEL, isCodexModel, isClaudeModel, normalizeModelPreference } from '../../shared/model-preference.js'
+import {
+  DEFAULT_MODEL,
+  isCodexModel,
+  isClaudeModel,
+  isCursorModel,
+  normalizeModelPreference,
+} from '../../shared/model-preference.js'
+import {
+  getCursorModelCatalog,
+  isCursorProviderReady,
+  resolveCursorModelOption,
+} from './cursor-model-catalog.js'
 import type { ModelImageInput } from './model-image-input.js'
 
 // Bridges return as soon as their subprocess is spawned, while completion is
@@ -87,6 +99,19 @@ export async function callModelStreaming(
   }
 
   try {
+    // Cursor slots fail closed — never fall through to Claude/Codex.
+    if (isCursorModel(resolvedModel)) {
+      await getCursorModelCatalog()
+      const option = resolveCursorModelOption(resolvedModel)
+      if (!isCursorProviderReady() || !option?.id) {
+        const message = !option?.id
+          ? `cursor-bridge: Cursor model slot ${resolvedModel} is not resolved. Check agent models / login.`
+          : 'cursor-bridge: Cursor CLI unavailable. Install agent and run agent login.'
+        await lockedCallbacks.onError(message)
+        return sid
+      }
+      return await callCursorStreaming(query, sid, lockedCallbacks, resolvedModel, images, reference, globalMsgNum, options)
+    }
     if (isCodexModel(resolvedModel)) {
       return await callCodexStreaming(query, sid, lockedCallbacks, resolvedModel, images, reference, globalMsgNum, options)
     }

package/server/lib/provider-terminal-error.ts

@@ -1,4 +1,4 @@
-export type CliProvider = 'claude' | 'codex'
+export type CliProvider = 'claude' | 'codex' | 'cursor'
 
 const AUTH_CODE = /^(?:401|403|unauthori[sz]ed|forbidden|authentication_error|authorization_error|invalid_api_key|not_authenticated)$/i
 // Match whole, terminal-looking provider failures only. Natural assistant

package/server/lib/query-job-coordinator.ts

@@ -292,6 +292,7 @@ export class QueryJobCoordinator {
             claudeRunId: snapshot.claudeRunId,
             codexRunId: snapshot.codexRunId,
             codexThreadId: snapshot.codexThreadId,
+            cursorRunId: snapshot.cursorRunId,
           })
           // Generation is already durable, but bridge post-processing missed
           // its deadline. Abort that tail after committing the answer so the

package/server/lib/query-job-runtime.ts

@@ -10,6 +10,7 @@ import { QueryJobCoordinator, type QueryJobRunner } from './query-job-coordinato
 import { QueryJobStore } from './query-job-store.js'
 import {
   isCodexModel,
+  isCursorModel,
   normalizeEffortPreference,
   normalizeModelPreference,
   type ModelPreference,
@@ -48,7 +49,8 @@ export async function preparePublicDurableQueryAdmission(raw: unknown): Promise<
   }
 }
 
-function providerFor(model: ModelPreference): 'claude' | 'codex' {
+function providerFor(model: ModelPreference): 'claude' | 'codex' | 'cursor' {
+  if (isCursorModel(model)) return 'cursor'
   return isCodexModel(model) ? 'codex' : 'claude'
 }
 
@@ -122,6 +124,7 @@ const runner: QueryJobRunner = async ({ jobId, turnId, request, signal, callback
           claudeRunId: metadata?.claudeRunId,
           codexRunId: metadata?.codexRunId,
           codexThreadId: metadata?.codexThreadId,
+          cursorRunId: metadata?.cursorRunId,
         } as const
         await callbacks.onStart({ sessionId, ...linkage })
         emitDisplay({ type: 'start', data: {
@@ -142,7 +145,9 @@ const runner: QueryJobRunner = async ({ jobId, turnId, request, signal, callback
         ...(activeModel ? { resolvedModel: activeModel } : {}),
         ...(metadata.provider === 'claude'
           ? { claudeRunId: metadata.runId }
-          : { codexRunId: metadata.runId }),
+          : metadata.provider === 'cursor'
+            ? { cursorRunId: metadata.runId }
+            : { codexRunId: metadata.runId }),
       }),
       onChunk: text => { callbacks.onChunk(text) },
       onToolStatus: toolName => {
@@ -175,6 +180,7 @@ const runner: QueryJobRunner = async ({ jobId, turnId, request, signal, callback
           claudeRunId: metadata?.claudeRunId,
           codexRunId: metadata?.codexRunId,
           codexThreadId: metadata?.codexThreadId,
+          cursorRunId: metadata?.cursorRunId,
         } as const
         // Publish compatibility completion only after the durable terminal is
         // fsynced. Display subscribers can disappear without owning this job.

package/server/lib/query-job-store.ts

@@ -361,6 +361,7 @@ export class QueryJobStore {
             claudeRunId: snapshot.claudeRunId,
             codexRunId: snapshot.codexRunId,
             codexThreadId: snapshot.codexThreadId,
+            cursorRunId: snapshot.cursorRunId,
           })
         } else {
           const result = await this.interrupt(snapshot.jobId, 'server_restarted')
@@ -548,9 +549,11 @@ export class QueryJobStore {
   }
 
   private applyLinkage(snapshot: QueryJobSnapshot, raw: Record<string, unknown>): void {
-    const provider = raw.provider === 'claude' || raw.provider === 'codex' ? raw.provider : undefined
+    const provider = raw.provider === 'claude' || raw.provider === 'codex' || raw.provider === 'cursor'
+      ? raw.provider
+      : undefined
     if (provider) snapshot.provider = provider
-    const fields = ['resolvedModel', 'cliSessionId', 'claudeRunId', 'codexRunId', 'codexThreadId'] as const
+    const fields = ['resolvedModel', 'cliSessionId', 'claudeRunId', 'codexRunId', 'codexThreadId', 'cursorRunId'] as const
     for (const field of fields) {
       const value = safeOptional(raw[field])
       if (value) snapshot[field] = value
@@ -795,6 +798,7 @@ export class QueryJobStore {
         claudeRunId: current.claudeRunId,
         codexRunId: current.codexRunId,
         codexThreadId: current.codexThreadId,
+        cursorRunId: current.cursorRunId,
       })
     }
     const normalized = normalizeQueryJobError(error)
@@ -831,6 +835,7 @@ export class QueryJobStore {
         claudeRunId: current.claudeRunId,
         codexRunId: current.codexRunId,
         codexThreadId: current.codexThreadId,
+        cursorRunId: current.cursorRunId,
       })
     }
     const error: QueryJobError = {
@@ -880,12 +885,15 @@ export class QueryJobStore {
 
   private safeLinkage(linkage: QueryJobProviderLinkage): QueryJobProviderLinkage {
     return {
-      ...(linkage.provider === 'claude' || linkage.provider === 'codex' ? { provider: linkage.provider } : {}),
+      ...(linkage.provider === 'claude' || linkage.provider === 'codex' || linkage.provider === 'cursor'
+        ? { provider: linkage.provider }
+        : {}),
       ...(safeOptional(linkage.resolvedModel, 64) ? { resolvedModel: safeOptional(linkage.resolvedModel, 64) } : {}),
       ...(safeOptional(linkage.cliSessionId) ? { cliSessionId: safeOptional(linkage.cliSessionId) } : {}),
       ...(safeOptional(linkage.claudeRunId) ? { claudeRunId: safeOptional(linkage.claudeRunId) } : {}),
       ...(safeOptional(linkage.codexRunId) ? { codexRunId: safeOptional(linkage.codexRunId) } : {}),
       ...(safeOptional(linkage.codexThreadId) ? { codexThreadId: safeOptional(linkage.codexThreadId) } : {}),
+      ...(safeOptional(linkage.cursorRunId) ? { cursorRunId: safeOptional(linkage.cursorRunId) } : {}),
     }
   }
 

package/server/lib/query-job-types.ts

@@ -73,12 +73,13 @@ export interface QueryJobRequest {
 }
 
 export interface QueryJobProviderLinkage {
-  provider?: 'claude' | 'codex'
+  provider?: 'claude' | 'codex' | 'cursor'
   resolvedModel?: string
   cliSessionId?: string
   claudeRunId?: string
   codexRunId?: string
   codexThreadId?: string
+  cursorRunId?: string
 }
 
 /** Path/id-free aggregate from output-image finalization. Values are bounded

package/server/lib/speaker-trainer.ts

@@ -78,7 +78,7 @@ export interface TrainingStatus {
 
 function getApiKey(): string {
   const key = loadCosEnvKey('FIREFLIES_API_KEY')
-  if (!key) throw new Error('FIREFLIES_API_KEY not found — set it in MU-Chief-Staff/.env')
+  if (!key) throw new Error('FIREFLIES_API_KEY not found — set it in your COS environment')
   return key
 }
 

package/server/lib/token-audit.ts

@@ -23,11 +23,16 @@ function estimateTokens(chars: number): number {
 
 export interface TokenAuditEntry {
   source: string       // "g2-voice", "g2-prewarm", "g2-archive", "g2-query"
-  model: string        // "opus", "sonnet", "haiku"
+  model: string        // "opus", "sonnet", "haiku", "cursor-composer", ...
   inputChars: number
   outputChars: number
   durationMs: number
   caller: string       // "voice_query", "prewarm", "chat_summary", "day_summary"
+  turnId?: string
+  runId?: string
+  sessionId?: string
+  clientJobId?: string
+  usageKind?: 'provider_final' | 'estimated'
 }
 
 export function logTokenAudit(entry: TokenAuditEntry): void {
@@ -41,6 +46,11 @@ export function logTokenAudit(entry: TokenAuditEntry): void {
     est_output_tokens: estimateTokens(entry.outputChars),
     duration_ms: entry.durationMs,
     caller: entry.caller,
+    usage_kind: entry.usageKind ?? 'estimated',
+    ...(entry.turnId ? { turn_id: entry.turnId } : {}),
+    ...(entry.runId ? { run_id: entry.runId } : {}),
+    ...(entry.sessionId ? { session_id: entry.sessionId } : {}),
+    ...(entry.clientJobId ? { client_job_id: entry.clientJobId } : {}),
   }
   try {
     appendFileSync(AUDIT_FILE, JSON.stringify(record) + '\n', { encoding: 'utf8', mode: 0o600 })

package/server/routes/cli-debug.ts

@@ -8,6 +8,10 @@ import {
   getCodexRunConfig,
   listCodexRuns,
 } from '../lib/codex-run-ledger.js'
+import {
+  getCursorRunConfig,
+  listCursorRuns,
+} from '../lib/cursor-run-ledger.js'
 import {
   safeCliDebugResponse,
   safeLegacyClaudeResponse,
@@ -38,13 +42,17 @@ cliDebugRouter.get('/cli/debug', (req, res) => {
   const model = optionalClaudeModel(req.query.model)
   const claudeConfig = getClaudeRunConfig()
   const codexConfig = getCodexRunConfig()
+  const cursorConfig = getCursorRunConfig()
   const claudeRuns = listClaudeRuns(limit, sessionId, model)
   const codexRuns = listCodexRuns(limit, sessionId)
+  const cursorRuns = listCursorRuns(limit, sessionId)
   res.json(safeCliDebugResponse(
     claudeConfig,
     claudeRuns[0],
     codexConfig,
     codexRuns[0],
+    cursorConfig,
+    cursorRuns[0],
   ))
 })