@gotcos/glasses-server 6.21.33 → 6.21.34

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+## 6.21.34
+
+- **Memory and Threads are now real production surfaces.** Authenticated
+  `/api/memory` and `/api/threads` list/detail routes expose bounded read-only
+  projections from the configured COS pipeline instead of returning 404.
+- **Stable references, not storage internals.** Memory uses its logical
+  `mem_...` ID and Threads use their existing stable ID. Responses never expose
+  embeddings, Qdrant point IDs, raw cache files, secrets, or local paths.
+- **Memory overview is complete.** The store total and type split scan the full
+  collection instead of silently stopping after the first 1,000 records.
+- **Manual threads remain visible immediately.** The bridge merges the computed
+  thread cache with the durable manual-thread store without mutating either.
+- **Standalone installs fail honestly.** Systems without a COS scripts pipeline
+  return empty/unavailable shapes while the rest of the glasses server remains
+  usable.
+
 ## 6.21.33
 
 - **Existing meeting libraries can be selected directly.** `COS_MEETINGS_ROOT`

package/README.md

@@ -301,6 +301,15 @@ direct library and an operations root are both configured, the server merges
 them with standalone G2 recordings and prefers the enriched writable record
 for the same session.
 
+Server 6.21.34 adds authenticated, read-only Memory and Threads browsing for
+full COS installs. With `COS_SCRIPTS_DIR` configured, the companion can show the
+complete Bot Memory count/type split, bounded recent summaries, exact logical
+memory IDs, and existing tracked/manual threads. Exact detail requests are
+resolved by stable ID so a spoken follow-up can carry the selected snapshot as
+context. Embeddings, vector-store point IDs, cache files, secrets, and local
+paths never cross the API boundary. Standalone installs report the feature as
+unavailable without affecting messages, meetings, transcription, or agents.
+
 The first server start downloads the real-time turbo model. True HQ additionally
 requires the full `ggml-large-v3.bin` model (about 3.1 GB):
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.21.33",
+  "version": "6.21.34",
   "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

@@ -39,6 +39,8 @@ import { promptEditRouter } from './routes/prompt-edit.js'
 import { bookmarksRouter } from './routes/bookmarks.js'
 import { welcomeContextRouter } from './routes/welcome-context.js'
 import { liveCuesRouter } from './routes/live-cues.js'
+import { memoryRouter } from './routes/memory.js'
+import { threadsRouter } from './routes/threads.js'
 import { shutdownLiveCues } from './lib/live-cues-engine.js'
 import { prewarmContext } from './lib/context-builder.js'
 import { preWarmCLI } from './lib/claude-bridge.js'
@@ -233,6 +235,8 @@ app.use('/api', displayRouter)
 app.use('/api', transcribeStreamRouter)
 app.use('/api', meetingRouter)
 app.use('/api', meetingsRouter)
+app.use('/api', memoryRouter)
+app.use('/api', threadsRouter)
 app.use('/api', openaiKeyRouter)
 // v6.3.0 — Message History, cross-day 'reference message N', and history
 // recovery for public npx users (previously full-COS-server only).

package/server/lib/cos-context-browser.ts

@@ -0,0 +1,230 @@
+export const MEMORY_ID_PATTERN = /^mem_[A-Za-z0-9_:-]{1,120}$/
+export const THREAD_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/
+
+const CONTROL_CHARS = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g
+const ABSOLUTE_PATH = /(^|[\s("'`])(?:~\/|\/(?!\/)(?:[^/\s)"'`]+\/)+[^/\s)"'`]+\/?)/g
+const SECRET_TOKEN = /\b(?:sk-[A-Za-z0-9_-]{12,}|(?:bearer|token|api[_ -]?key)\s*[:=]\s*[A-Za-z0-9._-]{12,})\b/gi
+
+export interface MemoryRefGroups {
+  people?: string[]
+  files?: string[]
+  meetings?: string[]
+  threads?: string[]
+}
+
+export interface MemoryListItem {
+  id: string
+  type: string
+  summary: string
+  content: string
+  created_at: string
+  domain: string
+  refs: MemoryRefGroups
+  reference_available: true
+}
+
+export interface ThreadListItem {
+  id: string
+  name: string
+  domain: string
+  is_manual: boolean
+  topics: string[]
+  meeting_count: number
+  first_seen: string
+  last_seen: string
+  velocity: string
+  age_days: number
+  is_stale: boolean
+  is_resolved: boolean
+  meetings: Array<{ name: string; date: string }>
+  manual_updates: Array<{ content: string; timestamp: string; source: string }>
+  stakeholders: string[]
+  milestones: string[]
+  sources: string[]
+  target_date: string
+  serves_goal: string
+  created_at: string
+  created_by: string
+  access_count: number
+  reference_available: true
+}
+
+export function cleanContextText(value: unknown, limit: number): string {
+  let text = typeof value === 'string' ? value : value == null ? '' : String(value)
+  text = text.replace(CONTROL_CHARS, '')
+  text = text.replace(ABSOLUTE_PATH, (_match, prefix: string) => `${prefix}[local path hidden]`)
+  text = text.replace(SECRET_TOKEN, '[secret hidden]')
+  return text.trim().slice(0, limit)
+}
+
+function finiteInteger(value: unknown, fallback = 0, maximum = Number.MAX_SAFE_INTEGER): number {
+  const number = typeof value === 'number' ? value : Number(value)
+  if (!Number.isFinite(number)) return fallback
+  return Math.max(0, Math.min(maximum, Math.trunc(number)))
+}
+
+function stringList(value: unknown, itemLimit: number, textLimit: number): string[] {
+  if (!Array.isArray(value)) return []
+  return value.slice(0, itemLimit).map(item => {
+    if (item && typeof item === 'object' && !Array.isArray(item)) {
+      const record = item as Record<string, unknown>
+      const label = record.title ?? record.name ?? record.summary ?? record.content ?? record.path ?? record.url
+      return cleanContextText(label ?? '', textLimit)
+    }
+    return cleanContextText(item, textLimit)
+  }).filter(Boolean)
+}
+
+function memoryRefs(value: unknown): MemoryRefGroups {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {}
+  const source = value as Record<string, unknown>
+  const result: MemoryRefGroups = {}
+  for (const key of ['people', 'files', 'meetings', 'threads'] as const) {
+    const items = stringList(source[key], 12, 160)
+    if (items.length) result[key] = items
+  }
+  return result
+}
+
+export function normalizeMemoryList(value: unknown, limit: number): MemoryListItem[] {
+  if (!Array.isArray(value)) return []
+  const result: MemoryListItem[] = []
+  for (const row of value.slice(0, Math.max(0, Math.min(limit, 50)))) {
+    if (!row || typeof row !== 'object' || Array.isArray(row)) continue
+    const source = row as Record<string, unknown>
+    const id = cleanContextText(source.id, 128)
+    if (!MEMORY_ID_PATTERN.test(id)) continue
+    result.push({
+      id,
+      type: cleanContextText(source.type || 'unknown', 48),
+      summary: cleanContextText(source.summary || source.content, 240),
+      content: cleanContextText(source.content, 1200),
+      created_at: cleanContextText(source.created_at, 64),
+      domain: cleanContextText(source.domain, 64),
+      refs: memoryRefs(source.refs),
+      reference_available: true,
+    })
+  }
+  return result
+}
+
+export function normalizeMemoryDetail(value: unknown): (MemoryListItem & {
+  auto_generated: boolean
+  consolidated: boolean
+}) | null {
+  const rows = normalizeMemoryList(value && typeof value === 'object' ? [value] : [], 1)
+  if (!rows[0] || !value || typeof value !== 'object' || Array.isArray(value)) return null
+  const source = value as Record<string, unknown>
+  return {
+    ...rows[0],
+    content: cleanContextText(source.content, 32_000),
+    auto_generated: source.auto_generated === true,
+    consolidated: source.consolidated === true,
+  }
+}
+
+function normalizeThread(value: unknown, detail: boolean): ThreadListItem | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null
+  const source = value as Record<string, unknown>
+  const id = cleanContextText(source.id, 128)
+  if (!THREAD_ID_PATTERN.test(id)) return null
+  const meetings = Array.isArray(source.meetings)
+    ? source.meetings.slice(0, detail ? 50 : 12).flatMap(item => {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) return []
+        const meeting = item as Record<string, unknown>
+        return [{ name: cleanContextText(meeting.name, 240), date: cleanContextText(meeting.date, 32) }]
+      })
+    : []
+  const manualUpdates = Array.isArray(source.manual_updates)
+    ? source.manual_updates.slice(0, detail ? 20 : 8).flatMap(item => {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) return []
+        const update = item as Record<string, unknown>
+        return [{
+          content: cleanContextText(update.content, detail ? 2000 : 500),
+          timestamp: cleanContextText(update.timestamp, 64),
+          source: cleanContextText(update.source, 120),
+        }]
+      })
+    : []
+  return {
+    id,
+    name: cleanContextText(source.name || 'Untitled thread', 160),
+    domain: cleanContextText(source.domain || 'unknown', 64),
+    is_manual: source.is_manual === true,
+    topics: stringList(source.topics, detail ? 40 : 12, 160),
+    meeting_count: finiteInteger(source.meeting_count, meetings.length, 100_000),
+    first_seen: cleanContextText(source.first_seen, 32),
+    last_seen: cleanContextText(source.last_seen, 32),
+    velocity: cleanContextText(source.velocity, 48),
+    age_days: finiteInteger(source.age_days, 0, 1_000_000),
+    is_stale: source.is_stale === true,
+    is_resolved: source.is_resolved === true,
+    meetings,
+    manual_updates: manualUpdates,
+    stakeholders: stringList(source.stakeholders, detail ? 30 : 12, 160),
+    milestones: stringList(source.milestones, detail ? 30 : 8, 500),
+    sources: stringList(source.sources, detail ? 30 : 8, 500),
+    target_date: cleanContextText(source.target_date, 32),
+    serves_goal: cleanContextText(source.serves_goal, 160),
+    created_at: cleanContextText(source.created_at, 64),
+    created_by: cleanContextText(source.created_by, 120),
+    access_count: finiteInteger(source.access_count),
+    reference_available: true,
+  }
+}
+
+export function normalizeThreads(value: unknown, limit: number): {
+  generated_at: string
+  active_count: number
+  stale_count: number
+  resolved_count: number
+  threads: ThreadListItem[]
+} {
+  const source = value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {}
+  const rawThreads = Array.isArray(source.threads) ? source.threads : []
+  const threads = rawThreads.slice(0, Math.max(0, Math.min(limit, 50)))
+    .map(item => normalizeThread(item, false))
+    .filter((item): item is ThreadListItem => item !== null)
+  return {
+    generated_at: cleanContextText(source.generated_at, 64),
+    active_count: finiteInteger(source.active_count),
+    stale_count: finiteInteger(source.stale_count),
+    resolved_count: finiteInteger(source.resolved_count),
+    threads,
+  }
+}
+
+export function normalizeThreadDetail(value: unknown): ThreadListItem | null {
+  return normalizeThread(value, true)
+}
+
+export function normalizeMemoryOverview(value: unknown): {
+  available: boolean
+  collection: 'cos_memory'
+  total: number
+  by_type: Record<string, number>
+  reason?: string
+} {
+  const source = value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {}
+  const rawTypes = source.by_type && typeof source.by_type === 'object' && !Array.isArray(source.by_type)
+    ? source.by_type as Record<string, unknown>
+    : {}
+  const byType: Record<string, number> = {}
+  for (const [rawKey, rawValue] of Object.entries(rawTypes).slice(0, 24)) {
+    const key = cleanContextText(rawKey, 48)
+    if (key) byType[key] = finiteInteger(rawValue)
+  }
+  const result: ReturnType<typeof normalizeMemoryOverview> = {
+    available: source.available === true,
+    collection: 'cos_memory',
+    total: finiteInteger(source.total),
+    by_type: byType,
+  }
+  const reason = cleanContextText(source.reason, 120)
+  if (reason) result.reason = reason
+  return result
+}

package/server/lib/python-bridge.ts

@@ -31,6 +31,10 @@ const BRIDGE_SCRIPT: string | null = COS_SCRIPTS_DIR ? resolve(COS_SCRIPTS_DIR,
 // have these, so callPython() degrades to a no-op.
 const pythonAvailable = !!(COS_SCRIPTS_DIR && existsSync(PYTHON_BIN!) && existsSync(BRIDGE_SCRIPT!))
 
+export function pythonBridgeAvailable(): boolean {
+  return pythonAvailable
+}
+
 if (pythonAvailable) {
   console.log('[python-bridge] COS pipeline detected — sourcing live context')
 } else if (COS_SCRIPTS_DIR) {
@@ -54,8 +58,17 @@ function standaloneNoop(args: string[]): unknown {
   switch (args[0]) {
     case 'calendar': return { events: [] }
     case 'tasks': return {}
-    case 'threads': return []
+    case 'threads': return { threads: [], active_count: 0, stale_count: 0, resolved_count: 0 }
+    case 'thread-detail': return { error: 'cos_pipeline_not_configured' }
     case 'memory': return []
+    case 'memory-overview': return {
+      available: false,
+      collection: 'cos_memory',
+      total: 0,
+      by_type: {},
+      reason: 'cos_pipeline_not_configured',
+    }
+    case 'memory-detail': return { error: 'cos_pipeline_not_configured' }
     case 'badges': return {}
     default: return {}
   }

package/server/routes/memory.ts

@@ -0,0 +1,65 @@
+import { Router } from 'express'
+import { callPython } from '../lib/python-bridge.js'
+import {
+  MEMORY_ID_PATTERN,
+  normalizeMemoryDetail,
+  normalizeMemoryList,
+  normalizeMemoryOverview,
+} from '../lib/cos-context-browser.js'
+
+export const memoryRouter = Router()
+
+function boundedInteger(value: unknown, fallback: number, min: number, max: number): number {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.max(min, Math.min(max, Math.trunc(parsed)))
+}
+
+memoryRouter.get('/memory/overview', async (_req, res) => {
+  try {
+    const data = await callPython(['memory-overview'])
+    res.json(normalizeMemoryOverview(data))
+  } catch (error) {
+    res.status(503).json({
+      available: false,
+      collection: 'cos_memory',
+      total: 0,
+      by_type: {},
+      reason: 'memory_bridge_unavailable',
+    })
+  }
+})
+
+memoryRouter.get('/memory/:id', async (req, res) => {
+  if (!MEMORY_ID_PATTERN.test(req.params.id)) {
+    res.status(400).json({ error: 'invalid_memory_id' })
+    return
+  }
+  try {
+    const data = await callPython(['memory-detail', req.params.id])
+    if (data && typeof data === 'object' && 'error' in data) {
+      res.status(404).json({ error: 'memory_not_found' })
+      return
+    }
+    const memory = normalizeMemoryDetail(data)
+    if (!memory) {
+      res.status(404).json({ error: 'memory_not_found' })
+      return
+    }
+    res.json(memory)
+  } catch {
+    res.status(503).json({ error: 'memory_unavailable' })
+  }
+})
+
+memoryRouter.get('/memory', async (req, res) => {
+  const days = boundedInteger(req.query.days, 30, 1, 3650)
+  const limit = boundedInteger(req.query.limit, 20, 1, 50)
+  try {
+    const data = await callPython(['memory', '--days', String(days), '--limit', String(limit)])
+    // Preserve the legacy top-level array used by released companions.
+    res.json(normalizeMemoryList(data, limit))
+  } catch {
+    res.json([])
+  }
+})

package/server/routes/threads.ts

@@ -0,0 +1,38 @@
+import { Router } from 'express'
+import { callPython } from '../lib/python-bridge.js'
+import { THREAD_ID_PATTERN, normalizeThreadDetail, normalizeThreads } from '../lib/cos-context-browser.js'
+
+export const threadsRouter = Router()
+
+threadsRouter.get('/threads/:id', async (req, res) => {
+  if (!THREAD_ID_PATTERN.test(req.params.id)) {
+    res.status(400).json({ error: 'invalid_thread_id' })
+    return
+  }
+  try {
+    const data = await callPython(['thread-detail', req.params.id])
+    if (data && typeof data === 'object' && 'error' in data) {
+      res.status(404).json({ error: 'thread_not_found' })
+      return
+    }
+    const thread = normalizeThreadDetail(data)
+    if (!thread) {
+      res.status(404).json({ error: 'thread_not_found' })
+      return
+    }
+    res.json(thread)
+  } catch {
+    res.status(503).json({ error: 'threads_unavailable' })
+  }
+})
+
+threadsRouter.get('/threads', async (req, res) => {
+  const parsed = Number(req.query.limit)
+  const limit = Number.isFinite(parsed) ? Math.max(1, Math.min(50, Math.trunc(parsed))) : 30
+  try {
+    const data = await callPython(['threads'])
+    res.json(normalizeThreads(data, limit))
+  } catch {
+    res.json(normalizeThreads({}, limit))
+  }
+})