@gotcos/glasses-server 6.16.3 → 6.16.5

package/.env.example

@@ -91,6 +91,13 @@ BIND_HOST=0.0.0.0
 # COS_TTS_LOCAL_DISABLE=1          # disable the local sidecar explicitly
 # COS_TTS_PRONUNCIATIONS_JSON={"Exampleco":{"local":"[Exampleco](/ɪgzˈæmpəlkoʊ/)","openai":"ig-ZAM-pul-co"}}
 
+# ── WELCOME WEATHER (optional) ──────────────────────────────────────────
+# Phone GPS (Even Hub location permission) is the primary source. The Mac only
+# proxies Open-Meteo. If the phone denies location, set a home fallback:
+# COS_WEATHER_DEFAULT_LAT=30.5788
+# COS_WEATHER_DEFAULT_LON=-97.8531
+# COS_WEATHER_DEFAULT_CITY=Home
+
 # ── FULL COS PIPELINE (optional — leave unset for standalone) ────────────
 # Power users running the COS Starter Kit can point the glasses at their
 # pipeline to inherit live tasks/calendar/people context. Omit for standalone.

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 6.16.5
+
+- **Welcome weather restored on managed installs.** Ported authenticated
+  `GET /api/welcome-context` (Open-Meteo + reverse-geocode). Phone sends
+  `lat`/`lon` from Even Hub geolocation; Mac never invents a home city.
+  Without coords: last process coords → optional `COS_WEATHER_DEFAULT_*` →
+  omit weather. New coords await reverse-geocode (3s) before first JSON so
+  the city label is not stale. Calendar `nextEvent` stays optional via the
+  COS python bridge with public-safe OOO filtering only.
+
+## 6.16.4
+
+- **Cursor Agent on legacy `/api/query`.** 6.16.3 only forwarded
+  `cursorExecutionMode` on durable jobs. Most installs still run with
+  `durableQueryJobs: false`, so the companion fell back to `/api/query` and
+  Cursor stayed Ask (Shell Rejected). Legacy route now accepts the field;
+  Cursor omit/unknown defaults to **agent** (Settings default). Explicit `ask`
+  still forces read-only. Durable runtime uses the same default.
+
 ## 6.16.3
 
 - **Cursor Agent mode on durable jobs.** Glasses Settings → Agent now reaches

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.16.3",
+  "version": "6.16.5",
   "description": "COS Glasses — self-hosted AI heads-up-display server for Even G2 smart glasses, powered by Claude Code, Codex, or Cursor Agent CLI",
   "type": "module",
   "bin": {

package/server/index.ts

@@ -37,6 +37,7 @@ import { handoffsRouter } from './routes/handoffs.js'
 import { recoveryRouter } from './routes/recovery.js'
 import { promptEditRouter } from './routes/prompt-edit.js'
 import { bookmarksRouter } from './routes/bookmarks.js'
+import { welcomeContextRouter } from './routes/welcome-context.js'
 import { prewarmContext } from './lib/context-builder.js'
 import { preWarmCLI } from './lib/claude-bridge.js'
 import { getCodexRunConfig } from './lib/codex-run-ledger.js'
@@ -245,6 +246,7 @@ app.use('/api', handoffsRouter)
 app.use('/api', recoveryRouter)
 app.use('/api', promptEditRouter)
 app.use('/api', bookmarksRouter)
+app.use('/api', welcomeContextRouter)
 
 // OpenAI-compatible endpoint for the G2 Agent (ER "Add Agent")
 // Mounted at root — routes are /v1/chat/completions and /v1/models

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

@@ -13,6 +13,7 @@ import {
   isCursorModel,
   normalizeEffortPreference,
   normalizeModelPreference,
+  type CursorExecutionMode,
   type ModelPreference,
 } from '../../shared/model-preference.js'
 import { mergeMediaAttachmentRefs } from '../../shared/media-attachment.js'
@@ -238,8 +239,15 @@ const runner: QueryJobRunner = async ({ jobId, turnId, request, signal, callback
     {
       abortSignal: signal,
       effort: validEffort,
-      // Companion sends agent|ask; omit/unknown → ask (safe default for old clients).
-      cursorExecutionMode: request.cursorExecutionMode === 'agent' ? 'agent' : 'ask',
+      // Glasses Settings default is Agent. Explicit ask stays ask; omit → agent
+      // for Cursor so legacy clients aren't stuck in Ask when durable is off.
+      ...(validModel && isCursorModel(validModel)
+        ? {
+            cursorExecutionMode: (
+              request.cursorExecutionMode === 'ask' ? 'ask' : 'agent'
+            ) as CursorExecutionMode,
+          }
+        : {}),
       clientJobId: request.clientJobId,
       generation: request.generation,
       sessionLockHeld: true,

package/server/routes/query.ts

@@ -5,7 +5,11 @@ import { Router } from 'express'
 import { callModelStreaming } from '../lib/model-router.js'
 import { emitDisplay } from '../lib/display-bus.js'
 import { errMsg } from '../lib/utils.js'
-import { normalizeEffortPreference, normalizeModelPreference } from '../../shared/model-preference.js'
+import {
+  isCursorModel,
+  normalizeEffortPreference,
+  normalizeModelPreference,
+} from '../../shared/model-preference.js'
 import { QueryAttachmentError, resolveQueryAttachments } from '../lib/query-attachments.js'
 import { getMediaStore } from '../lib/media-store.js'
 import { mergeMediaAttachmentRefs } from '../../shared/media-attachment.js'
@@ -38,6 +42,9 @@ queryRouter.post('/query', async (req, res) => {
   const activityToolMode = req.body.activityToolMode === 'off' || req.body.activityToolMode === 'preview'
     ? req.body.activityToolMode
     : 'status'
+  // Glasses Settings default is Agent. Only an explicit "ask" stays read-only —
+  // omit/unknown must not silently force Ask (6.16.3 durable-only gap).
+  const cursorExecutionMode = req.body.cursorExecutionMode === 'ask' ? 'ask' as const : 'agent' as const
 
   // Resolve durable attachment ids and legacy base64 images through one
   // validation/normalization path before opening SSE.
@@ -170,7 +177,11 @@ queryRouter.post('/query', async (req, res) => {
         ? { query: String(reference.query), response: String(reference.response) }
         : undefined,
       validGlobalMsgNum,
-      { abortSignal: abortController.signal, effort: validEffort },
+      {
+        abortSignal: abortController.signal,
+        effort: validEffort,
+        ...(validModel && isCursorModel(validModel) ? { cursorExecutionMode } : {}),
+      },
     )
   } catch (err: unknown) {
     maintenanceLease.release()

package/server/routes/welcome-context.ts

@@ -0,0 +1,284 @@
+// GET /api/welcome-context — weather + optional next event for glasses home.
+// Weather uses phone-supplied lat/lon (Even Hub WebView geolocation). The Mac
+// only proxies Open-Meteo / reverse-geocode — it is not "server location".
+
+import { Router } from 'express'
+import { callPython } from '../lib/python-bridge.js'
+
+export const welcomeContextRouter = Router()
+
+const WEATHER_TTL_MS = 30 * 60_000
+const GEOCODE_TIMEOUT_MS = 3_000
+const FORECAST_TIMEOUT_MS = 3_000
+const CALENDAR_TTL_MS = 2 * 60_000
+const COORD_MOVE_DEG = 0.05 // ~5km
+
+type WeatherPayload = { temp: string; desc: string; location: string }
+type NextEventPayload = { title: string; time: string; inMinutes?: number }
+
+let cachedWeather: WeatherPayload | null = null
+let weatherFetchedAt = 0
+let lastKnownLat: number | undefined
+let lastKnownLon: number | undefined
+let lastKnownCity = ''
+
+let cachedNextEvent: NextEventPayload | null = null
+let calendarFetchedAt = 0
+
+/** Full WMO 4677 — discrete codes, exact match required. */
+export const WMO_CODES: Record<number, string> = {
+  0: 'Clear',
+  1: 'Mostly Clear',
+  2: 'Partly Cloudy',
+  3: 'Overcast',
+  45: 'Foggy',
+  48: 'Rime Fog',
+  51: 'Light Drizzle',
+  53: 'Drizzle',
+  55: 'Heavy Drizzle',
+  56: 'Freezing Drizzle',
+  57: 'Icy Drizzle',
+  61: 'Light Rain',
+  63: 'Rain',
+  65: 'Heavy Rain',
+  66: 'Freezing Rain',
+  67: 'Icy Rain',
+  71: 'Light Snow',
+  73: 'Snow',
+  75: 'Heavy Snow',
+  77: 'Snow Grains',
+  80: 'Light Showers',
+  81: 'Showers',
+  82: 'Violent Showers',
+  85: 'Snow Showers',
+  86: 'Heavy Snow Showers',
+  95: 'Thunderstorm',
+  96: 'T-Storm + Hail',
+  99: 'Severe T-Storm',
+}
+
+export function wmoDescription(code: number): string {
+  if (code in WMO_CODES) return WMO_CODES[code]
+  if (code >= 95) return 'Thunderstorm'
+  if (code >= 80) return 'Showers'
+  if (code >= 71) return 'Snow'
+  if (code >= 61) return 'Rain'
+  if (code >= 51) return 'Drizzle'
+  if (code >= 45) return 'Foggy'
+  if (code >= 1) return 'Cloudy'
+  return 'Clear'
+}
+
+export function parseCoord(raw: unknown, kind: 'lat' | 'lon'): number | undefined {
+  if (raw == null || raw === '') return undefined
+  const n = typeof raw === 'number' ? raw : parseFloat(String(raw))
+  if (!Number.isFinite(n)) return undefined
+  if (kind === 'lat' && (n < -90 || n > 90)) return undefined
+  if (kind === 'lon' && (n < -180 || n > 180)) return undefined
+  return n
+}
+
+function envDefaultCoords(): { lat: number; lon: number; city: string } | null {
+  const lat = parseCoord(process.env.COS_WEATHER_DEFAULT_LAT, 'lat')
+  const lon = parseCoord(process.env.COS_WEATHER_DEFAULT_LON, 'lon')
+  if (lat == null || lon == null) return null
+  const city = (process.env.COS_WEATHER_DEFAULT_CITY || '').trim()
+  return { lat, lon, city }
+}
+
+/** Resolve coords: phone query → last successful this process → optional env home. */
+export function resolveWeatherCoords(
+  queryLat?: number,
+  queryLon?: number,
+): { lat: number; lon: number; source: 'query' | 'last' | 'env' } | null {
+  if (queryLat != null && queryLon != null) {
+    return { lat: queryLat, lon: queryLon, source: 'query' }
+  }
+  if (lastKnownLat != null && lastKnownLon != null) {
+    return { lat: lastKnownLat, lon: lastKnownLon, source: 'last' }
+  }
+  const env = envDefaultCoords()
+  if (env) return { lat: env.lat, lon: env.lon, source: 'env' }
+  return null
+}
+
+async function reverseGeocode(lat: number, lon: number): Promise<string> {
+  try {
+    const res = await fetch(
+      `https://api.bigdatacloud.net/data/reverse-geocode-client?latitude=${lat}&longitude=${lon}&localityLanguage=en`,
+      { signal: AbortSignal.timeout(GEOCODE_TIMEOUT_MS) },
+    )
+    if (!res.ok) return lastKnownCity
+    const data = await res.json() as {
+      city?: string
+      locality?: string
+      principalSubdivision?: string
+      principalSubdivisionCode?: string
+      countryCode?: string
+    }
+    const city = data.city || data.locality || data.principalSubdivision || ''
+    const region = data.principalSubdivisionCode?.split('-')[1] || data.countryCode || ''
+    if (city) {
+      lastKnownCity = region ? `${city}, ${region}` : city
+    }
+    return lastKnownCity
+  } catch {
+    return lastKnownCity
+  }
+}
+
+export async function fetchWeather(
+  queryLat?: number,
+  queryLon?: number,
+): Promise<WeatherPayload | null> {
+  const resolved = resolveWeatherCoords(queryLat, queryLon)
+  if (!resolved) return null
+
+  const { lat: useLat, lon: useLon, source } = resolved
+  const coordsChanged = source === 'query'
+    && (
+      lastKnownLat == null
+      || lastKnownLon == null
+      || Math.abs(useLat - lastKnownLat) > COORD_MOVE_DEG
+      || Math.abs(useLon - lastKnownLon) > COORD_MOVE_DEG
+    )
+
+  if (coordsChanged) {
+    lastKnownLat = useLat
+    lastKnownLon = useLon
+    weatherFetchedAt = 0
+    // Blocker fix: wait for city before first paint (capped).
+    await reverseGeocode(useLat, useLon)
+  } else if (source === 'env' && !lastKnownCity) {
+    const env = envDefaultCoords()
+    if (env?.city) lastKnownCity = env.city
+    lastKnownLat = useLat
+    lastKnownLon = useLon
+  } else if (lastKnownLat == null) {
+    lastKnownLat = useLat
+    lastKnownLon = useLon
+  }
+
+  if (cachedWeather && Date.now() - weatherFetchedAt < WEATHER_TTL_MS) {
+    return cachedWeather
+  }
+
+  try {
+    const res = await fetch(
+      `https://api.open-meteo.com/v1/forecast?latitude=${useLat}&longitude=${useLon}&current=temperature_2m,weather_code&temperature_unit=fahrenheit&timezone=auto`,
+      { signal: AbortSignal.timeout(FORECAST_TIMEOUT_MS) },
+    )
+    if (!res.ok) return cachedWeather
+
+    const data = await res.json() as {
+      current?: { temperature_2m?: number; weather_code?: number }
+    }
+    const temp = data.current?.temperature_2m
+    const code = data.current?.weather_code
+    if (typeof temp !== 'number' || typeof code !== 'number') return cachedWeather
+
+    if (!lastKnownCity && source === 'env') {
+      const env = envDefaultCoords()
+      if (env?.city) lastKnownCity = env.city
+    }
+    if (!lastKnownCity) {
+      await reverseGeocode(useLat, useLon)
+    }
+
+    cachedWeather = {
+      temp: `${Math.round(temp)}\u00B0F`,
+      desc: wmoDescription(code),
+      location: lastKnownCity || `${useLat.toFixed(2)}, ${useLon.toFixed(2)}`,
+    }
+    weatherFetchedAt = Date.now()
+    return cachedWeather
+  } catch {
+    return cachedWeather
+  }
+}
+
+/** Public-safe filter only — no operator-specific title rules. */
+function isGenericNoiseEvent(title: string): boolean {
+  const t = (title || '').toLowerCase()
+  return /\booo\b|out of office|vacation|\bpto\b/i.test(t)
+}
+
+async function fetchNextEvent(): Promise<NextEventPayload | null> {
+  if (cachedNextEvent && Date.now() - calendarFetchedAt < CALENDAR_TTL_MS) {
+    return cachedNextEvent
+  }
+
+  try {
+    const cal = await callPython(['calendar']) as {
+      today_remaining?: Array<{
+        title?: string
+        start_time?: string
+        start?: string
+        is_all_day?: boolean
+      }>
+      next_event?: { title?: string; start_time?: string }
+      minutes_until_next?: number
+    } | null
+
+    const remaining = cal?.today_remaining ?? []
+    const meaningful = remaining.find((evt) => {
+      if (evt.is_all_day) return false
+      return !isGenericNoiseEvent(evt.title || '')
+    })
+
+    if (meaningful) {
+      const now = Date.now()
+      const eventTime = new Date(meaningful.start_time || meaningful.start || '').getTime()
+      const minsUntil = Number.isFinite(eventTime)
+        ? Math.max(0, Math.round((eventTime - now) / 60_000))
+        : undefined
+      cachedNextEvent = {
+        title: meaningful.title || 'Meeting',
+        time: meaningful.start_time || meaningful.start || '',
+        ...(minsUntil != null ? { inMinutes: minsUntil } : {}),
+      }
+    } else if (cal?.next_event && !isGenericNoiseEvent(cal.next_event.title || '')) {
+      cachedNextEvent = {
+        title: cal.next_event.title || 'Meeting',
+        time: cal.next_event.start_time || '',
+        ...(cal.minutes_until_next != null ? { inMinutes: cal.minutes_until_next } : {}),
+      }
+    } else {
+      cachedNextEvent = null
+    }
+
+    calendarFetchedAt = Date.now()
+    return cachedNextEvent
+  } catch {
+    return cachedNextEvent
+  }
+}
+
+/** Test helper — reset module caches between cases. */
+export function _resetWelcomeContextCachesForTests(): void {
+  cachedWeather = null
+  weatherFetchedAt = 0
+  lastKnownLat = undefined
+  lastKnownLon = undefined
+  lastKnownCity = ''
+  cachedNextEvent = null
+  calendarFetchedAt = 0
+}
+
+welcomeContextRouter.get('/welcome-context', async (req, res) => {
+  const lat = parseCoord(req.query.lat, 'lat')
+  const lon = parseCoord(req.query.lon, 'lon')
+  // Both required together; one alone is ignored.
+  const pairLat = lat != null && lon != null ? lat : undefined
+  const pairLon = lat != null && lon != null ? lon : undefined
+
+  const [weather, nextEvent] = await Promise.all([
+    fetchWeather(pairLat, pairLon),
+    fetchNextEvent(),
+  ])
+
+  res.json({
+    ...(weather ? { weather } : {}),
+    ...(nextEvent ? { nextEvent } : {}),
+  })
+})