@gotcos/glasses-server 6.27.2 → 6.27.4

package/server/routes/health.ts

@@ -59,6 +59,8 @@ import { getEarlyMeetingSyncSnapshot } from '../lib/g2-ops-handoff.js'
 import { getProgressiveHqSnapshot } from '../lib/meeting-batch-transcribe.js'
 import { getMeetingFinalizationSnapshot } from '../lib/meeting-finalization-jobs.js'
 import { resolveMeetingLibrary } from '../lib/cos-operations-meetings.js'
+import { videoUploadV2Capability } from '../lib/video-upload-v2.js'
+import { MAX_MODEL_IMAGE_INPUTS } from '../lib/query-attachments.js'
 
 export const healthRouter = Router()
 
@@ -172,6 +174,7 @@ healthRouter.get('/health', async (_req, res) => {
   // capabilities.liveCues so the two surfaces can never disagree.
   const liveCues = liveCuesCapability()
   const richMedia = await getRichMediaProcessingCapabilities()
+  const videoUploadV2 = videoUploadV2Capability(richMedia.video)
   // Upload limits are published so the client never carries its own byte caps:
   // cos-glasses-app and cos-glasses-server are separate repos that have already
   // diverged, so a constant in both is guaranteed to drift. Absent means an
@@ -326,6 +329,11 @@ healthRouter.get('/health', async (_req, res) => {
         maxVideoBytesPerAttachment: MAX_VIDEO_MEDIA_BYTES,
         maxVideoMinutes: 20,
         maxStillFrames: 8,
+        videoUploadV2: {
+          available: videoUploadV2.available,
+          protocol: videoUploadV2.protocol,
+          reason: videoUploadV2.reason,
+        },
       },
       meetingLifecycle: {
         earlySyncClaim: getEarlyMeetingSyncSnapshot(),
@@ -359,6 +367,8 @@ healthRouter.get('/models', async (req, res) => {
   const transcriptionLive = getWhisperPreviewCapability()
   const transcriptionProfile = getTranscriptionProfileStatus()
   const progressiveHq = getProgressiveHqSnapshot()
+  const richMedia = await getRichMediaProcessingCapabilities()
+  const videoUploadV2 = videoUploadV2Capability(richMedia.video)
   const cursorOptions = cursorCatalog.options.filter(option => !!option.id)
   res.json({
     ...catalog,
@@ -391,6 +401,20 @@ healthRouter.get('/models', async (req, res) => {
       // THIS surface, so a value present only on /api/health leaves the
       // live-cues indicator blind.
       liveCues: liveCuesCapability(),
+      richMedia: {
+        video: richMedia.video,
+        maxPromptVisuals: MAX_MODEL_IMAGE_INPUTS,
+        videoUploadV2: {
+          ...videoUploadV2,
+          // The first private train deliberately admits only one video and no
+          // other visual attachment. This keeps a server fallback at its
+          // proven 16-frame policy inside the provider-wide 16-image ceiling.
+          promptAdmission: {
+            maxVideos: 1,
+            maxOtherVisualsWithVideo: 0,
+          },
+        },
+      },
       ...(localFirstMeetings ? { localFirstMeetings } : {}),
     },
   })

package/server/routes/maintenance.ts

@@ -16,6 +16,7 @@ import { serverMetrics } from '../lib/server-metrics.js'
 import { getServerInstanceId } from '../lib/server-instance-id.js'
 import { getWhisperHealth } from '../lib/whisper-local.js'
 import { getActiveTranscriptionSessionCount, getTranscriptionSessionLiveness } from './transcribe-stream.js'
+import { getVideoUploadRegistry } from '../lib/video-upload-v2.js'
 
 export const maintenanceRouter = Router()
 
@@ -78,6 +79,21 @@ function statusSnapshot(credentials: MaintenanceOperationCredentials = {}) {
   // rather than counted, and are never deleted here.
   const sessionLiveness = getTranscriptionSessionLiveness()
   const managed = managedRuntimeCapability()
+  let videoUploads
+  try {
+    videoUploads = getVideoUploadRegistry().status()
+  } catch {
+    videoUploads = {
+      protocol: 1 as const,
+      enabled: false,
+      receiving: 0,
+      finalizing: 0,
+      unacknowledgedPublished: 0,
+      failed: 0,
+      blocksRestart: false,
+      blocksRollback: false,
+    }
+  }
   const tracked = maintenanceLifecycle.snapshot(credentials, {
     recording_session: sessionLiveness.live,
   })
@@ -107,7 +123,10 @@ function statusSnapshot(credentials: MaintenanceOperationCredentials = {}) {
     shuttingDown: jobs.shuttingDown,
     durableStoreState: jobs.store.state,
     lifecycle,
-    safeToRestart: lifecycle.safeToRestart && !jobs.shuttingDown,
+    videoUploads,
+    // Published receipts intentionally survive an ordinary restart. They only
+    // block a binary downgrade, where an old server could erase V2 evidence.
+    safeToRestart: lifecycle.safeToRestart && !jobs.shuttingDown && !videoUploads.blocksRestart,
     whisper: getWhisperHealth(),
   }
 }

package/server/routes/media.ts

@@ -57,6 +57,16 @@ import {
   isValidUploadId,
   type UploadSessionErrorCode,
 } from '../lib/upload-session.js'
+import {
+  VIDEO_UPLOAD_V2_CHUNK_BYTES,
+  VIDEO_UPLOAD_V2_MAX_FRAME_BYTES,
+  VideoUploadError,
+  getVideoUploadRegistry,
+  isValidVideoUploadId,
+  type VideoUploadErrorCode,
+} from '../lib/video-upload-v2.js'
+import { getServerInstanceId } from '../lib/server-instance-id.js'
+import { maintenanceAdmissionsOpen } from '../lib/maintenance-lifecycle.js'
 
 // Route-scoped parser: 16 MB covers the max valid batch after base64 + JSON
 // overhead. Mounted only for /api/media in server/index.ts — the global
@@ -301,6 +311,9 @@ export function createMediaChunkBodyParser(options: MediaChunkParserOptions = {}
 
 /** Chunk parser at the advertised chunk size. */
 export const mediaChunkBodyParser = createMediaChunkBodyParser()
+export const videoUploadChunkBodyParser = createMediaChunkBodyParser({
+  maxChunkBytes: Math.max(VIDEO_UPLOAD_V2_CHUNK_BYTES, VIDEO_UPLOAD_V2_MAX_FRAME_BYTES),
+})
 
 function takeChunkBody(req: Request): Buffer | undefined {
   const bytes = chunkBodies.get(req)
@@ -347,6 +360,19 @@ const UPLOAD_ERROR_STATUS: Record<UploadSessionErrorCode, number> = {
   upload_staging_failed: 500,
 }
 
+const VIDEO_UPLOAD_ERROR_STATUS: Record<VideoUploadErrorCode, number> = {
+  video_upload_disabled: 503,
+  video_upload_not_found: 404,
+  video_upload_conflict: 409,
+  video_upload_busy: 409,
+  video_upload_incomplete: 409,
+  video_upload_invalid: 400,
+  video_upload_quota: 507,
+  video_upload_cancelled: 410,
+  video_upload_failed: 500,
+  server_identity_mismatch: 409,
+}
+
 function sendMediaError(res: Response, err: unknown): void {
   // Chunked-upload failures go through the SAME funnel as every other media
   // error, so there is one place that decides the error body's shape.
@@ -354,6 +380,14 @@ function sendMediaError(res: Response, err: unknown): void {
     res.status(UPLOAD_ERROR_STATUS[err.code] ?? 500).json({ error: err.code, ...err.detail })
     return
   }
+  if (err instanceof VideoUploadError) {
+    res.status(VIDEO_UPLOAD_ERROR_STATUS[err.code] ?? 500).json({
+      error: err.code,
+      detail: err.message,
+      ...err.detail,
+    })
+    return
+  }
   if (err instanceof MediaStoreError) {
     res.status(MEDIA_ERROR_STATUS[err.code] ?? 500).json({ error: err.code })
     return
@@ -374,6 +408,26 @@ function sendMediaError(res: Response, err: unknown): void {
   res.status(500).json({ error: 'media_internal_error' })
 }
 
+function videoUploadServerIdentity(req: Request): string | undefined {
+  return safeString(req.header('x-cos-server-instance'), 160)
+    ?? safeString(req.header('x-cos-server-instance-id'), 160)
+}
+
+function requireVideoUploadAdmission(res: Response): boolean {
+  if (maintenanceAdmissionsOpen()) return true
+  res.status(503).json({ error: 'server_maintenance', retryable: true })
+  return false
+}
+
+function requireCurrentServerIdentity(req: Request): string {
+  const presented = videoUploadServerIdentity(req)
+  const current = getServerInstanceId()
+  if (!presented || presented !== current) {
+    throw new VideoUploadError('server_identity_mismatch', 'request targets a different COS server')
+  }
+  return presented
+}
+
 function safeString(v: unknown, max: number): string | undefined {
   return typeof v === 'string' && v.trim().length > 0 ? v.trim().slice(0, max) : undefined
 }
@@ -489,6 +543,124 @@ function uploadLabelFrom(req: Request): string | undefined {
   try { return decodeURIComponent(rawLabel).slice(0, 120) } catch { return rawLabel.slice(0, 120) }
 }
 
+// ── Resumable video upload V2 (private canary) ───────────────────────────────
+
+mediaRouter.post('/media/video-upload/init', (req: Request, res: Response) => {
+  try {
+    const serverInstanceId = requireCurrentServerIdentity(req)
+    const body = req.body ?? {}
+    const progress = getVideoUploadRegistry().init({
+      clientRequestId: body.clientRequestId,
+      serverInstanceId,
+      totalBytes: body.totalBytes,
+      mime: body.mime,
+      label: uploadLabelFrom(req),
+      capturedAt: safeString(req.header('x-cos-captured-at'), 40),
+      sessionId: safeString(req.header('x-cos-session-id'), 64),
+    })
+    res.json(progress)
+  } catch (err) {
+    sendMediaError(res, err)
+  }
+})
+
+mediaRouter.get('/media/video-upload/:uploadId', (req: Request, res: Response) => {
+  try {
+    const serverInstanceId = requireCurrentServerIdentity(req)
+    if (!isValidVideoUploadId(req.params.uploadId)) {
+      throw new VideoUploadError('video_upload_not_found', 'unknown or expired video upload')
+    }
+    res.json(getVideoUploadRegistry().get(req.params.uploadId, serverInstanceId))
+  } catch (err) {
+    sendMediaError(res, err)
+  }
+})
+
+mediaRouter.put(
+  '/media/video-upload/:uploadId/original/:index',
+  videoUploadChunkBodyParser,
+  async (req: Request, res: Response) => {
+    const bytes = takeChunkBody(req)
+    try {
+      if (!requireVideoUploadAdmission(res)) return
+      const serverInstanceId = requireCurrentServerIdentity(req)
+      if (!isValidVideoUploadId(req.params.uploadId) || bytes === undefined) {
+        throw new VideoUploadError('video_upload_invalid', 'valid upload id and raw chunk bytes are required')
+      }
+      res.json(await getVideoUploadRegistry().putOriginal(
+        req.params.uploadId,
+        req.params.index,
+        bytes,
+        serverInstanceId,
+      ))
+    } catch (err) {
+      sendMediaError(res, err)
+    }
+  },
+)
+
+mediaRouter.put(
+  '/media/video-upload/:uploadId/frame/:index',
+  videoUploadChunkBodyParser,
+  async (req: Request, res: Response) => {
+    const bytes = takeChunkBody(req)
+    try {
+      if (!requireVideoUploadAdmission(res)) return
+      const serverInstanceId = requireCurrentServerIdentity(req)
+      if (!isValidVideoUploadId(req.params.uploadId) || bytes === undefined) {
+        throw new VideoUploadError('video_upload_invalid', 'valid upload id and raw frame bytes are required')
+      }
+      res.json(await getVideoUploadRegistry().putFrame(
+        req.params.uploadId,
+        req.params.index,
+        bytes,
+        serverInstanceId,
+      ))
+    } catch (err) {
+      sendMediaError(res, err)
+    }
+  },
+)
+
+mediaRouter.post('/media/video-upload/:uploadId/finalize', async (req: Request, res: Response) => {
+  try {
+    if (!requireVideoUploadAdmission(res)) return
+    const serverInstanceId = requireCurrentServerIdentity(req)
+    if (!isValidVideoUploadId(req.params.uploadId)) {
+      throw new VideoUploadError('video_upload_not_found', 'unknown or expired video upload')
+    }
+    res.json(await getVideoUploadRegistry().finalize(req.params.uploadId, serverInstanceId))
+  } catch (err) {
+    sendMediaError(res, err)
+  }
+})
+
+mediaRouter.post('/media/video-upload/:uploadId/ack', async (req: Request, res: Response) => {
+  try {
+    const serverInstanceId = requireCurrentServerIdentity(req)
+    if (!isValidVideoUploadId(req.params.uploadId)) {
+      throw new VideoUploadError('video_upload_not_found', 'unknown or expired video upload')
+    }
+    res.json(await getVideoUploadRegistry().acknowledge(req.params.uploadId, serverInstanceId))
+  } catch (err) {
+    sendMediaError(res, err)
+  }
+})
+
+mediaRouter.delete('/media/video-upload/:uploadId', async (req: Request, res: Response) => {
+  try {
+    const serverInstanceId = requireCurrentServerIdentity(req)
+    if (!isValidVideoUploadId(req.params.uploadId)) {
+      res.json({ ok: true, dropped: false })
+      return
+    }
+    const progress = await getVideoUploadRegistry().cancel(req.params.uploadId, serverInstanceId)
+    res.json({ ok: true, dropped: progress !== null, ...(progress ? { upload: progress } : {}) })
+  } catch (err) {
+    sendMediaError(res, err)
+  }
+})
+
 mediaRouter.post('/media/upload/init', (req: Request, res: Response) => {
   try {
     const body = req.body ?? {}

package/server/routes/prompt-drafts.ts

@@ -35,6 +35,8 @@ import {
   applyNegativeRules,
 } from '../lib/hallucination-filter.js'
 import { applyCorrections } from '../lib/whisper-local.js'
+import { applyFuzzyCorrections } from '../lib/fuzzy-correct.js'
+import { getAllSpeakerNames } from '../lib/speaker-embeddings.js'
 import { transcribeWhisperPreview } from '../lib/whisper-preview.js'
 import { autoCleanDictation, AUTOCLEAN_MAX_CHARS } from '../lib/dictation-clean.js'
 import { getVocabulary } from '../lib/profile.js'
@@ -104,6 +106,27 @@ function routeAutoClean(req: { body?: any; query?: any }): AutoCleanRequest {
 
 async function cleanOutboundDictation(text: string, opts: AutoCleanRequest & { signal?: AbortSignal }): Promise<string> {
   let cleaned = applyNegativeRules(applyCorrections(text)).replace(/\s+/g, ' ').trim() || text
+  // applyCorrections above is an EXACT string map, so it only fixes misspellings someone
+  // already hand-authored. A novel miss ("Miyala" for Niala, "Yukoma" for Ukaoma) sails
+  // through it. The Levenshtein pass is what catches those, and until now it had exactly
+  // ONE call site — transcribe-audio.ts:252, the server-transcription route — so phone
+  // Moonshine dictation, which arrives here as text, never got it. Same construction and
+  // same non-fatal posture as that site, deliberately: targets are speaker names plus
+  // vocabulary, and a throw must never cost the user their transcript.
+  //
+  // Runs BEFORE the autoclean LLM so the model sees corrected proper nouns rather than
+  // being asked to guess at them, and it still helps on every path where autoclean is
+  // off, over the char cap, or breaker-open.
+  try {
+    const fuzzyTargets = [...getAllSpeakerNames(), ...getVocabulary()]
+    const { text: corrected, replacements } = applyFuzzyCorrections(cleaned, fuzzyTargets)
+    if (replacements > 0) {
+      console.log(`[prompt-draft] Fuzzy corrected ${replacements} word(s)`)
+      cleaned = corrected
+    }
+  } catch (fuzzyErr: any) {
+    console.warn(`[prompt-draft] Fuzzy correction failed (non-fatal): ${fuzzyErr?.message ?? fuzzyErr}`)
+  }
   if (!(opts.enabled ?? autoCleanDefaultEnabled())) return cleaned
   if (cleaned.length > AUTOCLEAN_MAX_CHARS || autoCleanBreaker.isOpen() || autoCleanCountToday() >= autoCleanDailyCap()) return cleaned
   const startedAt = Date.now()