@gotcos/glasses-server 6.2.1 → 6.5.0

package/server/lib/model-image-input.ts

@@ -0,0 +1,27 @@
+// Internal model-input shape for image attachments (Release A).
+// The bridges receive resolved server-owned FILE PATHS — never base64 —
+// plus the public ref and an explicit deletion contract:
+//   deleteAfterRun: false  → durable media-store asset; the store's lifecycle
+//                            (GC/retention) owns the file. Bridges must not
+//                            delete it, even on failed/cancelled runs.
+//   deleteAfterRun: true   → truly ephemeral request-temp file; the bridge
+//                            deletes it exactly once when the run settles.
+
+import { unlinkSync } from 'node:fs'
+import type { MediaAttachmentRef } from '../../shared/media-attachment.js'
+
+export interface ModelImageInput {
+  /** Absolute path to a server-owned normalized image file. */
+  path: string
+  attachment: MediaAttachmentRef
+  deleteAfterRun: boolean
+}
+
+/** Terminal cleanup used by both bridges: delete ONLY inputs explicitly
+ *  marked ephemeral. Idempotent — safe if a bridge settles twice. */
+export function cleanupModelImageInputs(inputs: ModelImageInput[]): void {
+  for (const input of inputs) {
+    if (!input.deleteAfterRun) continue
+    try { unlinkSync(input.path) } catch { /* already gone — fine */ }
+  }
+}

package/server/lib/model-router.ts

@@ -8,21 +8,51 @@ import {
   type PromptReference,
 } from './conversation.js'
 import { DEFAULT_MODEL, isCodexModel, isClaudeModel, normalizeModelPreference } from '../../shared/model-preference.js'
+import type { ModelImageInput } from './model-image-input.js'
 
-// Chat routes to the user's local Claude Code CLI (opus/sonnet/haiku) or the
-// Codex CLI (codex-high). Any unknown preference falls back to the Claude default
+// Bridges return as soon as their subprocess is spawned, while completion is
+// delivered later through callbacks. This keyed tail queue therefore releases
+// only on a terminal callback (or an early throw), preventing two turns from
+// mutating the same conversation/CLI session concurrently.
+const sessionRunTails = new Map<string, Promise<void>>()
+
+async function acquireSessionRunLock(sessionId: string): Promise<() => void> {
+  const previous = sessionRunTails.get(sessionId) ?? Promise.resolve()
+  let openGate!: () => void
+  const gate = new Promise<void>(resolve => { openGate = resolve })
+  const tail = previous.catch(() => {}).then(() => gate)
+  sessionRunTails.set(sessionId, tail)
+  await previous.catch(() => {})
+
+  let released = false
+  return () => {
+    if (released) return
+    released = true
+    openGate()
+    if (sessionRunTails.get(sessionId) === tail) sessionRunTails.delete(sessionId)
+  }
+}
+
+// Chat routes to the user's local Claude Code CLI or stable Codex live-catalog
+// slots. Any unknown preference falls back to the Claude default
 // so chat always works on a stock install.
 export async function callModelStreaming(
   query: string,
   sessionId: string | undefined,
   callbacks: StreamCallbacks,
   model?: ModelPreference,
-  images?: string[],
+  images?: ModelImageInput[],
   reference?: PromptReference,
   globalMsgNum?: number,
   options?: CallOptions,
 ): Promise<string> {
   const sid = getOrCreateSession(sessionId)
+  const release = await acquireSessionRunLock(sid)
+  if (options?.abortSignal?.aborted) {
+    release()
+    throw new Error('model-router: request aborted before the model run started.')
+  }
+
   const sessionModel = getSessionModel(sid)
   // COS_G2_DEFAULT_MODEL is the documented default-model switch (CHANGELOG 6.1.0);
   // it must win over the hardcoded DEFAULT_MODEL on this primary query path, not
@@ -32,11 +62,40 @@ export async function callModelStreaming(
 
   setSessionModel(sid, resolvedModel)
 
-  if (isCodexModel(resolvedModel)) {
-    return callCodexStreaming(query, sid, callbacks, resolvedModel, images, reference, globalMsgNum, options)
+  let terminal = false
+  const releaseTerminal = () => {
+    if (terminal) return
+    terminal = true
+    release()
   }
-  if (isClaudeModel(resolvedModel)) {
-    return callClaudeStreaming(query, sid, callbacks, resolvedModel, images, reference, globalMsgNum, options)
+  const lockedCallbacks: StreamCallbacks = {
+    ...callbacks,
+    onDone: (fullText, completedModel, cliSessionId, metadata) => {
+      try {
+        callbacks.onDone(fullText, completedModel, cliSessionId, metadata)
+      } finally {
+        releaseTerminal()
+      }
+    },
+    onError: (error) => {
+      try {
+        callbacks.onError(error)
+      } finally {
+        releaseTerminal()
+      }
+    },
+  }
+
+  try {
+    if (isCodexModel(resolvedModel)) {
+      return await callCodexStreaming(query, sid, lockedCallbacks, resolvedModel, images, reference, globalMsgNum, options)
+    }
+    if (isClaudeModel(resolvedModel)) {
+      return await callClaudeStreaming(query, sid, lockedCallbacks, resolvedModel, images, reference, globalMsgNum, options)
+    }
+    return await callClaudeStreaming(query, sid, lockedCallbacks, DEFAULT_MODEL, images, reference, globalMsgNum, options)
+  } catch (err) {
+    releaseTerminal()
+    throw err
   }
-  return callClaudeStreaming(query, sid, callbacks, DEFAULT_MODEL, images, reference, globalMsgNum, options)
 }

package/server/lib/query-attachments.ts

@@ -0,0 +1,132 @@
+// Query-side attachment resolution (Release A). Converts an /api/query
+// request body's image inputs into ModelImageInput[]:
+//
+//   attachmentIds[]   — durable media-store assets uploaded via /api/media.
+//                       Validated against lifecycle + the reservation's
+//                       clientQueueItemId (an id alone is never bearer auth).
+//   images[]/image    — legacy base64. NOT a bypass: bytes are ingested
+//                       through the same media store (validation,
+//                       normalization, lifecycle tracking, limits) and then
+//                       resolved exactly like uploaded attachments.
+//
+// Every resolved input is durable (deleteAfterRun: false) — the store's
+// retention owns the files; model runs never delete them.
+
+import {
+  MAX_ATTACHMENTS_PER_PROMPT,
+  isValidMediaId,
+  parseMediaIdList,
+  type MediaAttachmentRef,
+} from '../../shared/media-attachment.js'
+import { getMediaStore, MediaStoreError } from './media-store.js'
+import { strictBase64Decode, ImageSafetyError } from './image-safety.js'
+import type { ModelImageInput } from './model-image-input.js'
+
+export interface ResolvedQueryAttachments {
+  inputs: ModelImageInput[]
+  refs: MediaAttachmentRef[]
+  /** Ids to associate with the final message when the run completes. */
+  ids: string[]
+}
+
+export class QueryAttachmentError extends Error {
+  readonly status: number
+  readonly code: string
+  constructor(status: number, code: string, message: string) {
+    super(message)
+    this.status = status
+    this.code = code
+    this.name = 'QueryAttachmentError'
+  }
+}
+
+const MEDIA_ERROR_STATUS: Record<string, number> = {
+  media_not_found: 404,
+  media_expired: 410,
+  media_unavailable: 503,
+  media_conflict: 409,
+}
+
+const SAFETY_ERROR_STATUS: Record<string, number> = {
+  invalid_base64: 400,
+  unsupported_format: 400,
+  image_too_large: 400,
+  dimensions_too_large: 400,
+  corrupt_image: 400,
+  media_processing_unavailable: 503,
+  normalization_failed: 500,
+}
+
+function asQueryAttachmentError(err: unknown): QueryAttachmentError {
+  if (err instanceof MediaStoreError) {
+    return new QueryAttachmentError(MEDIA_ERROR_STATUS[err.code] ?? 500, err.code, err.message)
+  }
+  if (err instanceof ImageSafetyError) {
+    return new QueryAttachmentError(SAFETY_ERROR_STATUS[err.code] ?? 500, err.code, err.message)
+  }
+  return new QueryAttachmentError(500, 'attachment_resolution_failed', err instanceof Error ? err.message : String(err))
+}
+
+export interface QueryImageBody {
+  attachmentIds?: unknown
+  clientQueueItemId?: unknown
+  images?: unknown
+  image?: unknown
+  sessionId?: unknown
+}
+
+/** Resolve all image inputs for one query. Throws QueryAttachmentError with
+ *  an HTTP status + typed code — callers respond BEFORE opening the SSE
+ *  stream. Returns empty inputs when the request carries no images. */
+export async function resolveQueryAttachments(body: QueryImageBody): Promise<ResolvedQueryAttachments> {
+  try {
+    const store = getMediaStore()
+    const clientQueueItemId = typeof body.clientQueueItemId === 'string' && body.clientQueueItemId.trim()
+      ? body.clientQueueItemId.trim().slice(0, 120)
+      : undefined
+    const sessionId = typeof body.sessionId === 'string' && body.sessionId.trim()
+      ? body.sessionId.trim().slice(0, 64)
+      : undefined
+
+    const inputs: ModelImageInput[] = []
+
+    // Reject over-limit requests BEFORE the shared parser caps them. Silent
+    // truncation would run a successful vision query while dropping a user's
+    // sixth image, which is materially worse than a typed 400.
+    const validUniqueIds = Array.isArray(body.attachmentIds)
+      ? [...new Set(body.attachmentIds.filter(isValidMediaId))]
+      : []
+    const legacyRaw: unknown[] = Array.isArray(body.images)
+      ? body.images
+      : typeof body.image === 'string' && body.image.length > 0 ? [body.image] : []
+    const validLegacyCount = legacyRaw.filter((raw) => typeof raw === 'string' && raw.length > 0).length
+    if (validUniqueIds.length + validLegacyCount > MAX_ATTACHMENTS_PER_PROMPT) {
+      throw new QueryAttachmentError(400, 'too_many_images', `max ${MAX_ATTACHMENTS_PER_PROMPT} images per prompt`)
+    }
+
+    // 1. Durable attachment ids.
+    const ids = parseMediaIdList(body.attachmentIds)
+    for (const id of ids) {
+      const { record, path } = store.resolveUsable(id, clientQueueItemId)
+      inputs.push({ path, attachment: record.ref, deleteAfterRun: false })
+    }
+
+    // 2. Legacy base64 — ingested through the SAME store (no bypass).
+    for (const raw of legacyRaw) {
+      if (typeof raw !== 'string' || raw.length === 0) continue
+      const bytes = strictBase64Decode(raw)
+      const ref = await store.ingestImage({ bytes, kind: 'user_photo', sessionId })
+      const { path } = store.resolveUsable(ref.id)
+      inputs.push({ path, attachment: ref, deleteAfterRun: false })
+    }
+
+    return {
+      inputs,
+      refs: inputs.map((i) => i.attachment),
+      ids: inputs.map((i) => i.attachment.id),
+    }
+  } catch (err) {
+    if (err instanceof QueryAttachmentError) throw err
+    throw asQueryAttachmentError(err)
+  }
+}