dsh-zen-remote 2.3.7 → 2.3.9

package/src/client/wizard/GatewayWizard.tsx

@@ -33,11 +33,13 @@ import {
   CLIENT_CONFIG_ROUTE,
   CLIENT_RECONNECT_ROUTE,
   CLIENT_STATUS_ROUTE,
+  awaitClientStatusReady,
   claimDeviceNameOf,
   clientStatusLineOf,
   deriveClientStatusView,
   deriveSettingsView,
   normalizePairingCode,
+  shouldReloadAfterClientActivation,
 } from '../../client-data/settings-form.ts'
 import { qrMatrix } from '../../client-data/qr.ts'
 import {
@@ -761,6 +763,12 @@ export function GatewayWizard(props: GatewayWizardProps): ReactNode {
   const runClientClaim = async (): Promise<void> => {
     setFormError(null)
     setClientClaimFail(null)
+    // UX-1: the facts that decide the post-pairing reload — whether the page
+    // opened as an already-effective client, and whether the backend's
+    // stream interceptor was already active (from the last client/status
+    // diagnostics). Captured BEFORE the role switch and the claim below.
+    const wasEffectiveClient = effectiveClient
+    const streamInterceptAlreadyActive = clientView?.intercept?.installed === true
     const trimmedUrl = clientServerUrl.trim()
     const normalizedCode = normalizePairingCode(clientPairCode)
     if (trimmedUrl === '' || !/^https?:\/\//i.test(trimmedUrl)) {
@@ -801,7 +809,21 @@ export function GatewayWizard(props: GatewayWizardProps): ReactNode {
       if (body?.ok === true && typeof body.token === 'string' && body.token !== '') {
         const urlToWrite = typeof body.serverUrl === 'string' && body.serverUrl !== '' ? body.serverUrl : trimmedUrl
         const echoed = typeof body.deviceName === 'string' && body.deviceName.trim() !== '' ? body.deviceName.trim() : deviceName
-        await config.writeClientPairing(urlToWrite, body.token, echoed)
+        const landed = await config.writeClientPairing(urlToWrite, body.token, echoed)
+        if (landed && shouldReloadAfterClientActivation({
+          wasEffectiveClient,
+          nowClientRole: true,
+          savedOrPaired: true,
+          streamInterceptAlreadyActive,
+        })) {
+          // UX-1: this was the FIRST client activation while the page's three
+          // resident global streams were opened unwrapped — wait out the
+          // backend's row-reload window, then reload so the streams reopen
+          // wrapped and the server's shared sessions enter the sidebar.
+          await awaitClientStatusReady()
+          window.location.reload()
+          return
+        }
         setClientPairCode('')
         await loadClientStatus()
         setStep('verify')

package/src/client-data/new-session.ts

@@ -0,0 +1,30 @@
+/**
+ * UX-3 — what tapping the phone home screen's "+ 新建会话" FAB should do.
+ *
+ * Entering a blank session with NO workspace leaves the phone dangling in
+ * the hero's inert "choose a workspace" state (the host's `marshal-main`
+ * belongs to no workspace, so the "all" filter often resolves to
+ * `undefined`). Decide BEFORE entering:
+ *
+ * - a workspace is already selected → start there;
+ * - exactly one workspace exists (or none at all) → start with it
+ *   (`undefined` keeps a no-workspace host usable);
+ * - several workspaces and none selected → the FAB opens the same
+ *   bottom-sheet workspace drawer the title bar uses, and the session only
+ *   starts once one is picked.
+ *
+ * Pure: no DOM, no imports — MobileHome calls it inside the FAB's onClick
+ * and test/permission-sheet.test.cjs drives it directly.
+ */
+export type NewSessionAction<W extends string> =
+  | { kind: 'start'; workspaceId: W | undefined }
+  | { kind: 'pick-workspace' }
+
+export function decideNewSessionAction<W extends string>(
+  selectedWorkspaceId: W | undefined,
+  workspaceIds: readonly W[],
+): NewSessionAction<W> {
+  if (selectedWorkspaceId !== undefined) return { kind: 'start', workspaceId: selectedWorkspaceId }
+  if (workspaceIds.length <= 1) return { kind: 'start', workspaceId: workspaceIds[0] }
+  return { kind: 'pick-workspace' }
+}

package/src/client-data/settings-form.ts

@@ -433,6 +433,63 @@ export function shouldFollowServerDeviceName(deviceName: string, rowName: string
   return deviceName !== '' && deviceName !== rowName && !hasDraft
 }
 
+// --- UX-1: reload after the FIRST client activation ---------------------------
+
+/**
+ * Whether one successful client-side activation (a staged-save role switch, a
+ * first pairing) needs a page reload: the backend's restart-watcher only
+ * installs the stream interceptor when the row reloads into client mode, and
+ * the page's three resident global streams were opened under whatever gateway
+ * object was current AT LOAD TIME. Without a reload they stay unwrapped and
+ * the server's remote sessions never enter the merged sidebar lists.
+ *
+ * - A write that did not land, or a save that is not heading to `client`,
+ *   never reloads.
+ * - A host→client switch always reloads: the streams predate the interceptor.
+ * - An already-client page reloads only when the diagnostics say the
+ *   interceptor was NOT yet active (`streamInterceptAlreadyActive === false`).
+ *   `undefined` — an older server that answers no diagnostics — is UNKNOWN and
+ *   stays on the safe no-reload side (a re-pairing must not needlessly reload).
+ */
+export interface ClientActivationReloadInput {
+  /** Whether the page was ALREADY an effective client before this operation. */
+  wasEffectiveClient: boolean
+  /** Whether the role after the operation is (or is switching to) client. */
+  nowClientRole: boolean
+  /** Whether this operation actually landed (the save / pairing write). */
+  savedOrPaired: boolean
+  /** The client/status diagnostics' interceptor flag before the operation
+   * (derived by the caller); `undefined` when unknown. */
+  streamInterceptAlreadyActive?: boolean
+}
+
+export function shouldReloadAfterClientActivation(input: ClientActivationReloadInput): boolean {
+  if (!input.savedOrPaired || !input.nowClientRole) return false
+  if (!input.wasEffectiveClient) return true
+  if (input.streamInterceptAlreadyActive === false) return true
+  return false
+}
+
+/**
+ * Poll {@link CLIENT_STATUS_ROUTE} until the backend answers ok — the bounded
+ * wait before the post-activation reload, covering the restart-watcher's row
+ * reload window (the route 404s / fails while the row restarts). Resolves
+ * after `maxMs` regardless, so the reload always fires. Injectable fetch and
+ * timings keep the check script fast; defaults are the page's 3 s / 250 ms.
+ */
+export async function awaitClientStatusReady(fetchFn: typeof fetch = fetch, maxMs = 3000, intervalMs = 250): Promise<void> {
+  const deadline = Date.now() + maxMs
+  while (true) {
+    try {
+      if ((await fetchFn(CLIENT_STATUS_ROUTE)).ok) return
+    } catch {
+      // the row is mid-reload; keep polling
+    }
+    if (Date.now() >= deadline) return
+    await new Promise((resolve) => setTimeout(resolve, intervalMs))
+  }
+}
+
 /**
  * Latest-wins sequencing for the status loads: every request takes a ticket,
  * and only the newest ticket may still apply its result. An earlier request

package/src/merge-streams.ts

@@ -968,6 +968,49 @@ export interface ControlMerger {
   retarget(identity: MergerIdentity): void
 }
 
+/** One `session/control` projection change, independent of the wire shape. */
+export interface ControlProjectionChange {
+  key: string
+  value: unknown
+}
+
+/**
+ * Read the changes of one live `session/control` `projection` frame in either
+ * wire shape. DSH 0.2.2-alpha.3 batched the frame per committed event —
+ * `{type:'projection', sessionId, seq, changes:[{key, val}]}` (its client
+ * face's handleControlFrame iterates `frame.changes`) — where 0.2.1 and
+ * 0.2.2-alpha.2 send one key per frame, `{type:'projection', sessionId, key,
+ * value, seq}` (that client face reads `frame.key` / `frame.value`). A
+ * `changes` array wins when present; `undefined` means neither shape is
+ * usable (a malformed entry spoils the whole frame, like every other
+ * malformed frame here).
+ */
+export function controlProjectionChanges(frame: Record<string, unknown>): ControlProjectionChange[] | undefined {
+  if (Array.isArray(frame.changes)) {
+    const out: ControlProjectionChange[] = []
+    for (const change of frame.changes) {
+      if (!isPlainObject(change) || typeof change.key !== 'string' || !('val' in change)) return undefined
+      out.push({ key: change.key, value: change.val })
+    }
+    return out
+  }
+  if (typeof frame.key === 'string' && 'value' in frame) return [{ key: frame.key, value: frame.value }]
+  return undefined
+}
+
+/**
+ * One single-key `session/control` projection frame that BOTH client
+ * generations apply: the per-key `key` / `value` fields for DSH ≤ 0.2.2-alpha.2
+ * and a one-entry `changes` list for ≥ 0.2.2-alpha.3. Neither client face
+ * validates stream frames (the gateway client only runs a binary `decode`),
+ * and each reads only its own fields, so the extra ones are inert. Splitting a
+ * batched frame into one frame per key at the same seq is lossless: the
+ * projection store applies per key (`seq <= row.seq` per row).
+ */
+export function controlProjectionFrame(sessionId: string, key: string, value: unknown, seq: number): Record<string, unknown> {
+  return { type: 'projection', sessionId, key, value, seq, changes: [{ key, val: value }] }
+}
+
 /**
  * The session/control merger. The control stream is key-value projection
  * traffic with no ordering constraints between sessions, so it needs no
@@ -1016,13 +1059,14 @@ export function createControlMerger(options: ControlMergerOptions): ControlMerge
           // UNCONDITIONALLY (T52-fix3): the host's projection store is
           // first-write-wins per seq, so a catalog-gated original value would
           // occupy the seq and the later virtual rewrite could never land.
-          out.push({
-            type: 'projection',
-            sessionId: virtualize(sessionId),
-            key,
-            value: key === 'modelSelection' ? virtualizeModelSelectionValue(values[key], identity.serverId) : values[key],
-            seq: asOfSeq,
-          })
+          out.push(
+            controlProjectionFrame(
+              virtualize(sessionId),
+              key,
+              key === 'modelSelection' ? virtualizeModelSelectionValue(values[key], identity.serverId) : values[key],
+              asOfSeq,
+            ),
+          )
         }
       }
       return out
@@ -1038,18 +1082,29 @@ export function createControlMerger(options: ControlMergerOptions): ControlMerge
         onDiagnostic?.(`dropped a session/control projection frame with unusable seq ${String(frame.seq)}`)
         return []
       }
-      return [
-        {
-          ...frame,
-          sessionId: virtualize(frame.sessionId),
+      // DSH 0.2.2-alpha.3 batches one event's changes into `changes[]`;
+      // older hosts send one key per frame. Read either, then emit one
+      // dual-shape frame per key so a local UI of EITHER generation applies
+      // it (a mixed local/server pair is only a fingerprint warning, the
+      // stream still flows).
+      const changes = controlProjectionChanges(frame)
+      if (changes === undefined) {
+        onDiagnostic?.('dropped a session/control projection frame with neither key/value nor a changes list')
+        return []
+      }
+      const sessionId = virtualize(frame.sessionId)
+      const seq = frame.seq
+      return changes.map(({ key, value }) =>
+        controlProjectionFrame(
+          sessionId,
+          key,
           // The modelSelection update's providers go virtual with the session
           // id (T52) — same unconditional rewrite as the exploded baseline
           // above (T52-fix3: first-write-wins per seq forbids a catalog gate).
-          ...(frame.key === 'modelSelection'
-            ? { value: virtualizeModelSelectionValue(frame.value, identity.serverId) }
-            : {}),
-        },
-      ]
+          key === 'modelSelection' ? virtualizeModelSelectionValue(value, identity.serverId) : value,
+          seq,
+        ),
+      )
     }
     onDiagnostic?.(`dropped a session/control frame of unknown type ${String(frame.type)}`)
     return []

package/src/relay-filter.ts

@@ -88,9 +88,10 @@ export function filterWorkspaceFrame(frame: unknown, isAccessible: Accessibility
 /**
  * Filter one `session/control` frame. Exactly two frame types exist:
  * `baseline{value:{projections: Record<sessionId, {asOfSeq, values}>}}` — the
- * per-session map keeps only accessible keys — and `projection{sessionId, key,
- * value, seq}` — kept whole or dropped by its session id. Anything else is
- * dropped.
+ * per-session map keeps only accessible keys — and `projection{sessionId, …}`
+ * (per-key `key, value, seq` up to DSH 0.2.2-alpha.2, batched `seq,
+ * changes[]` from alpha.3) — kept whole or dropped by its session id, so either
+ * shape passes untouched. Anything else is dropped.
  *
  * The baseline record is rebuilt with `defineProperty` because a session id of
  * `__proto__` must become an own data property of the new record, not fire the

package/src/relay-server.ts

@@ -27,6 +27,7 @@
  */
 
 import { withPeer } from './owner-peer.js'
+import { controlProjectionFrame } from './merge-streams.js'
 import { randomBytes, timingSafeEqual } from 'node:crypto'
 import { Readable, Transform } from 'node:stream'
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
@@ -2508,8 +2509,9 @@ export function createRelayHandler(options: RelayHandlerOptions): RelayHandler {
           })
         } else if (decision.filter === 'control') {
           // A newly shared session needs its current projections: fetch
-          // them once and emit one synthesized `projection` frame per key,
-          // shaped exactly like the upstream frames. An unshared session
+          // them once and emit one synthesized `projection` frame per key in
+          // the dual shape both DSH generations read (per-key key/value for
+          // ≤ 0.2.2-alpha.2, a one-entry `changes` list for ≥ alpha.3). An unshared session
           // synthesizes nothing — the client drops it via the workspace
           // stream's re-filtered upserts.
           const syncProjections = async (sessionId: string): Promise<void> => {
@@ -2528,7 +2530,7 @@ export function createRelayHandler(options: RelayHandlerOptions): RelayHandler {
             const values = isPlainObject(result.values) ? result.values : {}
             const seq = typeof result.asOfSeq === 'number' ? result.asOfSeq : 0
             for (const key of Object.keys(values)) {
-              void writeLine({ type: 'frame', frame: { type: 'projection', sessionId, key, value: values[key], seq } })
+              void writeLine({ type: 'frame', frame: controlProjectionFrame(sessionId, key, values[key], seq) })
             }
           }
           unsubscribe = store.subscribe((event) => {