@gotcos/glasses-server 6.2.1 → 6.5.0

package/server/lib/codex-bridge.ts

@@ -1,15 +1,15 @@
-// Codex bridge — streaming-compatible interface to `codex exec --json`
-// MVP target: local subscription-authenticated GPT-5.5 High via Codex CLI.
+// Codex bridge — streaming-compatible interface to `codex exec --json`.
+// Concrete GPT ids resolve from Codex's live model catalog at run time.
 
-import { spawn } from 'node:child_process'
-import { writeFileSync, unlinkSync } from 'node:fs'
-import { join } from 'node:path'
-import crypto from 'node:crypto'
+import { spawn, spawnSync } from 'node:child_process'
 import { logTokenAudit } from './token-audit.js'
+import { cleanupModelImageInputs, type ModelImageInput } from './model-image-input.js'
 import { buildSystemPrompt, buildLightweightSystemPrompt } from './context-builder.js'
 import {
   getHistory,
   addExchange,
+  setExchangeAttachments,
+  removeExchange,
   formatHistoryForPrompt,
   getOrCreateSession,
   isNewSession,
@@ -27,10 +27,16 @@ import {
 } from './codex-engine-sessions.js'
 import {
   CODEX_HIGH_MODEL,
-  CODEX_HIGH_REASONING_EFFORT,
-  CODEX_MODEL_ID,
   type CodexModelPreference,
+  type EffortPreference,
 } from '../../shared/model-preference.js'
+import {
+  getCodexModelCatalog,
+  resolveCodexEffortForModel,
+  resolveCodexModelOption,
+  resolveCodexServiceTier,
+  type CodexModelOption,
+} from './codex-model-catalog.js'
 import type { CallOptions, StreamCallbacks } from './claude-bridge.js'
 import {
   classifyCodexError,
@@ -43,6 +49,16 @@ import {
   updateCodexRun,
   type CodexRunStatus,
 } from './codex-run-ledger.js'
+import { codexActivityPreviewLines } from './activity-preview.js'
+import {
+  createRunOutputImagePublisher,
+  isRunOutputImagePublisherCommand,
+  type RunOutputImageCollectionStats,
+} from './run-output-images.js'
+import {
+  MAX_ATTACHMENTS_PER_PROMPT,
+  type MediaAttachmentRef,
+} from '../../shared/media-attachment.js'
 
 const INACTIVITY_MS = 180_000
 const WALL_MAX_MS = 900_000
@@ -66,23 +82,61 @@ function codexSandboxArgs(): string[] {
   return ['--sandbox', mode, '--skip-git-repo-check']
 }
 
+let addDirSupported: boolean | undefined
+
+/** Older Codex CLIs do not expose --add-dir. Probe lazily and disable only
+ * output publishing when unavailable; chat remains read-only and functional. */
+export function codexSupportsAdditionalDir(): boolean {
+  if (addDirSupported !== undefined) return addDirSupported
+  try {
+    const result = spawnSync('codex', ['exec', '--help'], {
+      encoding: 'utf8',
+      timeout: 5_000,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+    addDirSupported = result.status === 0 && `${result.stdout}\n${result.stderr}`.includes('--add-dir')
+  } catch {
+    addDirSupported = false
+  }
+  return addDirSupported
+}
+
 export function buildCodexExecArgs(input: {
   codexCwd: string
   imagePaths?: string[]
   persistentCodexSession: boolean
   codexThreadId?: string
+  model?: CodexModelPreference
+  resolvedModel?: CodexModelOption
+  effort?: EffortPreference
+  publisherWritableDirectory?: string
 }): string[] {
   const imagePaths = input.imagePaths ?? []
-  const args = ['exec']
+  const resolvedModel = input.resolvedModel
+    ?? resolveCodexModelOption(input.model ?? CODEX_HIGH_MODEL)
+  const reasoningEffort = resolveCodexEffortForModel(resolvedModel, input.effort)
+  const serviceTier = resolveCodexServiceTier(resolvedModel)
+  // Sandbox + publisher capability are global `codex exec` options and MUST
+  // appear before the `resume` subcommand. The publisher grants write access
+  // only to its random run directory; the rest of the host stays read-only.
+  const args = ['exec', ...codexSandboxArgs()]
+  if (input.publisherWritableDirectory) {
+    args.push('--add-dir', input.publisherWritableDirectory)
+  }
+
+  const appendModelConfig = () => {
+    if (resolvedModel.id) args.push('--model', resolvedModel.id)
+    args.push('-c', `model_reasoning_effort="${reasoningEffort}"`)
+    if (serviceTier) args.push('-c', `service_tier="${serviceTier}"`)
+  }
+
   if (input.codexThreadId) {
     args.push(
       'resume',
       '--json',
       '--all',
-      ...codexSandboxArgs(),
-      '-c', `model_reasoning_effort="${CODEX_HIGH_REASONING_EFFORT}"`,
     )
-    if (CODEX_MODEL_ID) args.push('--model', CODEX_MODEL_ID)
+    appendModelConfig()
     for (const p of imagePaths) args.push('--image', p)
     args.push(input.codexThreadId, '-')
     return args
@@ -91,10 +145,8 @@ export function buildCodexExecArgs(input: {
   args.push(
     '--json',
     '--cd', input.codexCwd,
-    ...codexSandboxArgs(),
-    '-c', `model_reasoning_effort="${CODEX_HIGH_REASONING_EFFORT}"`,
   )
-  if (CODEX_MODEL_ID) args.push('--model', CODEX_MODEL_ID)
+  appendModelConfig()
   if (!input.persistentCodexSession) args.push('--ephemeral')
   for (const p of imagePaths) args.push('--image', p)
   args.push('-')
@@ -111,26 +163,36 @@ function buildCodexPrompt(systemPrompt: string, fullQuery: string): string {
   ].join('\n')
 }
 
-function eventText(event: any): string {
+/** Extract only observable assistant response text. Reasoning/tool payloads
+ * must remain invisible even if a future Codex JSON shape also has delta or
+ * content fields. */
+export function extractCodexResponseText(event: any): string {
   const item = event?.item ?? event?.payload ?? event?.message ?? event
+  const eventType = String(event?.type ?? '').toLowerCase()
+  const itemType = String(item?.type ?? '').toLowerCase()
+  const assistantEvent = /(?:^|[._-])(agent_message|assistant_message|output_text)(?:$|[._-])/.test(eventType)
+    || /^(?:agent_message|assistant_message|output_text)$/.test(itemType)
+  if (!assistantEvent) return ''
 
   if (typeof event?.delta === 'string') return event.delta
-  if (typeof event?.text === 'string' && /message|delta|answer/i.test(String(event.type ?? ''))) return event.text
-  if (typeof item?.text === 'string' && /agent_message|message|assistant/i.test(String(item.type ?? event?.type ?? ''))) return item.text
+  if (typeof event?.text === 'string') return event.text
+  if (typeof item?.text === 'string') return item.text
 
   const content = item?.content ?? event?.content
   if (Array.isArray(content)) {
     let text = ''
     for (const block of content) {
       if (typeof block === 'string') text += block
-      if (typeof block?.text === 'string') text += block.text
-      if (typeof block?.content === 'string') text += block.content
+      const blockType = String(block?.type ?? '').toLowerCase()
+      if (/(?:reasoning|thinking|tool|command|input)/.test(blockType)) continue
       if (typeof block?.output_text === 'string') text += block.output_text
+      else if (typeof block?.text === 'string') text += block.text
+      else if (typeof block?.content === 'string') text += block.content
     }
     return text
   }
 
-  if (typeof item?.result === 'string' && /result|completed|answer/i.test(String(event?.type ?? ''))) return item.result
+  if (typeof item?.result === 'string') return item.result
   return ''
 }
 
@@ -156,7 +218,7 @@ function safeCodexUserError(message: string): string {
   if (code === 'codex.cli_unavailable') return 'Codex CLI unavailable. Check server Settings.'
   if (code === 'codex.auth_error') return 'Codex auth failed. Run codex login on the Mac.'
   if (code === 'codex.timeout') return 'Codex timed out. Retry or start a new chat.'
-  if (code === 'codex.permission_denied') return 'Codex permission failed. Check full-access configuration.'
+  if (code === 'codex.permission_denied') return 'Codex permission failed. Check COS_CODEX_SANDBOX and the work directory.'
   return `Codex failed (${code}). Retry or check Codex Debug.`
 }
 
@@ -165,12 +227,18 @@ export async function callCodexStreaming(
   sessionId: string | undefined,
   callbacks: StreamCallbacks,
   model: CodexModelPreference = CODEX_HIGH_MODEL,
-  images?: string[],
+  images?: ModelImageInput[],
   reference?: PromptReference,
   globalMsgNum?: number,
   options?: CallOptions,
 ): Promise<string> {
   const sid = getOrCreateSession(sessionId)
+  // Refresh is TTL-cached and coalesced, so every run sees the newest known
+  // catalog without creating duplicate app-server discovery processes.
+  await getCodexModelCatalog()
+  if (options?.abortSignal?.aborted) {
+    throw new Error('codex-bridge: client disconnected before Codex started.')
+  }
   const history = getHistory(sid)
   const session = getSessionRaw(sid)
   const contextBreaks = session?.contextBreaks ?? []
@@ -179,9 +247,14 @@ export async function callCodexStreaming(
   const persistentCodexSession = isCodexPersistenceEnabled()
   const codexCwd = getCodexExecutionCwd()
   const codexTrustMode = getCodexTrustMode()
+  const resolvedCodexModel = resolveCodexModelOption(model)
+  const resolvedCodexEffort = resolveCodexEffortForModel(resolvedCodexModel, options?.effort)
   const engineSession = persistentCodexSession
     ? getCodexEngineSession({ cosSessionId: sid, model, cwd: codexCwd, trustMode: codexTrustMode })
     : null
+  const imageInputs: ModelImageInput[] = images ?? []
+  const imagePaths = imageInputs.map(input => input.path)
+  const outputImageBudget = Math.max(0, MAX_ATTACHMENTS_PER_PROMPT - imageInputs.length)
   const startTime = Date.now()
   const run = startCodexRun({
     cosSessionId: sid,
@@ -192,8 +265,23 @@ export async function callCodexStreaming(
     trustMode: codexTrustMode,
     codexThreadId: engineSession?.codexThreadId,
     expiresAt: engineSession?.expiresAt,
+    cliModel: resolvedCodexModel.id || 'codex-cli-default',
+    reasoningEffort: resolvedCodexEffort,
     query,
   })
+  let outputImagePublisher: ReturnType<typeof createRunOutputImagePublisher> | null = null
+  if (!options?.lightweight && outputImageBudget > 0 && codexSupportsAdditionalDir()) {
+    try {
+      outputImagePublisher = createRunOutputImagePublisher({
+        sessionId: sid,
+        globalMsgNum,
+        runId: run.runId,
+        maxImages: outputImageBudget,
+      })
+    } catch (err) {
+      console.error('[codex-bridge] output image publisher unavailable:', err)
+    }
+  }
   let codexThreadId: string | undefined = engineSession?.codexThreadId
   callbacks.onStart?.(model, sid, undefined, { codexRunId: run.runId, codexThreadId })
 
@@ -207,6 +295,7 @@ export async function callCodexStreaming(
       systemPrompt = await buildSystemPrompt(contextPrompt)
     }
   } catch (err: any) {
+    outputImagePublisher?.cleanup()
     finishCodexRun(run.runId, {
       status: 'failed',
       startedAtMs: startTime,
@@ -215,37 +304,15 @@ export async function callCodexStreaming(
     })
     throw err
   }
+  if (outputImagePublisher) systemPrompt = `${systemPrompt}\n\n${outputImagePublisher.promptInstructions}`
 
   phase = 'thinking'
   callbacks.onToolStatus?.('Reasoning...')
 
-  const imagePaths: string[] = []
-  try {
-    if (images && images.length > 0) {
-      for (const img of images) {
-        const id = crypto.randomUUID().slice(0, 8)
-        const p = join('/tmp', `cos-vision-${id}.jpg`)
-        writeFileSync(p, Buffer.from(img, 'base64'))
-        imagePaths.push(p)
-      }
-    }
-  } catch (err: any) {
-    for (const p of imagePaths) {
-      try { unlinkSync(p) } catch { /* ignore */ }
-    }
-    finishCodexRun(run.runId, {
-      status: 'failed',
-      startedAtMs: startTime,
-      error: `codex-bridge: image staging failed — ${err?.message ?? 'unknown error'}`,
-      exitCode: null,
-    })
-    throw err
-  }
-
   const isFirstQuery = isNewSession(sid)
   const photoPrefix = imagePaths.length === 1 ? '[Photo]' : imagePaths.length > 1 ? `[${imagePaths.length} Photos]` : ''
   const historyQuery = photoPrefix ? `${photoPrefix} ${query || 'What do you see?'}` : query
-  addExchange(sid, 'user', historyQuery, globalMsgNum)
+  const pendingUserExchange = addExchange(sid, 'user', historyQuery, globalMsgNum)
 
   let fullQuery: string
   if (imagePaths.length === 1) {
@@ -262,10 +329,15 @@ export async function callCodexStreaming(
     imagePaths,
     persistentCodexSession,
     codexThreadId: engineSession?.codexThreadId,
+    model,
+    resolvedModel: resolvedCodexModel,
+    effort: options?.effort,
+    publisherWritableDirectory: outputImagePublisher?.writableDirectory,
   })
 
   const env = { ...process.env }
   delete env.CLAUDECODE
+  if (outputImagePublisher) Object.assign(env, outputImagePublisher.env)
 
   const proc = spawn('codex', args, {
     stdio: ['pipe', 'pipe', 'pipe'],
@@ -281,9 +353,7 @@ export async function callCodexStreaming(
   const emittedBlocks = new Set<string>()
 
   function cleanupImages() {
-    for (const p of imagePaths) {
-      try { unlinkSync(p) } catch { /* ignore */ }
-    }
+    cleanupModelImageInputs(imageInputs)
   }
 
   function cleanup() {
@@ -301,12 +371,42 @@ export async function callCodexStreaming(
     callbacks.onChunk(text)
   }
 
-  function finalize(text: string) {
+  async function finalize(text: string) {
     if (finalized) return
     finalized = true
     cleanup()
     cleanupImages()
 
+    const assistantExchange = addExchange(sid, 'assistant', text, globalMsgNum)
+    if (imagePaths.length > 0) {
+      replaceLastExchangeWithSummary(sid, query, text, imagePaths.length)
+    }
+
+    let outputAttachments: MediaAttachmentRef[] = []
+    let outputImageStats: RunOutputImageCollectionStats | undefined
+    if (outputImagePublisher) {
+      callbacks.onToolStatus?.('Preparing images...')
+      const preparingHeartbeat = setInterval(() => callbacks.onToolStatus?.('Preparing images...'), HEARTBEAT_INTERVAL_MS)
+      preparingHeartbeat.unref?.()
+      try {
+        outputAttachments = await outputImagePublisher.collect()
+      } catch (err) {
+        console.error('[codex-bridge] output image collection failed:', err)
+      } finally {
+        clearInterval(preparingHeartbeat)
+        outputImageStats = outputImagePublisher.stats
+        outputImagePublisher.cleanup()
+      }
+      if (outputAttachments.length > 0) {
+        setExchangeAttachments(sid, assistantExchange, outputAttachments)
+      }
+      if (outputImageStats && outputImageStats.rejected > 0) {
+        callbacks.onToolStatus?.(outputImageStats.attached > 0
+          ? 'Some images could not be attached'
+          : 'Image attachment unavailable')
+      }
+    }
+
     const totalMs = Date.now() - startTime
     logTokenAudit({
       source: options?.lightweight ? 'g2-voice' : 'g2-query',
@@ -333,12 +433,12 @@ export async function callCodexStreaming(
       output: text,
       exitCode: 0,
     })
-    addExchange(sid, 'assistant', text, globalMsgNum)
-    if (imagePaths.length > 0) {
-      replaceLastExchangeWithSummary(sid, query, text, imagePaths.length)
-    }
-
-    callbacks.onDone(text, model, undefined, { codexRunId: run.runId, codexThreadId })
+    callbacks.onDone(text, model, undefined, {
+      codexRunId: run.runId,
+      codexThreadId,
+      ...(outputAttachments.length > 0 ? { outputAttachments } : {}),
+      ...(outputImageStats && outputImageStats.published > 0 ? { outputImageStats } : {}),
+    })
 
     if (isFirstQuery) {
       notifySessionStart(sid, query)
@@ -352,6 +452,8 @@ export async function callCodexStreaming(
     finalized = true
     cleanup()
     cleanupImages()
+    outputImagePublisher?.cleanup()
+    removeExchange(sid, pendingUserExchange)
     if (engineSession) {
       clearCodexEngineSession(sid, model)
     }
@@ -394,20 +496,12 @@ export async function callCodexStreaming(
   const wallTimer = setTimeout(() => {
     proc.kill('SIGTERM')
     if (fullText) {
-      finalize(fullText)
+      void finalize(fullText)
     } else {
       finalizeError(`Wall clock limit reached (${WALL_MAX_MS / 1000}s). Codex process killed.`)
     }
   }, WALL_MAX_MS)
 
-  if (options?.abortSignal) {
-    if (options.abortSignal.aborted) {
-      handleAbort()
-    } else {
-      options.abortSignal.addEventListener('abort', handleAbort, { once: true })
-    }
-  }
-
   function handleEvent(event: any) {
     const nextThreadId = extractCodexThreadId(event)
     if (nextThreadId && nextThreadId !== codexThreadId) {
@@ -418,12 +512,17 @@ export async function callCodexStreaming(
     const status = toolStatus(event)
     if (status) callbacks.onToolStatus?.(status)
 
-    const text = eventText(event)
+    const command = event?.item?.command ?? event?.item?.input ?? event?.payload?.command ?? event?.payload?.input
+    if (!isRunOutputImagePublisherCommand(command)) {
+      for (const preview of codexActivityPreviewLines(event)) callbacks.onActivityLine?.(preview)
+    }
+
+    const text = extractCodexResponseText(event)
     if (text) emitText(text)
 
     const type = String(event?.type ?? '')
     if (type === 'turn.completed') {
-      finalize(fullText)
+      void finalize(fullText)
     } else if (type === 'turn.failed' || type === 'error') {
       finalizeError(`codex-bridge: ${event?.error ?? event?.message ?? 'unknown error'}`)
     }
@@ -459,7 +558,7 @@ export async function callCodexStreaming(
     if (code !== 0) {
       finalizeError(`codex-bridge: exit ${code} — ${stderr.trim().slice(0, 240)}`, code)
     } else if (fullText) {
-      finalize(fullText)
+      void finalize(fullText)
     } else {
       finalizeError('codex-bridge: Codex completed without a response.')
     }
@@ -468,9 +567,25 @@ export async function callCodexStreaming(
   proc.on('error', (err) => {
     finalizeError(`codex-bridge: ${err.message}`)
   })
+  proc.stdin.on('error', (err) => {
+    finalizeError(`codex-bridge: stdin failed — ${err.message}`)
+  })
 
-  proc.stdin.write(prompt)
-  proc.stdin.end()
+  if (options?.abortSignal) {
+    if (options.abortSignal.aborted) {
+      handleAbort()
+      return sid
+    }
+    options.abortSignal.addEventListener('abort', handleAbort, { once: true })
+  }
+
+  try {
+    proc.stdin.write(prompt)
+    proc.stdin.end()
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    finalizeError(`codex-bridge: stdin failed — ${message}`)
+  }
 
   return sid
 }

package/server/lib/codex-engine-sessions.ts

@@ -1,6 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
 import { dirname, resolve } from 'node:path'
-import type { CodexModelPreference } from '../../shared/model-preference.js'
+import {
+  isCodexModel,
+  normalizeModelPreference,
+  type CodexModelPreference,
+} from '../../shared/model-preference.js'
 
 export const CODEX_ENGINE_SESSION_TTL_MS = 2 * 60 * 60_000
 
@@ -40,8 +44,26 @@ function readStore(): CodexEngineSessionFile {
   if (!existsSync(path)) return { sessions: {}, savedAt: new Date().toISOString() }
   try {
     const parsed = JSON.parse(readFileSync(path, 'utf-8')) as Partial<CodexEngineSessionFile>
+    const sessions: Record<string, CodexEngineSession> = {}
+    for (const raw of Object.values(parsed.sessions && typeof parsed.sessions === 'object' ? parsed.sessions : {})) {
+      const model = normalizeModelPreference(raw?.model)
+      if (
+        !model ||
+        !isCodexModel(model) ||
+        typeof raw?.cosSessionId !== 'string' ||
+        typeof raw?.codexThreadId !== 'string' ||
+        typeof raw?.cwd !== 'string' ||
+        (raw?.trustMode !== 'read-only' && raw?.trustMode !== 'workspace-write') ||
+        typeof raw?.lastUsedAt !== 'number' ||
+        typeof raw?.expiresAt !== 'string'
+      ) continue
+      const key = sessionKey(raw.cosSessionId, model)
+      const normalized = { ...raw, key, model } as CodexEngineSession
+      const prior = sessions[key]
+      if (!prior || normalized.lastUsedAt > prior.lastUsedAt) sessions[key] = normalized
+    }
     return {
-      sessions: parsed.sessions && typeof parsed.sessions === 'object' ? parsed.sessions : {},
+      sessions,
       savedAt: typeof parsed.savedAt === 'string' ? parsed.savedAt : new Date().toISOString(),
     }
   } catch {