dsh-plugin-mobile-gateway 0.7.2 → 0.7.4

package/lib/client.js

@@ -248,18 +248,17 @@ window.__ModuleLoader__.load({
         }
       }
 
-      const toggleGateway = async () => {
-        const enabled = !(status && status.gatewayEnabled)
+      const changeGatewayMode = async (mode) => {
         setBusy(true)
         setError(null)
         try {
           const data = await request('/mgw/gateway', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ enabled }),
+            body: JSON.stringify({ mode }),
           })
           setStatus((current) => ({ ...(current || {}), ...data }))
-          if (!enabled) setQr(null)
+          if (mode === 'disabled') setQr(null)
         } catch (cause) {
           setError(cause.message)
         } finally {
@@ -324,25 +323,35 @@ window.__ModuleLoader__.load({
           React.createElement('section', { style: styles.card },
             React.createElement('div', { style: { display: 'flex', justifyContent: 'space-between', gap: 14, alignItems: 'center' } },
               React.createElement('div', null,
-                React.createElement('strong', null, '允许移动设备连接'),
+                React.createElement('strong', null, '网关运行模式'),
                 React.createElement('div', { style: { ...styles.muted, marginTop: 4 } }, status && status.gatewayEnabled
-                  ? status.connectedClients > 0
-                    ? `${status.connectedClients} 个连接，网关保持开启`
-                    : `等待可信设备连接${status.waitExpiresAt ? `，约 ${Math.max(1, Math.ceil((status.waitExpiresAt - Date.now()) / 60000))} 分钟后自动关闭` : ''}`
-                  : '关闭时不会接受移动设备连接')),
-              React.createElement('label', { style: { ...styles.switch, opacity: busy || !status ? .55 : 1 }, title: status && status.gatewayEnabled ? '关闭移动网关' : '开启移动网关' },
-                React.createElement('input', {
-                  type: 'checkbox',
-                  role: 'switch',
-                  'aria-label': '允许移动设备连接',
-                  'aria-checked': !!(status && status.gatewayEnabled),
-                  checked: !!(status && status.gatewayEnabled),
+                  ? status.gatewayMode === 'persistent'
+                    ? '常驻开启，重启后保持；无需设备在线'
+                    : status.waitExpiresAt
+                      ? `等待可信设备连接，约 ${Math.max(1, Math.ceil((status.waitExpiresAt - Date.now()) / 60000))} 分钟后自动关闭`
+                      : '设备已连接过，本次运行保持开启；重启后重新计时'
+                  : '关闭时不会接受移动设备连接，重启后保持关闭')),
+              React.createElement('span', { style: { position: 'relative', display: 'inline-flex', flexShrink: 0 } },
+                React.createElement('select', {
+                  style: { ...styles.input, width: 'auto', marginBottom: 0, padding: '8px 40px 8px 12px', appearance: 'none', WebkitAppearance: 'none' },
+                  'aria-label': '网关运行模式',
+                  value: status ? status.gatewayMode || (status.gatewayEnabled ? 'temporary' : 'disabled') : 'disabled',
                   disabled: busy || !status,
-                  onChange: toggleGateway,
-                  style: styles.switchInput,
-                }),
-                React.createElement('span', { style: { ...styles.switchTrack, background: status && status.gatewayEnabled ? colors.success : colors.muted } }),
-                React.createElement('span', { style: { ...styles.switchKnob, left: status && status.gatewayEnabled ? 21 : 3 } })))),
+                  onChange: (event) => changeGatewayMode(event.target.value),
+                },
+                React.createElement('option', { value: 'disabled' }, '关闭'),
+                React.createElement('option', { value: 'temporary' }, '临时开启'),
+                React.createElement('option', { value: 'persistent' }, '常驻开启')),
+                React.createElement('span', {
+                  'aria-hidden': true,
+                  style: {
+                    position: 'absolute', right: 15, top: '50%', width: 7, height: 7,
+                    borderRight: `1.5px solid ${colors.text}`, borderBottom: `1.5px solid ${colors.text}`,
+                    transform: 'translateY(-65%) rotate(45deg)', pointerEvents: 'none',
+                  },
+                }))),
+            status && status.gatewayId ? React.createElement('div', { style: { ...styles.muted, marginTop: 12, overflowWrap: 'anywhere' } },
+              `${status.gatewayName} · ${status.gatewayId}`) : null),
           React.createElement('section', { style: styles.card },
             React.createElement('div', { style: { display: 'flex', justifyContent: 'space-between', gap: 14, alignItems: 'center' } },
               React.createElement('div', null,

package/lib/dsh-host-adapter.mjs

@@ -13,88 +13,52 @@ function requireArray(value, endpoint) {
   return value
 }
 
-function chunkRowLength(event) {
-  if (event.type === 'chunkrow/tool-call-chunks') return requireArray(event.data?.args, event.type).length
-  return requireArray(event.data?.texts, event.type).length
+export const DSH_VERSION = '0.1.5-rc.2'
+export const SESSION_FORMAT_VERSION = 3
+
+export function readHistoryRecords(records) {
+  return requireArray(records, 'session history').map(record => {
+    const value = requireRecord(record, 'session history record')
+    if (value.type !== 'event') throw new Error('DSH 0.1.5-rc.2 history requires event records')
+    const event = requireRecord(value.event, 'session history event')
+    if (!Number.isSafeInteger(event.seq) || event.seq < 0) throw new Error('invalid history sequence')
+    return event
+  })
 }
 
-// DSH 0.1.2 compresses consecutive assistant deltas inside history pages.
-// dsh-mobile-v1 predates that storage shape, so restore the exact logical
-// SessionEvent sequence at this boundary instead of teaching every client a
-// Host-specific encoding detail.
-function expandChunkRow(event) {
-  const data = requireRecord(event.data, event.type)
-  const values = event.type === 'chunkrow/tool-call-chunks'
-    ? requireArray(data.args, event.type)
-    : requireArray(data.texts, event.type)
-  const gaps = requireArray(data.dt, event.type)
-  if (gaps.length !== Math.max(0, values.length - 1)) {
-    throw new Error(`${event.type} returned invalid timing data`)
-  }
-  const events = []
-  let time = event.time
-  for (let index = 0; index < values.length; index += 1) {
-    if (index > 0) time += gaps[index - 1]
-    let chunk
-    if (event.type === 'chunkrow/text-chunks') {
-      chunk = { type: 'text-delta', index: data.index, text: values[index] }
-    } else if (event.type === 'chunkrow/reasoning-chunks') {
-      chunk = { type: 'reasoning-delta', index: data.index, text: values[index] }
-    } else {
-      chunk = {
-        type: 'tool-call-delta',
-        index: data.index,
-        id: data.id,
-        ...(Object.hasOwn(data, 'name') ? { name: data.name } : {}),
-        argumentsDelta: values[index],
-      }
-    }
-    events.push({
-      type: 'assistant/chunk',
-      seq: event.seq + index,
-      time,
-      data: { turn: data.turn, step: data.step, chunk },
+export function readSessionSnapshot(frame, sessionId) {
+  requireRecord(frame, 'session/follow')
+  if (frame.type !== 'snapshot' || !Number.isSafeInteger(frame.cursor) || frame.cursor < -1
+    || frame.header?.id !== sessionId) throw new Error('session/follow returned an invalid snapshot')
+  if (frame.header.version !== SESSION_FORMAT_VERSION) {
+    throw Object.assign(new Error('mobile-gateway requires DSH 0.1.5-rc.2 Session format 3'), {
+      code: 'unsupported-session-format',
     })
   }
-  return events
-}
-
-export function expandHistoryRecords(records) {
-  const events = []
-  for (const record of requireArray(records, 'session history')) {
-    const value = requireRecord(record, 'session history record')
-    const event = requireRecord(value.event, 'session history event')
-    if (value.type === 'event') {
-      events.push(event)
-      continue
-    }
-    if (value.type !== 'chunks' || ![
-      'chunkrow/text-chunks',
-      'chunkrow/reasoning-chunks',
-      'chunkrow/tool-call-chunks',
-    ].includes(event.type)) {
-      throw new Error('session history returned an unsupported record')
-    }
-    if (chunkRowLength(event) === 0) throw new Error(`${event.type} returned an empty run`)
-    events.push(...expandChunkRow(event))
+  return {
+    events: readHistoryRecords(frame.records).map(event => ({ event })),
+    hasMore: frame.hasMore === true,
+    projections: requireRecord(frame.projections, 'session/follow projections'),
+    historyFormatVersion: frame.header.version,
+    cursor: frame.cursor,
   }
-  return events
 }
 
 async function firstStreamFrame(gateway, namespace, method, args, signal) {
-  const ownedAbort = signal === undefined ? new AbortController() : null
-  const streamSignal = signal ?? ownedAbort.signal
-  const iterable = await gateway.stream({ namespace, method, args, signal: streamSignal })
-  const iteratorFactory = iterable?.[Symbol.asyncIterator] ?? iterable?.[Symbol.iterator]
-  if (typeof iteratorFactory !== 'function') throw new Error(`${namespace}/${method} returned an invalid stream`)
-  const iterator = iteratorFactory.call(iterable)
+  const ownedAbort = new AbortController()
+  const streamSignal = signal ? AbortSignal.any([signal, ownedAbort.signal]) : ownedAbort.signal
+  let iterator
   try {
+    const iterable = await gateway.stream({ namespace, method, args, signal: streamSignal })
+    const iteratorFactory = iterable?.[Symbol.asyncIterator] ?? iterable?.[Symbol.iterator]
+    if (typeof iteratorFactory !== 'function') throw new Error(`${namespace}/${method} returned an invalid stream`)
+    iterator = iteratorFactory.call(iterable)
     const first = await iterator.next()
     if (first.done) throw new Error(`${namespace}/${method} ended before its opening frame`)
     return first.value
   } finally {
-    ownedAbort?.abort()
-    if (typeof iterator.return === 'function') await iterator.return()
+    ownedAbort.abort()
+    if (typeof iterator?.return === 'function') await iterator.return()
   }
 }
 
@@ -102,7 +66,7 @@ function requestArgs(request) {
   return { request }
 }
 
-// The RC.1 SessionController intentionally names its reserved list argument
+// The 0.1.5-rc.2 SessionController names its reserved list argument
 // `_request`. Typert descriptors preserve that source parameter name exactly,
 // so this endpoint cannot share the normal `{ request }` wrapper.
 function sessionListArgs(request) {
@@ -134,10 +98,7 @@ export function createDshHostAdapter(typertGateway) {
       requestArgs(request),
       signal,
     ), 'session/follow')
-    if (frame.type !== 'snapshot' || !Number.isSafeInteger(frame.cursor)) {
-      throw new Error('session/follow returned an invalid opening snapshot')
-    }
-    return frame
+    return readSessionSnapshot(frame, request.address.sessionId)
   }
 
   const history = async (payload, signal) => {
@@ -146,8 +107,8 @@ export function createDshHostAdapter(typertGateway) {
       ...(payload.maxMessages === undefined ? {} : { maxMessages: payload.maxMessages }),
     }
     const snapshot = await sessionSnapshot(request, signal)
-    let records = snapshot.records
-    let hasMore = snapshot.hasMore === true
+    let events = snapshot.events
+    let hasMore = snapshot.hasMore
     if (payload.beforeSeq !== undefined) {
       const page = requireRecord(await invoke('session', 'page', requestArgs({
         address: request.address,
@@ -155,13 +116,13 @@ export function createDshHostAdapter(typertGateway) {
         beforeSeq: payload.beforeSeq,
         ...(payload.maxMessages === undefined ? {} : { maxMessages: payload.maxMessages }),
       }), signal), 'session/page')
-      records = page.records
+      events = readHistoryRecords(page.records).map(event => ({ event }))
       hasMore = page.hasMore === true
     }
     return {
-      events: expandHistoryRecords(records).map(event => ({ event })),
+      ...snapshot,
+      events,
       hasMore,
-      projections: requireRecord(snapshot.projections, 'session/follow projections'),
     }
   }
 
@@ -172,10 +133,13 @@ export function createDshHostAdapter(typertGateway) {
 
   const commands = {
     list: (sessionId, signal) => invoke('commands', 'list', { agentId: sessionId }, signal),
-    execute: (sessionId, line, images, signal) => invoke(
+    // DSH 0.1.5-rc.2 accepts `submittedAttachments`. The parsed
+    // wire images already carry the { type: 'image', ... } shape it expects, so
+    // only the field name changes.
+    execute: (sessionId, line, attachments, signal) => invoke(
       'commands',
       'execute',
-      { agentId: sessionId, line, images },
+      { agentId: sessionId, line, submittedAttachments: attachments },
       signal,
     ),
   }
@@ -196,6 +160,8 @@ export function createDshHostAdapter(typertGateway) {
     ])
     return {
       version: 'remote-gateway',
+      dshVersion: DSH_VERSION,
+      historyFormatVersion: SESSION_FORMAT_VERSION,
       cwd: os.homedir(),
       attachedSessions: Array.isArray(sessions?.items) ? sessions.items.length : 0,
       canOpenPath: canOpenPath === true,
@@ -301,6 +267,13 @@ export function createDshHostAdapter(typertGateway) {
       describe: (_payload = {}, signal) => describeHost(signal),
     },
     describeHost,
+    openSessionStream(sessionId, signal) {
+      return typertGateway.stream({
+        namespace: 'session', method: 'follow',
+        args: requestArgs({ address: { kind: 'session', sessionId }, assistantStream: true }),
+        signal,
+      })
+    },
     openControlStream(signal) {
       return typertGateway.stream({ namespace: 'session', method: 'control', args: {}, signal })
     },

package/lib/gateway-state.mjs

@@ -0,0 +1,57 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import crypto from 'node:crypto'
+
+export const GATEWAY_MODES = ['disabled', 'temporary', 'persistent']
+
+// A dedicated file keeps installation identity independent of device revocation.
+// A malformed file must fail startup rather than silently replace that identity.
+export function createGatewayState(file) {
+  const validate = (value) => {
+    if (!value || value.version !== 1 ||
+        typeof value.gatewayId !== 'string' ||
+        !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(value.gatewayId) ||
+        (value.mode !== null && !GATEWAY_MODES.includes(value.mode))) {
+      throw new Error('invalid gateway identity or mode')
+    }
+    return value
+  }
+  const read = () => validate(JSON.parse(fs.readFileSync(file, 'utf8')))
+  const write = (value, initial = false) => {
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 })
+    const tmp = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`
+    try {
+      fs.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600, flag: 'wx' })
+      if (initial) fs.linkSync(tmp, file) // Never overwrite a concurrently created identity.
+      else fs.renameSync(tmp, file)
+    } finally {
+      fs.rmSync(tmp, { force: true })
+    }
+  }
+  let state
+  try {
+    try {
+      state = read()
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error
+      state = { version: 1, gatewayId: crypto.randomUUID(), mode: null }
+      try { write(state, true) } catch (cause) {
+        if (cause.code !== 'EEXIST') throw cause
+        state = read()
+      }
+    }
+    fs.chmodSync(file, 0o600)
+  } catch (error) {
+    throw new Error(`failed to load gateway state ${file}: ${error.message}`, { cause: error })
+  }
+  return {
+    get gatewayId() { return state.gatewayId },
+    get mode() { return state.mode },
+    setMode(mode) {
+      if (!GATEWAY_MODES.includes(mode)) throw new TypeError('invalid gateway mode')
+      const next = { ...state, mode }
+      write(next)
+      state = next
+    },
+  }
+}