@gotcos/glasses-server 6.99.33 → 7.0.18

package/server/lib/agent-session-turns.ts

@@ -33,7 +33,9 @@ import {
   payloadText,
   type AgentProvider,
 } from './agent-session-store.js'
-import type { SessionOutputImage } from './agent-session-output-images.js'
+import type { SessionOutputFile, SessionOutputImage } from './agent-session-output-images.js'
+import type { SessionToolImage } from './agent-session-tool-images.js'
+import type { SessionOutputLink } from './session-links.js'
 import { unwrapPeerMessage } from './session-stream-events.js'
 import { withoutTurnFooter } from './turn-footer.js'
 
@@ -44,9 +46,23 @@ export interface SessionTurn {
   at?: string
   /** Opt-in native-session output previews. No local paths or COS message identities. */
   outputImages?: SessionOutputImage[]
+  /** Files a Claude session sent with SendUserFile that are not normalized images (6.99.35). Names only, no paths. */
+  outputFiles?: SessionOutputFile[]
+  /** Preview engine phase 1: local Markdown links in this reply, as cards. The text carries `[words](cos-file:N)`; base names only, no paths. */
+  outputLinks?: SessionOutputLink[]
+  /** Images the session looked at in the step around this turn (tool results), or a prompt's attached images. Opaque ids, no bytes, no paths. */
+  toolImages?: SessionToolImage[]
+  /** Images in that step past TOOL_IMAGES_PER_TURN: counted, never given an id. */
+  toolImagesMore?: number
+  /** 6.99.35: this message had images or files and "Show files and images your sessions make" is off. No names travel. */
+  previewsOff?: true
 }
 
-export type SessionTurnProjection = (provider: AgentProvider, record: Record<string, unknown>, turn: SessionTurn | null) => SessionTurn | null
+export type SessionTurnProjection = {
+  (provider: AgentProvider, record: Record<string, unknown>, turn: SessionTurn | null): SessionTurn | null
+  /** A growing read reparses its window from scratch; discard state from the previous pass. */
+  reset?: () => void
+}
 
 /** What a client may ask for in one read. Forty messages is ~10 lens pages of words. */
 export const SESSION_TURNS_MAX = 40
@@ -137,6 +153,7 @@ export function sessionTurnFromRecord(provider: AgentProvider, obj: Record<strin
 
 /** The newest `limit` messages among these lines (file order in, file order out). */
 export function recentSessionTurns(provider: AgentProvider, lines: readonly string[], limit: number, project?: SessionTurnProjection): SessionTurn[] {
+  project?.reset?.()
   const out: SessionTurn[] = []
   for (const line of lines) {
     const obj = parseJsonLine(line)

package/server/lib/api-auth.ts

@@ -1,7 +1,7 @@
 import type { RequestHandler } from 'express'
 import { timingSafeTokenEqual } from './token-auth.js'
 import { PAIRING_NONCE_BODY } from './glasses-pairing.js'
-import { isWebSessionAuthorized } from './web-session-auth.js'
+import { formatSetWebSessionCookie, isWebSessionAuthorized, renewWebSessionCookieValue, verifyWebSessionCookieValue, webSessionCookieFrom } from './web-session-auth.js'
 
 // Recovery/setup clients need these availability surfaces before they have a
 // usable token. Keep private provider state and every mutation route out.
@@ -44,6 +44,31 @@ const DISPLAY_STREAM_CAPABILITY_PATH = /^\/display-stream\/\d{1,15}\.[0-9a-f]{64
 // Minting, status and decisions stay behind the token AND a loopback socket.
 const PAIRING_POLL_PATH = new RegExp(`^/pairing/claim/${PAIRING_NONCE_BODY}$`)
 
+/** Set on a response whose request renewed its browser sign-in: `<new expiry ISO> <30-day cap ISO>`. The page reads it. */
+export const WEB_SESSION_RENEWED_HEADER = 'X-COS-Web-Session'
+
+/** `res.locals` key the gate sets to `'token'` when the X-COS-Token header matched. */
+export const API_AUTH_BY_LOCAL = 'cosApiAuthBy'
+
+/**
+ * Final review S1 (lead 2026-11-10 02:09): `res.locals` key the gate sets ONLY for a request it let in by the browser's
+ * sign-in cookie: a check that the same cookie still verifies now (its expiry, the epoch "Sign out every browser" bumps,
+ * the 30-day cap). A stream that outlives its opening request calls it on every heartbeat (`streamSignInHolds`).
+ */
+export const WEB_SESSION_RECHECK_LOCAL = 'cosWebSessionRecheck'
+
+/**
+ * For a long-lived stream, on each heartbeat: false once the browser sign-in that opened it no longer verifies, so the
+ * stream tears down. A request the API token let in has no re-check and always holds, as does one that never passed
+ * the gate (a route mounted without it in a test). The browser reconnects with whatever cookie it holds now; a renewed
+ * one verifies there.
+ */
+export function streamSignInHolds(res: { locals?: Record<string, unknown> }): boolean {
+  const recheck = res.locals?.[WEB_SESSION_RECHECK_LOCAL]
+  if (typeof recheck !== 'function') return true
+  try { return recheck() === true } catch { return false }
+}
+
 export function isPublicApiRequest(method: string, path: string): boolean {
   if (PUBLIC_API_PATHS.has(path)) return true
   if (method === 'POST' && path === '/pairing/claim') return true
@@ -76,6 +101,9 @@ export function requireApiToken(apiToken: string, options: RequireApiTokenOption
   return (req, res, next) => {
     if (isPublicApiRequest(req.method, req.path)) return next()
     if (timingSafeTokenEqual(req.headers['x-cos-token'], apiToken)) {
+      // 7.0.4 W1: which door let this request in, for routes that answer the Mac's own helper differently from a
+      // browser (lib/native-mac-caller.ts). Set only here, after the header matched; a cookie session never sets it.
+      res.locals[API_AUTH_BY_LOCAL] = 'token'
       if (options.onAuthenticated) {
         try { options.onAuthenticated(req) } catch { /* observer only */ }
       }
@@ -86,6 +114,20 @@ export function requireApiToken(apiToken: string, options: RequireApiTokenOption
       allowedPorts: options.allowedPorts?.(),
     })
     if (cookieAuth) {
+      // Final review S1: the cookie this request came in with, checked again by any stream it opens (above).
+      const opened = webSessionCookieFrom(req.headers.cookie)
+      res.locals[WEB_SESSION_RECHECK_LOCAL] = (): boolean => verifyWebSessionCookieValue(opened, apiToken, Date.now())
+      // 7.0.x (Miles 2026-11-09, "Renew while in use, 30-day cap"): only here, after the socket, cookie, CSRF and Origin
+      // checks above all passed, a cookie in its last 2 days gets a fresh one, never past 30 days from its first sign-in.
+      // Appended, so a route's own Set-Cookie (none today on gated routes) is never overwritten. A renewal that cannot
+      // be made (outside the window, at the cap) changes nothing.
+      try {
+        const renewed = renewWebSessionCookieValue(webSessionCookieFrom(req.headers.cookie), apiToken)
+        if (renewed) {
+          res.append('Set-Cookie', formatSetWebSessionCookie(renewed.value, Math.floor((renewed.expiresAtMs - Date.now()) / 1000), req.secure))
+          res.setHeader(WEB_SESSION_RENEWED_HEADER, new Date(renewed.expiresAtMs).toISOString() + ' ' + new Date(renewed.capAtMs).toISOString())
+        }
+      } catch { /* a failed renewal leaves the request and the old cookie as they were */ }
       return next()
     }
     return res.status(401).json({

package/server/lib/ask-work-plan.ts

@@ -82,7 +82,9 @@ export function prepareAskWorkPlan(request: AskWorkPlanRequest, task: TaskBoardR
   const evidenceStatus = { snapshotAgeSec: evidence.snapshotAgeSec, liveListAgeSec: evidence.liveListAgeSec,
     logScanComplete: evidence.logScanComplete, fresh, usageMode: 'cached',
     scope: 'Canonical task and server session evidence only; no local attachments, local link context, or chat history. Meeting references do not include transcripts.',
-    disabledTargets: evidence.rows.filter((_, index) => !sessions[index]!.automatic || !sessions[index]!.forkable).map(row => ({ id: row.id,
+    // A row is wholly disabled only when neither Continue nor Fork is eligible. The
+    // individual automatic/forkable fields still constrain each assignment mode.
+    disabledTargets: evidence.rows.filter((_, index) => !sessions[index]!.automatic && !sessions[index]!.forkable).map(row => ({ id: row.id,
       reasons: [!fresh && 'stale_or_missing_evidence', !evidence.logScanComplete && 'incomplete_session_scan',
         !row.member && 'not_card_member', !['claude', 'codex'].includes(row.id.split(':')[0]!) && 'unsupported_provider',
         !providerAllowed(row.id.split(':')[0]!) && 'provider_usage_unavailable', row.busy && 'busy', !row.live && 'not_live',

package/server/lib/calendar-meetings.ts

@@ -0,0 +1,70 @@
+/**
+ * Today round 2 (2026-11-09): which calendar rows are distinct, real meetings. ONE helper for the calendar API
+ * (calendar-source.ts calendarToday: next, remainingCount, endedRecently) and the Today summary (today-brief.ts
+ * withCalendar), so the two never disagree.
+ *
+ * - Canceled: a title that starts "Canceled:" or "Cancelled:" (how Exchange and Google rename a canceled occurrence),
+ *   or a row whose `status` says canceled, or `canceled: true` (the snapshot's EventKit status, when it carries one;
+ *   the 11/09 snapshot had no status field on any of its 154 events).
+ * - Distinct: the same title (trimmed, case-folded, spaces collapsed) at the same start is one meeting, whichever
+ *   calendar it is on. The 11/09 live snapshot had 13 such pairs or triples, 12 of them on ONE Exchange calendar with
+ *   different external ids (the same invite delivered twice), so "across calendars" alone would have left 12 of them.
+ *   The first row of each wins, so callers keep their own order.
+ * No dependencies: the summary imports it without the calendar reader.
+ */
+export const CANCELED_TITLE = /^\s*(?:canceled|cancelled)\s*:/i
+const CANCELED_STATUS = new Set(['canceled', 'cancelled'])
+
+export interface MeetingFields { title: unknown; start: unknown; status?: unknown; canceled?: unknown }
+
+export function isCanceledMeeting(row: MeetingFields): boolean {
+  if (row.canceled === true) return true
+  if (typeof row.status === 'string' && CANCELED_STATUS.has(row.status.trim().toLowerCase())) return true
+  return typeof row.title === 'string' && CANCELED_TITLE.test(row.title)
+}
+
+/** The identity of one meeting: its title and its start instant. */
+export function meetingKey(row: MeetingFields): string {
+  const title = typeof row.title === 'string' ? row.title.trim().toLowerCase().replace(/\s+/g, ' ') : ''
+  const start = typeof row.start === 'number' ? row.start : Date.parse(String(row.start ?? ''))
+  return `${title}|${Number.isFinite(start) ? start : String(row.start ?? '')}`
+}
+
+/** The rows that are real meetings, one per meeting, in the order given. */
+export function distinctMeetings<T>(rows: readonly T[], fields: (row: T) => MeetingFields): T[] {
+  const seen = new Set<string>()
+  const out: T[] = []
+  for (const row of rows) {
+    const f = fields(row)
+    if (isCanceledMeeting(f)) continue
+    const key = meetingKey(f)
+    if (seen.has(key)) continue
+    seen.add(key)
+    out.push(row)
+  }
+  return out
+}
+
+/**
+ * Prep on every Next up row (Miles typed 2026-11-09 13:00 CST): a calendar hold or status block is not a meeting to
+ * prep for. ONE list for the server: /api/calendar/today marks each row `hold`, /api/welcome-context marks nextEvent
+ * `hold`, and Control Web and desktop Control read that flag instead of keeping their own copy of the words.
+ *
+ * A title is a hold when, after leading punctuation ("[Hold] ...", "* Busy"), it starts with one of these words or
+ * phrases as a whole word, and it does not name someone with "with" ("Lunch with Jeremy" and "Focus group with the
+ * Jewel360 board" are meetings). Case and repeated spaces do not matter. A false "not a hold" only offers Prep on a hold;
+ * a false "hold" would hide Prep on a real meeting, so the rule stays narrow.
+ */
+export const CALENDAR_HOLD_WORDS: readonly string[] = Object.freeze([
+  'blocked', 'block', 'busy', 'hold', 'holds', 'focus', 'travel', 'personal', 'private', 'ooo', 'out of office', 'lunch',
+  'pto', 'vacation', 'commute', 'dnd', 'do not book', 'do not schedule',
+])
+// Letters and single spaces only, so the words need no escaping.
+const HOLD_START = new RegExp(`^(?:${CALENDAR_HOLD_WORDS.join('|')})(?![a-z0-9])`)
+
+export function isCalendarHold(title: unknown): boolean {
+  if (typeof title !== 'string') return false
+  const t = title.trim().toLowerCase().replace(/\s+/g, ' ').replace(/^[^a-z0-9]+/, '')
+  if (!t || !HOLD_START.test(t)) return false
+  return !/(?:^|[^a-z0-9])with(?![a-z0-9])/.test(t)
+}