@saluzi/saluzi-edu 0.2.61 → 0.2.62

package/dist/parade/web/menu.html

@@ -14,14 +14,23 @@
   cursor, so the menu can extend beyond the parade window.
 
   Contract with the electron main script:
-    - Window size: MENU_W x MENU_H design px (158x147) — the constants in
-      paradeWindow.ts MUST match the locked layout below.
-    - Query params: ?mode=<displayMode>&rot=<dynamic|static>&zoom=<dpiScale>
-      zoom is applied identically to index.html (physical px compensation on
+    - Window: one PRE-WARMED frameless transparent popup, created hidden at
+      startup and REUSED for every right-click (hide/show, never recreated —
+      recreating a renderer process per open read as a laggy menu). Main
+      re-anchors it via setBounds at the OS cursor and sizes it
+      MENU_W x MENU_H design px x unitScale — the constants in paradeWindow.ts
+      MUST match the locked layout below.
+    - State: pushed per open over IPC parade-menu-state {mode, rot}; the page
+      applies it and acks via paradeMenu.ready(), then main shows the window
+      (no stale highlight). The ?mode/&rot/&zoom=<dpiScale> query params are
+      only the initial-load fallback / browser-debugging path. zoom is applied
+      identically to index.html (physical px compensation on
       --force-device-scale-factor=1 Win11; multiply window size by unitScale).
     - Selections: window.paradeMenu.action({type:'view', value}) or
       ({type:'rotation'}) → IPC parade-menu-action → relayed to the parade
       window renderer, which stays the single source of truth for mode state.
+      Escape dismisses via window.paradeMenu.dismiss() (hide, not close —
+      the window is reused).
 -->
 <style>
   :root {
@@ -124,35 +133,67 @@
     <div class="ctx-item" id="ctx-mode">Rotation: Dynamic</div>
   </div>
 <script>
-// Reflect the parade window's current state passed via query string.
-;(function () {
-  var q = new URLSearchParams(window.location.search)
-
-  // DPI compensation — identical mechanism to index.html/cube.js: the main
-  // process forces 1 CSS px = 1 physical px on Win11, then we CSS-zoom the
-  // content by the OS DPI factor so physical size matches intent. Applied at
-  // parse time; the window was sized as design px x unitScale by main.
-  var zoom = parseFloat(q.get('zoom')) || 0
-  if (zoom > 1) document.documentElement.style.zoom = String(zoom)
-
-  // Mark the active display mode radio item.
-  var mode = q.get('mode') || ''
+// ---- State application ----
+// The electron main process pre-warms this page and reuses its window for
+// every right-click: each open pushes the parade window's current state via
+// the parade-menu-state IPC; the query params below are only the initial
+// fallback / browser-debugging path. applyState() must therefore REMOVE the
+// previous open's active marks, not just add new ones.
+function applyState(state) {
+  state = (state && typeof state === 'object') ? state : {}
+  var mode = String(state.mode || '')
   var views = document.querySelectorAll('.ctx-view')
   for (let i = 0; i < views.length; i++) {
     if (views[i].getAttribute('data-view') === mode) {
       views[i].classList.add('active')
+    } else {
+      views[i].classList.remove('active')
     }
   }
-
-  // Rotation label.
-  var rot = q.get('rot') === 'static' ? 'static' : 'dynamic'
+  var rot = state.rot === 'static' ? 'static' : 'dynamic'
   var modeEl = document.getElementById('ctx-mode')
   if (modeEl) {
     modeEl.textContent = 'Rotation: ' + (rot === 'dynamic' ? 'Dynamic' : 'Static')
   }
+}
+
+// The page itself is reused across opens, so the load-time #menu animation
+// would only ever play once — replay it on every state push (i.e. every open).
+function replayOpenAnimation() {
+  var menuEl = document.getElementById('menu')
+  if (!menuEl) return
+  menuEl.style.animation = 'none'
+  void menuEl.offsetWidth // force reflow so the animation restarts
+  menuEl.style.animation = ''
+}
+
+// Initial state via query string (fallback / browser debugging).
+;(function () {
+  var q = new URLSearchParams(window.location.search)
+
+  // DPI compensation — identical mechanism to index.html/cube.js: the main
+  // process forces 1 CSS px = 1 physical px on Win11, then we CSS-zoom the
+  // content by the OS DPI factor so physical size matches intent. Applied at
+  // parse time; the window was sized as design px x unitScale by main.
+  var zoom = parseFloat(q.get('zoom')) || 0
+  if (zoom > 1) document.documentElement.style.zoom = String(zoom)
+
+  applyState({ mode: q.get('mode') || '', rot: q.get('rot') || '' })
 })()
 
-// Report a selection to the electron main process, which closes the popup and
+// Per-open state push: apply, replay the open animation, then ack so main
+// shows the window with the highlight already up to date.
+if (window.paradeMenu && typeof window.paradeMenu.onState === 'function') {
+  window.paradeMenu.onState(function (state) {
+    applyState(state)
+    replayOpenAnimation()
+    if (typeof window.paradeMenu.ready === 'function') {
+      window.paradeMenu.ready()
+    }
+  })
+}
+
+// Report a selection to the electron main process, which hides the popup and
 // relays the action to the parade window renderer.
 function reportAction(action) {
   if (window.paradeMenu && typeof window.paradeMenu.action === 'function') {
@@ -178,10 +219,17 @@ if (modeEl) {
   })
 }
 
-// Escape dismisses (native-menu parity).
+// Escape dismisses (native-menu parity). The popup window is reused, so the
+// page must NOT window.close() itself (that would destroy the prewarmed
+// renderer) — it asks main to hide it instead. window.close() stays as the
+// browser-debugging fallback where the bridge is missing.
 document.addEventListener('keydown', function (e) {
   if (e.key === 'Escape') {
-    try { window.close() } catch (_) { /* ignore */ }
+    if (window.paradeMenu && typeof window.paradeMenu.dismiss === 'function') {
+      window.paradeMenu.dismiss()
+    } else {
+      try { window.close() } catch (_) { /* ignore */ }
+    }
   }
 })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saluzi/saluzi-edu",
-  "version": "0.2.61",
+  "version": "0.2.62",
   "description": "Saluzi CLI - interactive AI coding assistant in the terminal",
   "license": "MIT",
   "type": "module",

package/packages/remote-control-server/src/__tests__/models-state-snapshot.test.ts

@@ -0,0 +1,216 @@
+/**
+ * Regression: model selector gray after re-entering a session.
+ *
+ * models_state is a one-shot snapshot — the worker sends it only once per
+ * bridge connect, and the web UI restores it from the last models_state
+ * event in GET /history. Anything that wipes or evicts the event log
+ * (/clear, /new, window eviction) used to make the selector permanently
+ * gray until the worker reconnected. The bus now keeps the latest snapshot
+ * out-of-band: /clear re-seeds it, /history merges it when the log lacks
+ * the event. Covers both worker write paths:
+ *   - v1 session-ingress (HybridTransport POST → ingestBridgeMessage)
+ *   - v2 CCR worker events (POST /v1/code/sessions/:id/worker/events)
+ */
+import { describe, test, expect, beforeEach, mock } from 'bun:test'
+import { mockConfigModule } from './helpers/mock-config'
+
+mock.module('../config', () => mockConfigModule({ pollTimeout: 1 }))
+
+import { Hono } from 'hono'
+import { storeReset } from '../store'
+import {
+  getAllEventBuses,
+  removeEventBus,
+  getEventBus,
+} from '../transport/event-bus'
+
+import v1SessionIngress from '../routes/v1/session-ingress'
+import v2WorkerEvents from '../routes/v2/worker-events'
+import webSessions from '../routes/web/sessions'
+import { issueToken } from '../auth/token'
+import { deletePersistedEvents } from '../services/event-persistence'
+import { publishSessionEvent } from '../services/transport'
+
+function createApp() {
+  const app = new Hono()
+  app.route('/v2/session_ingress', v1SessionIngress)
+  app.route('/v1/code/sessions', v2WorkerEvents)
+  app.route('/web', webSessions)
+  return app
+}
+
+const AUTH_HEADERS = {
+  Authorization: 'Bearer test-api-key',
+  'X-Username': 'testuser',
+}
+
+function auth(user: string): string {
+  return `Bearer ${issueToken(user).token}`
+}
+
+const MODELS_STATE_MSG = {
+  type: 'models_state',
+  models_state: {
+    availableModels: [
+      { modelId: 'firstParty', name: 'First Party' },
+      { modelId: 'firstParty:opus', name: 'Opus' },
+    ],
+    currentModelId: 'firstParty',
+  },
+}
+
+describe('models_state snapshot survives history loss (gray selector regression)', () => {
+  let app: Hono
+  let sessionId: string
+
+  beforeEach(async () => {
+    storeReset()
+    for (const [key] of getAllEventBuses()) {
+      removeEventBus(key)
+    }
+    app = createApp()
+
+    const res = await app.request('/web/sessions', {
+      method: 'POST',
+      headers: {
+        Authorization: auth('user-1'),
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({}),
+    })
+    const body = (await res.json()) as { id: string }
+    sessionId = body.id
+  })
+
+  async function fetchHistory(): Promise<
+    Array<{ id: string; type: string; payload: Record<string, unknown> }>
+  > {
+    const res = await app.request(`/web/sessions/${sessionId}/history`, {
+      headers: { Authorization: auth('user-1') },
+    })
+    expect(res.status).toBe(200)
+    const body = (await res.json()) as {
+      events: Array<Record<string, unknown>>
+    }
+    return body.events as Array<{
+      id: string
+      type: string
+      payload: Record<string, unknown>
+    }>
+  }
+
+  function parseModelsState(
+    events: Array<{
+      id: string
+      type: string
+      payload: Record<string, unknown>
+    }>,
+  ): { availableModels: unknown[]; currentModelId: string } | null {
+    // Same parse the web adapter's loadHistory performs.
+    for (const event of [...events].reverse()) {
+      if (event.type !== 'models_state') continue
+      const raw = event.payload.raw
+      const state = (
+        raw && typeof raw === 'object'
+          ? (raw as Record<string, unknown>).models_state
+          : event.payload.models_state
+      ) as { availableModels: unknown[]; currentModelId: string } | undefined
+      if (
+        state &&
+        Array.isArray(state.availableModels) &&
+        typeof state.currentModelId === 'string'
+      ) {
+        return state
+      }
+    }
+    return null
+  }
+
+  test('v1 session-ingress POST path reaches /history', async () => {
+    const ingestRes = await app.request(
+      `/v2/session_ingress/session/${sessionId}/events`,
+      {
+        method: 'POST',
+        headers: { ...AUTH_HEADERS, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ events: [MODELS_STATE_MSG] }),
+      },
+    )
+    expect(ingestRes.status).toBe(200)
+
+    const state = parseModelsState(await fetchHistory())
+    expect(state).not.toBeNull()
+    expect(state?.currentModelId).toBe('firstParty')
+  })
+
+  test('v2 worker events POST path (payload envelope) reaches /history', async () => {
+    const ingestRes = await app.request(
+      `/v1/code/sessions/${sessionId}/worker/events`,
+      {
+        method: 'POST',
+        headers: { ...AUTH_HEADERS, 'Content-Type': 'application/json' },
+        body: JSON.stringify([
+          { payload: { ...MODELS_STATE_MSG, uuid: 'u1' } },
+        ]),
+      },
+    )
+    expect(ingestRes.status).toBe(200)
+
+    const state = parseModelsState(await fetchHistory())
+    expect(state).not.toBeNull()
+    expect(state?.availableModels).toHaveLength(2)
+  })
+
+  test('POST /clear re-seeds models_state so re-entry still restores the selector', async () => {
+    await app.request(`/v2/session_ingress/session/${sessionId}/events`, {
+      method: 'POST',
+      headers: { ...AUTH_HEADERS, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ events: [MODELS_STATE_MSG] }),
+    })
+
+    const clearRes = await app.request(`/web/sessions/${sessionId}/clear`, {
+      method: 'POST',
+      headers: { Authorization: auth('user-1') },
+    })
+    expect(clearRes.status).toBe(200)
+
+    const state = parseModelsState(await fetchHistory())
+    expect(state).not.toBeNull()
+    expect(state?.currentModelId).toBe('firstParty')
+  })
+
+  test('/history merges the bus snapshot when the event log lost the entry', async () => {
+    await app.request(`/v2/session_ingress/session/${sessionId}/events`, {
+      method: 'POST',
+      headers: { ...AUTH_HEADERS, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ events: [MODELS_STATE_MSG] }),
+    })
+
+    // Simulate pure log loss (server older than the re-seed, eviction, …):
+    // wipe events but keep the bus alive — the snapshot must cover it.
+    getEventBus(sessionId).clearHistory()
+    deletePersistedEvents(sessionId)
+
+    const state = parseModelsState(await fetchHistory())
+    expect(state).not.toBeNull()
+    expect(state?.availableModels).toHaveLength(2)
+  })
+
+  test('snapshot updates to the latest models_state (set_model re-report)', async () => {
+    publishSessionEvent(sessionId, 'models_state', MODELS_STATE_MSG, 'inbound')
+    publishSessionEvent(
+      sessionId,
+      'models_state',
+      {
+        type: 'models_state',
+        models_state: {
+          ...MODELS_STATE_MSG.models_state,
+          currentModelId: 'firstParty:opus',
+        },
+      },
+      'inbound',
+    )
+
+    const state = parseModelsState(await fetchHistory())
+    expect(state?.currentModelId).toBe('firstParty:opus')
+  })
+})

package/packages/remote-control-server/src/routes/web/sessions.ts

@@ -34,6 +34,7 @@ import {
 import { createWorkItem, stopWork } from '../../services/work-dispatch'
 import { createSSEStream } from '../../transport/sse-writer'
 import { getEventBus } from '../../transport/event-bus'
+import { publishSessionEvent } from '../../services/transport'
 
 const app = new Hono()
 
@@ -286,6 +287,26 @@ app.get('/sessions/:id/history', sessionAuth, async c => {
   const events = [...byId.values()].sort(
     (a, b) => a.createdAt - b.createdAt || a.seqNum - b.seqNum,
   )
+  // models_state fallback: the worker reports the model list once per bridge
+  // connect, so the event log can legitimately lack it (/clear before the
+  // re-seed existed, event-window eviction, pre-persistence servers). The
+  // bus keeps the latest snapshot out-of-band — merge it here so the web UI
+  // can restore the model selector on every re-entry.
+  if (!events.some(e => e.type === 'models_state')) {
+    const snapshot = getEventBus(sessionId).modelsStateSnapshot
+    if (snapshot) {
+      const lastCreated = events[events.length - 1]?.createdAt ?? Date.now()
+      events.push({
+        id: `models_state_snapshot_${sessionId}`,
+        sessionId,
+        seqNum: 0,
+        type: 'models_state',
+        payload: { models_state: snapshot },
+        direction: 'inbound',
+        createdAt: lastCreated + 1,
+      })
+    }
+  }
   return c.json({ events }, 200)
 })
 
@@ -344,6 +365,18 @@ app.post('/sessions/:id/clear', sessionAuth, async c => {
     },
     { transient: true },
   )
+  // Re-seed models_state from the bus snapshot. The worker only reports
+  // models_state once per bridge connect, so a plain history wipe would make
+  // the model selector permanently gray after re-entering the session (and
+  // /model would report "未提供模型选择能力") until the worker reconnects.
+  if (bus.modelsStateSnapshot) {
+    publishSessionEvent(
+      sessionId,
+      'models_state',
+      { type: 'models_state', models_state: bus.modelsStateSnapshot },
+      'inbound',
+    )
+  }
   log(`[RCS] Cleared conversation history for session ${sessionId}`)
   return c.json({ status: 'ok' }, 200)
 })

package/packages/remote-control-server/src/services/transport.ts

@@ -169,6 +169,18 @@ export function publishSessionEvent(
   const bus = getEventBus(sessionId)
   const eventId = randomUUID()
 
+  // models_state is a one-shot snapshot from the worker (sent on bridge
+  // connect, never re-sent during the worker's lifetime). Keep the latest
+  // payload on the bus so /clear re-seeding and /history fallback can
+  // restore the web UI's model selector even after the event log lost the
+  // original entry.
+  if (type === 'models_state' && payload && typeof payload === 'object') {
+    const state = (payload as Record<string, unknown>).models_state
+    if (state && typeof state === 'object') {
+      bus.modelsStateSnapshot = state as Record<string, unknown>
+    }
+  }
+
   const normalized = normalizePayload(type, payload)
   const transient = TRANSIENT_EVENT_TYPES.has(type)
 

package/packages/remote-control-server/src/transport/event-bus.ts

@@ -30,6 +30,16 @@ export class EventBus {
     MAX_SEEN_UUIDS_PER_BUS,
   )
   private seenUuidWriteIdx = 0
+  /**
+   * Latest models_state payload for the session, kept OUT of the retained
+   * event window. The worker reports models_state only once per bridge
+   * connect, while the event log is mutable (/clear wipes it, the bounded
+   * window evicts old entries) — without this snapshot any log loss makes
+   * the web UI's model selector permanently gray until the worker
+   * reconnects. Lives on the bus so it is dropped when the session is
+   * deleted (removeEventBus) and survives clearHistory().
+   */
+  modelsStateSnapshot: Record<string, unknown> | null = null
 
   subscribe(callback: Subscriber): () => void {
     this.subscribers.add(callback)