dsh-zen-remote 2.3.5 → 2.3.7

package/src/intercept.ts

@@ -671,6 +671,12 @@ export interface InterceptHandle {
    * re-judges NOW — the mergers dedupe no-change calls — instead of
    * waiting for the next frame or the 1s fallback poll. */
   currentSessionChanged(): void
+  /** PB-26a: trigger a summary-sync check for virtual session ids discovered
+   * OUTSIDE workspace/follow (a sidechat childId the plugin bridge just
+   * minted in a response rewrite, for instance). Empty and non-virtual
+   * entries are dropped; a batch with nothing left is a no-op. Reaches every
+   * live merged `$events` stream, and the pending slot when none is open. */
+  nudgeSummarySync(ids: readonly string[]): void
 }
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {
@@ -2013,6 +2019,15 @@ async function* mergedEventsStream(deps: MergedEventsStreamDeps): AsyncGenerator
   /** The ids the in-flight round asked (its triggering batches) — marked at
    * completion, joined by nothing (mid-flight batches queue instead). */
   let askingNow: string[] = []
+  /** PB-26a: the newest REAL-TIME running flag this stream delivered per
+   * VIRTUAL session id (the leg's forwarded `api-session/status` frames
+   * only — never the synthesized status-sync frames). Read when a row is
+   * first announced: a status frame that reached the UI BEFORE its row
+   * existed was dropped by the host (handleSessionStatus only updates
+   * sessions already in its summaries), and a flip during the list pull is
+   * newer than the snapshot's `running` — either way the announce must be
+   * followed by the live value. Cleared with a fresh serving period. */
+  const latestLiveStatus = new Map<string, boolean>()
   const scheduleRetry = (): void => {
     if (retryTimer !== undefined || retryAt.size === 0) return
     const earliest = Math.min(...retryAt.values())
@@ -2072,6 +2087,15 @@ async function* mergedEventsStream(deps: MergedEventsStreamDeps): AsyncGenerator
           if (announced.has(rowId)) continue
           announced.add(rowId)
           channel.push(frame)
+          // PB-26a: the row is born in the UI carrying the snapshot's
+          // `running`; when this stream delivered a live status for it the
+          // host could not apply (no row yet) or that postdates the
+          // snapshot, realign right behind the added frame — only when the
+          // two disagree, a matching flag needs no second frame.
+          const liveRunning = latestLiveStatus.get(rowId)
+          if (liveRunning !== undefined && liveRunning !== (isPlainObject(row) && row.running === true)) {
+            channel.push({ type: 'emit', event: 'api-session/status', args: [rowId, liveRunning] })
+          }
         }
         // T65-fix ask bookkeeping: a returned id is announced and done; an
         // id the server did NOT return either exhausts its attempts or
@@ -2206,6 +2230,10 @@ async function* mergedEventsStream(deps: MergedEventsStreamDeps): AsyncGenerator
       askedForGood.clear()
       askAttempts.clear()
       retryAt.clear()
+      // PB-26a: the live flags belong to the serving period that delivered
+      // them — the status re-sync below re-reads every row from a fresh
+      // snapshot.
+      latestLiveStatus.clear()
       if (retryTimer !== undefined) {
         clock.clearTimeout(retryTimer)
         retryTimer = undefined
@@ -2370,6 +2398,20 @@ async function* mergedEventsStream(deps: MergedEventsStreamDeps): AsyncGenerator
             if (isPlainObject(frame) && frame.type === 'emit' && frame.event === 'api-session/status') {
               const rowId = Array.isArray(frame.args) ? frame.args[0] : undefined
               if (typeof rowId === 'string' && rowId !== '') liveStatusSeq.set(rowId, ++statusSeq)
+              // PB-26a: the rewritten frame is the proved shape (`args` =
+              // [virtualId, running]). Remember the live flag under the
+              // VIRTUAL id, and — when this stream has not announced the row
+              // — pull the list now: a sidechat / subagent child rides no
+              // workspace/follow frame, so this status is the client's first
+              // (and, until the next turn, only) notice that the row exists.
+              // The frame itself still crosses at once, below.
+              const args = isPlainObject(rewritten) && Array.isArray(rewritten.args) ? rewritten.args : undefined
+              const virtualId = args?.[0]
+              const running = args?.[1]
+              if (typeof virtualId === 'string' && typeof running === 'boolean') {
+                latestLiveStatus.set(virtualId, running)
+                if (!announced.has(virtualId)) handleForwardedBatch([virtualId])
+              }
             }
             // The orphan-close bookkeeping rides the two id-carrying frame
             // types: waterfalls enter the record (once per leg — a repeat
@@ -3498,6 +3540,10 @@ export function installIntercept(options: InstallInterceptOptions): InterceptHan
     currentSessionChanged() {
       for (const listener of [...currentSessionListeners]) listener()
     },
+    nudgeSummarySync(ids: readonly string[]) {
+      const virtualIds = ids.filter((id) => typeof id === 'string' && id !== '' && isVirtual(id))
+      if (virtualIds.length > 0) summarySync.noteForwardedSessionIds(virtualIds)
+    },
   }
 }
 

package/src/log-ring.ts

@@ -0,0 +1,101 @@
+/**
+ * CU-1: the plugin's in-process diagnostic log ring (SPEC §方案 C). A bounded
+ * FIFO of the plugin row's own log lines, kept in memory only — the desktop
+ * app writes no log file, so this is the one artifact the debug report (CU-2)
+ * can read on either role. Deliberately NOT a file, and deliberately only
+ * this plugin's lines: DSH's own log stream stays untouched.
+ *
+ * Pure module: no DSH imports, no I/O, no clocks beyond the timestamp it
+ * stamps entries with. The wiring lives in src/index.ts, which funnels its
+ * `logWarn` / `logInfo` through {@link createPluginLog} so existing call
+ * sites enter the ring unchanged (double write: logger first, ring second),
+ * and pushes the handful of lifecycle events (row apply/reload, gateway
+ * spawn/exit, relay link flips, fetch-route installs) by hand.
+ *
+ * One discipline the debug report leans on: ring lines carry event codes,
+ * id shapes and counters — never payloads. The redactor (debug-redact.ts)
+ * is the second layer, not the license to log secrets here.
+ */
+
+import { format } from 'node:util'
+
+/** Severity of one ring entry. The ring only distinguishes what the report
+ * renders: info lines and warnings. */
+export type LogLevel = 'info' | 'warn'
+
+/** One ring entry: ISO timestamp, level, fully interpolated message. */
+export interface LogRingEntry {
+  t: string
+  level: LogLevel
+  msg: string
+}
+
+/** Longest message kept, in characters (UTF-16 code units). Debug lines are
+ * codes and shapes, not dumps — anything longer was the wrong thing to log. */
+const MAX_MSG_CHARS = 512
+
+/** The ring's face. `push` never throws and never returns anything; callers
+ * log through it exactly like they would through the context logger. */
+export interface LogRing {
+  push(level: LogLevel, formatText: string, ...args: unknown[]): void
+  /** Oldest-last copy of the ring. Mutating the returned array or its
+   * entries never reaches the ring's own state. */
+  snapshot(): LogRingEntry[]
+}
+
+/**
+ * Create one bounded log ring. `cap` defaults to 300 entries — a full debug
+ * session of lifecycle lines plus a healthy share of warnings, while keeping
+ * the report a fixed small size. A cap below 1 is clamped to 1.
+ */
+export function createLogRing(cap = 300): LogRing {
+  const capacity = Number.isFinite(cap) && cap >= 1 ? Math.floor(cap) : 1
+  const entries: LogRingEntry[] = []
+  return {
+    push(level, formatText, ...args) {
+      let msg: string
+      try {
+        msg = args.length === 0 ? String(formatText) : format(formatText, ...args)
+      } catch {
+        // A malformed format string must never break the caller's flow —
+        // keep the raw template as the message.
+        msg = String(formatText)
+      }
+      if (msg.length > MAX_MSG_CHARS) msg = msg.slice(0, MAX_MSG_CHARS)
+      entries.push({ t: new Date().toISOString(), level, msg })
+      if (entries.length > capacity) entries.splice(0, entries.length - capacity)
+    },
+    snapshot() {
+      return entries.map((entry) => ({ ...entry }))
+    },
+  }
+}
+
+/** The logger face this module needs: the cordis context logger's two
+ * methods, each optional (test fakes carry none). */
+export interface PluginLogLike {
+  info?(format: string, ...args: unknown[]): void
+  warn?(format: string, ...args: unknown[]): void
+}
+
+/** The double-writer the apply() wiring funnels its logging through: every
+ * line reaches the context logger (unchanged behavior, unchanged call
+ * sites) AND the ring (the debug report's source). A ring failure is
+ * swallowed; a logger failure propagates exactly as it did before this
+ * module existed. */
+export function createPluginLog(ring: LogRing, logger: PluginLogLike | undefined): { info(format: string, ...args: unknown[]): void, warn(format: string, ...args: unknown[]): void } {
+  return {
+    info(formatText, ...args) {
+      logger?.info?.(formatText, ...args)
+      try {
+        ring.push('info', formatText, ...args)
+      } catch { /* the ring must never break logging */ }
+    },
+    warn(formatText, ...args) {
+      logger?.warn?.(formatText, ...args)
+      try {
+        ring.push('warn', formatText, ...args)
+      } catch { /* the ring must never break logging */ }
+    },
+  }
+}

package/src/plugin-adapter-core.ts

@@ -25,7 +25,7 @@
 import { createHash } from 'node:crypto'
 import { isVirtual, fromVirtual } from './virtual-id.js'
 import { MAX_UPLOAD_BYTES } from './upload-limits.js'
-import type { NormalizedBridgeRoute, NormalizedDeclaration } from './plugin-bridge.js'
+import type { BridgeLocator, NormalizedBridgeRoute, NormalizedDeclaration } from './plugin-bridge.js'
 import { BRIDGE_METHODS, DEFAULT_ROUTE_BODY_BYTES } from './plugin-bridge.js'
 
 export { fromVirtual }
@@ -327,6 +327,15 @@ export function normalizeAdapter(input: unknown, installedVersion: string, optio
         methods: route.methods.length === 1 && route.methods[0] === 'GET' ? undefined : [...route.methods],
         maxBody: route.maxBody === DEFAULT_ROUTE_BODY_BYTES ? undefined : route.maxBody,
         upgrade: route.upgrade ? true : undefined,
+        // PB-26b: an upgrade route whose ids do NOT ride the query keeps its
+        // locator on the registry entry — the tunnel's validation and the
+        // client's upgrade surrogate read where the ids actually arrive (the
+        // sidechat ws watch carries them in the post-handshake JSON frames).
+        // A query route's declaration stays EXACTLY the 2.1 shape — no
+        // locator key — so every older consumer and digest is untouched
+        // (the adapter digest always covered route.locator and never
+        // covered the declaration routes' shape).
+        ...(route.upgrade && route.locator.in !== 'query' ? { locator: route.locator as BridgeLocator } : {}),
       })),
     digest,
   }
@@ -483,6 +492,16 @@ export function locateAdapterIds(route: NormalizedAdapterRoute, pathname: string
       for (const field of locator.fields) {
         const value = body[field]
         if (typeof value === 'string' && value !== '') hits.push({ kind: 'json-body', key: field, value })
+        // PB-26b: a field may carry a LIST of ids — better-sidebar's sidechat
+        // ws watch frame sends `{"op":"watch","threadIds":[...]}`. Every
+        // non-empty string element is one hit under the same field key, so
+        // classify/rewrite treat the batch exactly like repeated query
+        // values: every id virtual → remote, one mixed in → refuse.
+        else if (Array.isArray(value)) {
+          for (const item of value) {
+            if (typeof item === 'string' && item !== '') hits.push({ kind: 'json-body', key: field, value: item })
+          }
+        }
       }
     }
   }
@@ -549,7 +568,15 @@ export function rewriteAdapterRequest(
     } else {
       if (bodyCopy === undefined && isRecord(body)) bodyCopy = { ...body }
       if (bodyCopy !== undefined) {
-        bodyCopy[hit.key!] = real
+        const current = bodyCopy[hit.key!]
+        // PB-26b: an array field rewrites IN PLACE, element for element —
+        // only the entries equal to this hit's located value swap for their
+        // real halves, so a mixed batch of ids keeps its shape and order.
+        if (Array.isArray(current)) {
+          bodyCopy[hit.key!] = current.map((item) => (item === hit.value ? real : item))
+        } else {
+          bodyCopy[hit.key!] = real
+        }
         bodyText = JSON.stringify(bodyCopy)
       }
     }