dsh-plugin-mobile-gateway 0.7.6 → 0.8.1

package/lib/index.mjs

@@ -132,6 +132,8 @@ import devicesModule from './devices.js'
 import { createDshHostAdapter, DSH_VERSION, SESSION_FORMAT_VERSION } from './dsh-host-adapter.mjs'
 import { createSessionFollower } from './session-follower.mjs'
 import { createGatewayState, GATEWAY_MODES } from './gateway-state.mjs'
+import { createCloudflareTunnel } from './cloudflare-tunnel.mjs'
+import { webRestartAvailable, prepareWebRestart } from './gateway-tools.mjs'
 import QRCode from 'qrcode'
 
 const { createRegistry } = devicesModule
@@ -225,6 +227,9 @@ const Config = Schema.object({
   lanHost: Schema.string().default('0.0.0.0'),
   lanPort: Schema.natural().min(1).max(65535).default(3081),
   lanAdvertiseHost: Schema.string().default(''),
+  cloudflaredPath: Schema.string().default('cloudflared'),
+  cloudflarePort: Schema.natural().min(1).max(65535).default(3082),
+  cloudflareStateFile: Schema.string().default(''),
 })
 
 function log(line) {
@@ -323,7 +328,8 @@ function buildWireEvent(session, event) {
     case 'tool/result': {
       let preview = ''
       for (const block of (d.message && d.message.content) || []) {
-        for (const inner of (block && block.content) || []) {
+        const content = block?.type === 'tool-result' ? block.content || [] : [block]
+        for (const inner of content) {
           if (inner.type === 'text' && typeof inner.text === 'string') preview += inner.text
         }
       }
@@ -333,9 +339,10 @@ function buildWireEvent(session, event) {
           type: 'tool/result',
           turn: d.turn,
           step: d.step,
-          callId: d.message && d.message.source && d.message.source.callId,
-          isError: !!d.error || ((d.message && d.message.content) || []).some(block => block?.type === 'tool-result' && block.isError === true),
+          callId: d.message?.toolCallId ?? d.message?.source?.callId,
+          isError: d.message?.isError === true || !!d.error || ((d.message && d.message.content) || []).some(block => block?.type === 'tool-result' && block.isError === true),
           preview,
+          ...(d.error ? { error: d.error } : {}),
         },
       })
     }
@@ -1122,7 +1129,7 @@ function validateHistoryCursor(msg, sessionId, field) {
   if (msg.historyFormatVersion !== SESSION_FORMAT_VERSION) {
     return { kind: 'error', code: 'history-format-mismatch', requestType: msg.type, sessionId,
       historyFormatVersion: SESSION_FORMAT_VERSION, resetRequired: true,
-      message: 'Reload the Session baseline before using a history or fork cursor; historyFormatVersion must be 3' }
+      message: `Reload the Session baseline before using a history or fork cursor; historyFormatVersion must be ${SESSION_FORMAT_VERSION}` }
   }
   if (msg[field] !== undefined && (!Number.isSafeInteger(msg[field]) || msg[field] < 0)) {
     return { kind: 'error', code: 'bad-request', requestType: msg.type, sessionId,
@@ -1220,7 +1227,9 @@ async function loadCommandOptions(api, command, sessionId) {
     const history = await proxyQuery(api, 'history', api.sessions.history.bind(api.sessions), { sessionId })
     if (history.kind !== 'history') return history
     const permissions = history.projections && history.projections.values && history.projections.values.permissions
-    if (!permissions || !Array.isArray(permissions.options) || typeof permissions.currentValue !== 'string') {
+    const catalog = await proxyQuery(api, 'permission-catalog', api.permissionPresets.catalog.bind(api.permissionPresets), {})
+    if (catalog.kind === 'error') return catalog
+    if (!permissions || typeof permissions.currentValue !== 'string' || !Array.isArray(catalog.options)) {
       return {
         kind: 'error',
         code: 'command-options-unavailable',
@@ -1233,7 +1242,7 @@ async function loadCommandOptions(api, command, sessionId) {
       kind: 'command-options',
       sessionId,
       command,
-      options: permissions.options.map((option) => ({
+      options: catalog.options.map((option) => ({
         id: String(option.value),
         label: String(option.name || option.value),
         ...(option.description ? { description: String(option.description) } : {}),
@@ -1660,11 +1669,18 @@ async function handleQuery(api, host, agentDefaultModel, msg) {
     return proxyQuery(api, 'select-model', api.sessions.selectModel.bind(api.sessions), payload)
   }
   if (msg.type === 'permission-options') {
-    const frame = await proxyQuery(api, 'permission-options', api.settings.describe.bind(api.settings), {})
+    const [frame, catalog] = await Promise.all([
+      proxyQuery(api, 'permission-options', api.settings.describe.bind(api.settings), {}),
+      proxyQuery(api, 'permission-catalog', api.permissionPresets.catalog.bind(api.permissionPresets), {}),
+    ])
     if (frame.kind !== 'permission-options') return frame
+    if (catalog.kind === 'error') return catalog
     const out = {
       kind: 'permission-options',
       namespace: (frame.namespaces || []).find((n) => n.ns === 'permission') || null,
+      options: catalog.options,
+      defaultOptions: catalog.defaultOptions,
+      defaultPreset: catalog.defaultPreset,
     }
     const sessionId = typeof msg.sessionId === 'string' && msg.sessionId.trim() !== '' ? msg.sessionId.trim() : null
     if (sessionId) {
@@ -1672,7 +1688,8 @@ async function handleQuery(api, host, agentDefaultModel, msg) {
       const hist = await querySessionProjection(api, msg.type, sessionId)
       if (hist.kind === 'error') return hist
       if (hist.kind === 'history' && hist.projections && hist.projections.values) {
-        out.sessionPermissions = hist.projections.values.permissions || null
+        const current = hist.projections.values.permissions
+        out.sessionPermissions = current ? { ...current, options: catalog.options } : null
       }
     }
     return out
@@ -1777,18 +1794,66 @@ async function handleQuery(api, host, agentDefaultModel, msg) {
     const method = msg.type === 'goal-pause' ? 'pause' : msg.type === 'goal-resume' ? 'resume' : 'clear'
     return mutateGoal(api, msg.type, method, { sessionId: sessionId.value, ref: ref.value })
   }
+  if (msg.type === 'schedule-catalog') {
+    return proxyQuery(api, msg.type, api.schedule.catalog.bind(api.schedule), {})
+  }
+  if (msg.type === 'schedule-list' || msg.type === 'schedule-history' ||
+      msg.type === 'schedule-update' || msg.type === 'schedule-delete') {
+    const sessionId = requireSessionId(msg)
+    if (sessionId.error) return sessionId.error
+    const requestId = typeof msg.requestId === 'string' && msg.requestId.trim() ? { requestId: msg.requestId } : {}
+    const payload = { sessionId: sessionId.value }
+    if (msg.type !== 'schedule-list') {
+      if (typeof msg.id !== 'string' || !msg.id.trim()) {
+        return { kind: 'error', code: 'bad-request', message: `${msg.type} requires an id`, requestType: msg.type, sessionId: sessionId.value, ...requestId }
+      }
+      payload.id = msg.id.trim()
+    }
+    if (msg.type === 'schedule-history') {
+      if (!Number.isSafeInteger(msg.limit) || msg.limit < 1 || msg.limit > 100 ||
+          (msg.before !== undefined && (typeof msg.before !== 'string' || !msg.before.trim()))) {
+        return { kind: 'error', code: 'bad-request', message: 'schedule-history requires limit 1..100 and an optional non-empty before cursor', requestType: msg.type, sessionId: sessionId.value, ...requestId }
+      }
+      payload.limit = msg.limit
+      if (msg.before !== undefined) payload.before = msg.before
+    }
+    if (msg.type === 'schedule-update') {
+      if (!msg.expected || typeof msg.expected !== 'object' || Array.isArray(msg.expected) || msg.expected.id !== payload.id) {
+        return { kind: 'error', code: 'bad-request', message: 'schedule-update requires the complete expected record with a matching id', requestType: msg.type, sessionId: sessionId.value, ...requestId }
+      }
+      // Catalog rows add Host management metadata. The Remote update contract
+      // requires the original ScheduleRecord only.
+      payload.expected = Object.fromEntries(
+        ['id', 'kind', 'title', 'prompt', 'scheduledAt', 'afterSeconds', 'everySeconds', 'time', 'timeZone', 'weekdays', 'expression']
+          .filter((field) => Object.hasOwn(msg.expected, field))
+          .map((field) => [field, msg.expected[field]]),
+      )
+      for (const field of ['title', 'prompt']) {
+        if (msg[field] !== undefined) payload[field] = msg[field]
+      }
+      if (msg.change !== undefined) payload.change = msg.change
+    }
+    const method = msg.type.slice('schedule-'.length)
+    const frame = await proxyQuery(api, msg.type, api.schedule[method].bind(api.schedule), payload)
+    return { ...frame, sessionId: sessionId.value, ...requestId }
+  }
   if (msg.type === 'agent-presets') {
     return proxyQuery(api, 'agent-presets', api.agentPresets.list.bind(api.agentPresets), {})
   }
   if (msg.type === 'defaults') {
-    const frame = await proxyQuery(api, 'defaults', api.settings.describe.bind(api.settings), {})
-    if (frame.kind !== 'defaults') return frame
-    const agentPresetNs = (frame.namespaces || []).find((n) => n.ns === 'agent-presets')
-    const permissionNs = (frame.namespaces || []).find((n) => n.ns === 'permission')
+    const [presets, catalog] = await Promise.all([
+      proxyQuery(api, 'agent-presets', api.agentPresets.list.bind(api.agentPresets), {}),
+      proxyQuery(api, 'permission-catalog', api.permissionPresets.catalog.bind(api.permissionPresets), {}),
+    ])
+    if (presets.kind === 'error') return presets
+    if (catalog.kind === 'error') return catalog
     return {
       kind: 'defaults',
-      agentPresetDefault: agentPresetNs && agentPresetNs.value && agentPresetNs.value.default !== undefined ? agentPresetNs.value.default : null,
-      permissionDefault: permissionNs && permissionNs.value && permissionNs.value.defaultPreset !== undefined ? permissionNs.value.defaultPreset : null,
+      agentPresetDefault: presets.presets?.find((preset) => preset.isDefault)?.id ?? null,
+      permissionDefault: catalog.defaultPreset ?? null,
+      permissionDefaultOptions: catalog.defaultOptions ?? [],
+      // rc.2 removed this roster flag; only an explicit older-host false disables selection.
+      modeSelectionEnabled: presets.modeSelectionEnabled !== false,
     }
   }
   if (msg.type === 'set-default') {
@@ -1800,8 +1865,21 @@ async function handleQuery(api, host, agentDefaultModel, msg) {
     if (!value) {
       return { kind: 'error', code: 'bad-request', message: 'set-default requires a value', requestType: 'set-default' }
     }
-    const ns = target === 'agent-preset' ? 'agent-presets' : 'permission'
-    const patch = target === 'agent-preset' ? { default: value } : { defaultPreset: value }
+    const catalog = target === 'agent-preset'
+      ? await proxyQuery(api, 'agent-presets', api.agentPresets.list.bind(api.agentPresets), {})
+      : await proxyQuery(api, 'permission-catalog', api.permissionPresets.catalog.bind(api.permissionPresets), {})
+    if (catalog.kind === 'error') return catalog
+    if (target === 'agent-preset' && catalog.modeSelectionEnabled === false) {
+      return { kind: 'error', code: 'mode-selection-disabled', message: 'Agent mode selection is disabled', requestType: 'set-default' }
+    }
+    const choices = target === 'agent-preset'
+      ? catalog.presets?.filter((preset) => !preset.broken).map((preset) => preset.id)
+      : catalog.defaultOptions?.map((option) => option.value)
+    if (!choices?.includes(value)) {
+      return { kind: 'error', code: 'bad-request', message: 'default value is not available', requestType: 'set-default' }
+    }
+    const ns = target === 'agent-preset' ? 'agent-preset-registry' : 'permission'
+    const patch = target === 'agent-preset' ? { selectedDefault: value } : { defaultPreset: value }
     const updated = await proxyQuery(api, 'set-default', api.settings.update.bind(api.settings), { ns, patch })
     if (updated.kind !== 'set-default') return updated
     log(`default updated: ${ns}.${Object.keys(patch)[0]} = ${value}`)
@@ -2075,6 +2153,9 @@ const plugin = {
       lanHost: '0.0.0.0',
       lanPort: 3081,
       lanAdvertiseHost: '',
+      cloudflaredPath: 'cloudflared',
+      cloudflarePort: 3082,
+      cloudflareStateFile: '',
       ...(config || {}),
     }
     const wsPath = options.path
@@ -2087,6 +2168,9 @@ const plugin = {
     if (options.lanEnabled === true && options.lanAdvertiseHost && !isPrivateNetworkHostname(options.lanAdvertiseHost)) {
       throw new Error('mobile-gateway: lanAdvertiseHost must be localhost or a private LAN address')
     }
+    if (typeof options.cloudflaredPath !== 'string' || !options.cloudflaredPath.trim()) {
+      throw new Error('mobile-gateway: cloudflaredPath must be a nonempty executable path')
+    }
     let requireAuth = options.requireAuth !== false
     const adminLoopbackOnly = options.adminLoopbackOnly !== false
     const deviceFile = options.deviceFile || path.join(os.homedir(), '.dsh', 'mobile-gateway-devices.json')
@@ -2136,6 +2220,7 @@ const plugin = {
     let lanListening = false
     let lanListenError = null
     let lanBoundPort = options.lanPort
+    let tunnel = null
     const configuredPublicUrl = () => {
       if (typeof options.publicUrl === 'string' && options.publicUrl.trim()) return options.publicUrl.trim()
       if (typeof options.publicUrlFile !== 'string' || !options.publicUrlFile.trim()) return ''
@@ -2157,6 +2242,7 @@ const plugin = {
         ...extra,
         ...configuredEndpoints,
         ...(publicUrl ? [publicUrl] : []),
+        ...(tunnel?.snapshot().publicUrl ? [tunnel.snapshot().publicUrl] : []),
         ...(lanListening ? lanWebSocketUrls(options, wsPath, lanBoundPort) : []),
       ])])
     }
@@ -2183,11 +2269,13 @@ const plugin = {
             log(`failed to persist automatic gateway disable: ${error.message}`)
           }
           log('mobile gateway automatically disabled: no device connected before timeout')
+          void tunnel?.reconcile()
         }, options.gatewayWaitTimeoutMs)
       } else if (mode === 'disabled') {
         for (const client of clients) client.close(4004, 'mobile gateway disabled')
       }
       log(`mobile gateway mode=${mode}${reason ? `: ${reason}` : ''}`)
+      void tunnel?.reconcile()
     }
 
     const logAuthRejected = (req) => {
@@ -2221,6 +2309,7 @@ const plugin = {
       toolName: payload.toolName,
       ...(payload.callId !== undefined ? { callId: payload.callId } : {}),
       ...(payload.reason !== undefined ? { reason: payload.reason } : {}),
+      ...(payload.displayReason !== undefined ? { displayReason: payload.displayReason } : {}),
       ...(replay ? { replay: true } : {}),
     })
 
@@ -2245,20 +2334,43 @@ const plugin = {
     }
 
     const replayPendingInteractions = (ws, trigger) => {
-      if (ws.mobileChannel === 'conversation') return { questionCount: 0, approvalCount: 0 }
+      // In split-channel mode `subscribe` belongs to the conversation socket,
+      // while interaction frames belong to the control socket. Bridge a
+      // conversation subscription to every live control/legacy socket so
+      // reopening a Session restores its still-pending cards. Reducers dedupe
+      // by rpcId, so replaying to another trusted device is harmless and keeps
+      // all active clients in sync.
+      // The companion control socket already receives a full replay when it
+      // connects, so a bare conversation connect must not duplicate it again.
+      if (ws.mobileChannel === 'conversation' && trigger !== 'subscribe') {
+        return { questionCount: 0, approvalCount: 0 }
+      }
+      const recipients = ws.mobileChannel === 'conversation'
+        ? [...clients].filter((client) => client.readyState === 1 && client.mobileChannel !== 'conversation')
+        : [ws]
+      if (recipients.length === 0) return { questionCount: 0, approvalCount: 0 }
+      const sessionId = ws.filterSessionId
       let questionCount = 0
       let approvalCount = 0
       for (const pending of pendingQuestions.values()) {
-        if (ws.filterSessionId && ws.filterSessionId !== pending.sessionId) continue
-        ws.send(stringifyWireFrame(questionFrameFor(pending.rpcId, pending, true)))
+        if (sessionId && sessionId !== pending.sessionId) continue
+        const wire = stringifyWireFrame(questionFrameFor(pending.rpcId, pending, true))
+        for (const recipient of recipients) {
+          if (recipient.filterSessionId && recipient.filterSessionId !== pending.sessionId) continue
+          recipient.send(wire)
+        }
         questionCount += 1
       }
       for (const pending of pendingApprovals.values()) {
-        if (ws.filterSessionId && ws.filterSessionId !== pending.sessionId) continue
-        ws.send(stringifyWireFrame(approvalFrameFor(pending.rpcId, pending, true)))
+        if (sessionId && sessionId !== pending.sessionId) continue
+        const wire = stringifyWireFrame(approvalFrameFor(pending.rpcId, pending, true))
+        for (const recipient of recipients) {
+          if (recipient.filterSessionId && recipient.filterSessionId !== pending.sessionId) continue
+          recipient.send(wire)
+        }
         approvalCount += 1
       }
-      log(`interaction replay: trigger=${trigger} filtered=${Boolean(ws.filterSessionId)} questions=${questionCount} approvals=${approvalCount}`)
+      log(`interaction replay: trigger=${trigger} channel=${ws.mobileChannel} filtered=${Boolean(sessionId)} recipients=${recipients.length} questions=${questionCount} approvals=${approvalCount}`)
       return { questionCount, approvalCount }
     }
 
@@ -2268,15 +2380,24 @@ const plugin = {
       && (!client.filterSessionId || client.filterSessionId === sessionId)
     ))
 
-    const completeQuestion = (pending, action, answer, cancellationCode = 'ASK_CANCELLED') => {
+    const abortDownstreamInteraction = (pending, kind) => {
+      if (pending.downstreamAbort.signal.aborted) return
+      // The Host API gateway fans this abort out to every WebUI delivery of
+      // the same Remote event. Its existing cancel handling removes each
+      // pending BottomSheet; Mobile peers receive the resolved frame below.
+      pending.downstreamAbort.abort(new Error(`${kind} completed outside WebUI`))
+    }
+
+    const completeQuestion = (pending, action, answer, cancellationCode = 'ASK_CANCELLED', cancellationError, source = 'mobile') => {
       if (pendingQuestions.get(pending.rpcId) !== pending) return false
       pendingQuestions.delete(pending.rpcId)
       pending.cleanup()
+      if (source !== 'downstream') abortDownstreamInteraction(pending, 'question')
       if (action === 'answer') pending.resolve(answer)
       else {
-        const error = new Error('question cancelled by mobile user')
-        error.name = 'UserQuestionError'
-        error.code = cancellationCode
+        const error = cancellationError ?? new Error('question cancelled by mobile user')
+        if (!error.name || error.name === 'Error') error.name = 'UserQuestionError'
+        if (!error.code) error.code = cancellationCode
         pending.reject(error)
       }
       broadcastInteractionFrame({
@@ -2315,10 +2436,11 @@ const plugin = {
       return { value: { answers: normalized } }
     }
 
-    const completeApproval = (pending, outcome) => {
+    const completeApproval = (pending, outcome, source = 'mobile') => {
       if (pendingApprovals.get(pending.rpcId) !== pending) return false
       pendingApprovals.delete(pending.rpcId)
       pending.cleanup()
+      if (source !== 'downstream') abortDownstreamInteraction(pending, 'approval')
       pending.resolve(outcome)
       broadcastInteractionFrame({
         kind: 'approval-resolved',
@@ -2330,18 +2452,80 @@ const plugin = {
       return true
     }
 
+    const startDownstreamQuestion = (pending) => {
+      let downstream
+      try {
+        downstream = pending.next()
+      } catch (error) {
+        pending.downstream = { kind: 'rejected', error }
+        return
+      }
+      pending.downstream = { kind: 'pending' }
+      Promise.resolve(downstream).then((answer) => {
+        if (pendingQuestions.get(pending.rpcId) !== pending) return
+        if (answer && Array.isArray(answer.answers)) {
+          completeQuestion(pending, 'answer', answer, undefined, undefined, 'downstream')
+          log(`question resolved by downstream answerer: rpcId=${pending.rpcId} session=${pending.sessionId}`)
+        } else {
+          // A downstream answerer may report that no WebUI currently owns the
+          // request. Keep Mobile active; the value is used only if every Mobile
+          // client later disconnects.
+          pending.downstream = { kind: 'unavailable', value: answer }
+          if (!hasInteractionClient(pending.sessionId)) fallbackQuestion(pending)
+        }
+      }, (error) => {
+        if (pendingQuestions.get(pending.rpcId) !== pending) return
+        if (error?.code === 'ASK_CANCELLED' || error?.code === 'ASK_ABORTED') {
+          completeQuestion(pending, 'cancel', undefined, error.code, error, 'downstream')
+          log(`question cancelled by downstream answerer: rpcId=${pending.rpcId} session=${pending.sessionId}`)
+        } else {
+          pending.downstream = { kind: 'rejected', error }
+          if (!hasInteractionClient(pending.sessionId)) fallbackQuestion(pending)
+        }
+      })
+    }
+
+    const startDownstreamApproval = (pending) => {
+      let downstream
+      try {
+        downstream = pending.next()
+      } catch (error) {
+        pending.downstream = { kind: 'rejected', error }
+        return
+      }
+      pending.downstream = { kind: 'pending' }
+      Promise.resolve(downstream).then((outcome) => {
+        if (pendingApprovals.get(pending.rpcId) !== pending) return
+        if (outcome === 'allowed-once' || outcome === 'rejected') {
+          completeApproval(pending, outcome, 'downstream')
+          log(`approval resolved by downstream answerer: rpcId=${pending.rpcId} session=${pending.sessionId} outcome=${outcome}`)
+        } else {
+          pending.downstream = { kind: 'unavailable', value: outcome }
+          if (!hasInteractionClient(pending.sessionId)) fallbackApproval(pending)
+        }
+      }, (error) => {
+        if (pendingApprovals.get(pending.rpcId) !== pending) return
+        pending.downstream = { kind: 'rejected', error }
+        if (!hasInteractionClient(pending.sessionId)) fallbackApproval(pending)
+      })
+    }
+
     const fallbackQuestion = (pending) => {
       if (pendingQuestions.get(pending.rpcId) !== pending) return
+      if (pending.downstream?.kind === 'pending') return
       pendingQuestions.delete(pending.rpcId)
       pending.cleanup()
-      Promise.resolve().then(pending.next).then(pending.resolve, pending.reject)
+      if (pending.downstream?.kind === 'rejected') pending.reject(pending.downstream.error)
+      else pending.resolve(pending.downstream?.value)
     }
 
     const fallbackApproval = (pending) => {
       if (pendingApprovals.get(pending.rpcId) !== pending) return
+      if (pending.downstream?.kind === 'pending') return
       pendingApprovals.delete(pending.rpcId)
       pending.cleanup()
-      Promise.resolve().then(pending.next).then(pending.resolve, pending.reject)
+      if (pending.downstream?.kind === 'rejected') pending.reject(pending.downstream.error)
+      else pending.resolve(pending.downstream?.value)
     }
 
     const releaseUnclaimedInteractions = () => {
@@ -2425,6 +2609,7 @@ const plugin = {
     log(`applying: version=${PLUGIN_VERSION} interactionProtocol=${INTERACTION_PROTOCOL_REVISION} path=${wsPath}, webServer.port=${webServer.port}, gatewayEnabled=${gatewayEnabled}, requireAuth=${requireAuth}, devices=${registry.count()}`)
 
     // ---- device management routes (loopback-gated admin surface) ----
+    let restartPending = false
     const disposeMgmt = webServer.register({
       kind: 'prefix',
       path: '/mgw',
@@ -2441,6 +2626,7 @@ const plugin = {
           const url = new URL(req.url || '/', 'http://x')
           const p = url.pathname
           if (req.method === 'GET' && p === '/mgw/status') {
+            const profile = ctx.get?.('profileContext')
             sendJson(res, 200, {
               version: PLUGIN_VERSION,
               requireAuth,
@@ -2451,8 +2637,13 @@ const plugin = {
               waitExpiresAt,
               connectedClients: clients.size,
               webPort: webServer.port,
+              webPid: process.pid,
               wsPath,
-              publicUrl: configuredPublicUrl() || null,
+              publicUrl: tunnel?.snapshot().enabled && tunnel.snapshot().mode === 'quick'
+                ? tunnel.snapshot().publicUrl
+                : tunnel?.snapshot().publicUrl || configuredPublicUrl() || null,
+              platform: process.platform,
+              cloudflare: tunnel?.snapshot() || null,
               lan: {
                 enabled: options.lanEnabled === true,
                 listening: lanListening,
@@ -2464,7 +2655,49 @@ const plugin = {
               },
               pairingTtlMs: options.pairingTtlMs,
               queryTokenAllowed: !!options.allowQueryToken,
+              tools: {
+                restartWeb: webRestartAvailable(profile),
+                stopWeb: webRestartAvailable(profile),
+              },
             })
+          } else if (req.method === 'POST' && p === '/mgw/tools/restart-web') {
+            if (!isLoopback(req)) {
+              sendJson(res, 403, { error: 'forbidden', message: 'Web restart is loopback-only' })
+              return
+            }
+            if (!webRestartAvailable(ctx.get?.('profileContext'))) {
+              sendJson(res, 409, { error: 'unavailable', message: '只能在通过 dsh web 启动的 Web profile 中重启' })
+              return
+            }
+            if (restartPending) {
+              sendJson(res, 409, { error: 'restart-pending', message: 'DSH Web 正在重启' })
+              return
+            }
+            restartPending = true
+            try {
+              await prepareWebRestart()
+            } catch (error) {
+              restartPending = false
+              throw error
+            }
+            res.once('finish', () => setTimeout(() => process.kill(process.pid, 'SIGTERM'), 100))
+            sendJson(res, 202, { restarting: true })
+          } else if (req.method === 'POST' && p === '/mgw/tools/stop-web') {
+            if (!isLoopback(req)) {
+              sendJson(res, 403, { error: 'forbidden', message: 'Web shutdown is loopback-only' })
+              return
+            }
+            if (!webRestartAvailable(ctx.get?.('profileContext'))) {
+              sendJson(res, 409, { error: 'unavailable', message: '只能停止通过 dsh web 启动的 Web profile' })
+              return
+            }
+            if (restartPending) {
+              sendJson(res, 409, { error: 'restart-pending', message: 'DSH Web 正在重启或停止' })
+              return
+            }
+            restartPending = true
+            res.once('finish', () => setTimeout(() => process.kill(process.pid, 'SIGTERM'), 100))
+            sendJson(res, 202, { stopping: true })
           } else if (req.method === 'GET' && p === '/mgw/public-setup') {
             sendJson(res, 200, await systemHelperStatus())
           } else if (req.method === 'POST' && p === '/mgw/public-setup') {
@@ -2483,6 +2716,12 @@ const plugin = {
             if (body.mode === undefined && typeof body.enabled !== 'boolean') throw badRequest('mode or boolean enabled is required')
             setGatewayMode(body.mode !== undefined ? body.mode : (body.enabled ? 'temporary' : 'disabled'), 'changed from management UI')
             sendJson(res, 200, { gatewayEnabled, gatewayMode, waitExpiresAt, connectedClients: clients.size })
+          } else if (req.method === 'POST' && p === '/mgw/cloudflare') {
+            const body = await readBody(req)
+            await tunnel.configure(body)
+            if (body.enabled && gatewayMode !== 'persistent') setGatewayMode('persistent', 'Cloudflare Tunnel enabled from management UI')
+            await tunnel.reconcile()
+            sendJson(res, 200, { ...tunnel.snapshot(), gatewayEnabled, gatewayMode })
           } else if (req.method === 'POST' && p === '/mgw/auth') {
             const body = await readBody(req)
             if (typeof body.enabled !== 'boolean') throw badRequest('enabled must be a boolean')
@@ -2703,7 +2942,9 @@ const plugin = {
                        msg.type === 'save-default-model' || msg.type === 'fork' || msg.type === 'session-cancel' || msg.type === 'queue-update' ||
                        msg.type === 'session-archive' || msg.type === 'session-rename' || msg.type === 'providers' ||
                        msg.type === 'tasks' || msg.type === 'goal' || msg.type === 'goal-edit' ||
-                       msg.type === 'goal-pause' || msg.type === 'goal-resume' || msg.type === 'goal-clear') {
+                       msg.type === 'goal-pause' || msg.type === 'goal-resume' || msg.type === 'goal-clear' ||
+                       msg.type === 'schedule-catalog' || msg.type === 'schedule-list' || msg.type === 'schedule-history' ||
+                       msg.type === 'schedule-update' || msg.type === 'schedule-delete') {
               handleQuery(api, host, agentDefaultModel, msg).then((frame) => {
                 if (frame && ws.readyState === 1) ws.send(stringifyWireFrame(frame))
               })
@@ -2749,6 +2990,7 @@ const plugin = {
               'commands',
               'tasks',
               'goals',
+              'schedule-management',
               'session-cancel',
               'queue-control',
               'session-archive',
@@ -2822,6 +3064,18 @@ const plugin = {
       })
     }
 
+    tunnel = createCloudflareTunnel({
+      file: options.cloudflareStateFile || `${deviceFile}.cloudflare.json`,
+      port: options.cloudflarePort,
+      wsPath,
+      executable: options.cloudflaredPath,
+      supported: process.platform === 'darwin' || process.platform === 'win32',
+      isGatewayEnabled: () => gatewayEnabled,
+      onUpgrade: handleMobileUpgrade,
+      log,
+    })
+    void tunnel.reconcile()
+
     const disposeEvents = ctx.on('session/event', (session, event) => {
       api.observeSessionEvent(String(session.id), event)
       if (clients.size === 0) return
@@ -2852,27 +3106,39 @@ const plugin = {
     })
     log('session/event listener attached')
 
+    // The Host notification has no payload: readers refetch the task catalog.
+    const disposeScheduleChanged = ctx.on('schedule/changed', () => {
+      if (clients.size > 0) broadcastSessionMetadataFrame({ kind: 'schedule-changed' })
+    })
+
     const disposeQuestions = ctx.on('user-questions/request', (request, next) => {
       const sessionId = request?.agent?.id === undefined ? null : String(request.agent.id)
       if (!sessionId || !Array.isArray(request.questions) || !hasInteractionClient(sessionId)) return next()
       const rpcId = crypto.randomUUID()
       return new Promise((resolve, reject) => {
+        const requestSignal = request.signal
+        const downstreamAbort = new AbortController()
+        request.signal = requestSignal
+          ? AbortSignal.any([requestSignal, downstreamAbort.signal])
+          : downstreamAbort.signal
         const onAbort = () => {
           const pending = pendingQuestions.get(rpcId)
           if (pending) completeQuestion(pending, 'cancel', undefined, 'ASK_ABORTED')
         }
-        request.signal?.addEventListener('abort', onAbort, { once: true })
+        requestSignal?.addEventListener('abort', onAbort, { once: true })
         const pending = {
           rpcId,
           sessionId,
           questions: request.questions,
           next,
+          downstreamAbort,
           resolve,
           reject,
-          cleanup: () => request.signal?.removeEventListener('abort', onAbort),
+          cleanup: () => requestSignal?.removeEventListener('abort', onAbort),
         }
         pendingQuestions.set(rpcId, pending)
         broadcastInteractionFrame(questionFrameFor(rpcId, pending))
+        startDownstreamQuestion(pending)
         log(`question requested: rpcId=${rpcId} session=${sessionId} questions=${request.questions.length}`)
       })
     }, { prepend: true })
@@ -2883,11 +3149,16 @@ const plugin = {
       const rpcId = crypto.randomUUID()
       const approvalId = crypto.randomUUID()
       return new Promise((resolve, reject) => {
+        const requestSignal = request.signal
+        const downstreamAbort = new AbortController()
+        request.signal = requestSignal
+          ? AbortSignal.any([requestSignal, downstreamAbort.signal])
+          : downstreamAbort.signal
         const onAbort = () => {
           const pending = pendingApprovals.get(rpcId)
           if (pending) completeApproval(pending, 'cancelled')
         }
-        request.signal?.addEventListener('abort', onAbort, { once: true })
+        requestSignal?.addEventListener('abort', onAbort, { once: true })
         const pending = {
           rpcId,
           sessionId,
@@ -2895,13 +3166,16 @@ const plugin = {
           toolName: request.toolName,
           ...(request.callId !== undefined ? { callId: request.callId } : {}),
           ...(request.reason !== undefined ? { reason: request.reason } : {}),
+          ...(request.displayReason !== undefined ? { displayReason: request.displayReason } : {}),
           next,
+          downstreamAbort,
           resolve,
           reject,
-          cleanup: () => request.signal?.removeEventListener('abort', onAbort),
+          cleanup: () => requestSignal?.removeEventListener('abort', onAbort),
         }
         pendingApprovals.set(rpcId, pending)
         broadcastInteractionFrame(approvalFrameFor(rpcId, pending))
+        startDownstreamApproval(pending)
         log(`approval requested: rpcId=${rpcId} approvalId=${approvalId} session=${sessionId} tool=${request.toolName}`)
       })
     }, { prepend: true })
@@ -2931,49 +3205,53 @@ const plugin = {
       log(`session archive state forwarded: count=${next.length}`)
     }
 
-    const normalizeQueueItems = (value, endpoint) => {
-      if (!Array.isArray(value)) throw new Error(`${endpoint} returned invalid queue items`)
-      return value.map((candidate) => {
-        const message = candidate && typeof candidate === 'object' && !Array.isArray(candidate)
-          ? candidate.message
-          : null
-        if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)
-          || typeof candidate.id !== 'string' || !candidate.id
-          || !['queued', 'steering', 'context'].includes(candidate.placement)
-          || !message || typeof message !== 'object' || Array.isArray(message)
+    // DSH rc.1 carries pending messages in the durable inbox projection.
+    // session/control no longer emits a separate queues baseline or queue frames.
+    const queueItemsFromInbox = (value, endpoint) => {
+      if (value == null) return []
+      if (typeof value !== 'object' || Array.isArray(value)
+        || !Array.isArray(value['next-turn']) || !Array.isArray(value['next-step'])) {
+        throw new Error(`${endpoint} returned an invalid inbox projection`)
+      }
+      const convert = (messages, target) => messages.map((message) => {
+        if (!message || typeof message !== 'object' || Array.isArray(message)
           || typeof message.id !== 'string' || !message.id
           || !Array.isArray(message.content)
-          || (candidate.rpcId !== undefined && typeof candidate.rpcId !== 'string')) {
-          throw new Error(`${endpoint} returned an invalid queue item`)
+          || !message.source || typeof message.source.kind !== 'string'
+          || (message.source.rpcId !== undefined && typeof message.source.rpcId !== 'string')) {
+          throw new Error(`${endpoint} returned an invalid inbox message`)
         }
         return {
-          id: candidate.id,
-          placement: candidate.placement,
-          ...(candidate.rpcId === undefined ? {} : { rpcId: candidate.rpcId }),
+          id: message.id,
+          placement: target === 'next-turn' ? 'queued' : message.source.kind === 'user' ? 'steering' : 'context',
+          ...(message.source.rpcId === undefined ? {} : { rpcId: message.source.rpcId }),
           message: { id: message.id, content: message.content },
         }
       })
+      return [...convert(value['next-turn'], 'next-turn'), ...convert(value['next-step'], 'next-step')]
     }
 
-    const installSessionQueueBaseline = (value) => {
-      if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error('session/control baseline returned invalid queues')
+    const installSessionQueueBaseline = (projections) => {
+      if (!projections || typeof projections !== 'object' || Array.isArray(projections)) {
+        throw new Error('session/control baseline returned invalid projections')
       }
       const next = new Map()
-      for (const [sessionId, items] of Object.entries(value)) {
-        next.set(sessionId, normalizeQueueItems(items, 'session/control baseline'))
+      for (const [sessionId, baseline] of Object.entries(projections)) {
+        const items = queueItemsFromInbox(baseline?.values?.inbox, 'session/control baseline')
+        if (items.length > 0) next.set(sessionId, items)
       }
       sessionQueues = next
       broadcastSessionMetadataFrame({ kind: 'session-queues', queues: Object.fromEntries(next) })
       log(`session queue baseline forwarded: sessions=${next.size}`)
     }
 
-    const installSessionQueue = (sessionIdValue, itemsValue) => {
+    const installSessionQueue = (sessionIdValue, inboxValue) => {
       const sessionId = typeof sessionIdValue === 'string' && sessionIdValue ? sessionIdValue : null
       if (!sessionId) throw new Error('session/control returned an invalid queue sessionId')
-      const items = normalizeQueueItems(itemsValue, 'session/control queue')
+      const items = queueItemsFromInbox(inboxValue, 'session/control inbox')
       if (sessionQueues === null) sessionQueues = new Map()
-      sessionQueues.set(sessionId, items)
+      if (items.length > 0) sessionQueues.set(sessionId, items)
+      else sessionQueues.delete(sessionId)
       broadcastSessionMetadataFrame({ kind: 'session-queue', sessionId, items })
       log(`session queue forwarded: session=${sessionId} items=${items.length}`)
     }
@@ -3034,9 +3312,9 @@ const plugin = {
           for await (const frame of stream) {
             if (frame?.type === 'baseline') {
               installProjectionBaseline(frame.value?.projections)
-              installSessionQueueBaseline(frame.value?.queues)
-            } else if (frame?.type === 'queue') {
-              installSessionQueue(frame.sessionId, frame.items)
+              installSessionQueueBaseline(frame.value?.projections)
+            } else if (frame?.type === 'projection' && frame.key === 'inbox') {
+              installSessionQueue(frame.sessionId, frame.value)
             } else if (frame?.type === 'projection' && (frame.key === 'todos' || frame.key === 'goal')) {
               const sessionId = String(frame.sessionId)
               const previous = Object.hasOwn(sessionProjectionBaselines, sessionId) ? sessionProjectionBaselines[sessionId] : null
@@ -3070,9 +3348,11 @@ const plugin = {
       disposeUpgrade()
       disposeMgmt()
       disposeEvents()
+      disposeScheduleChanged()
       disposeQuestions()
       disposeApprovals()
       if (lanServer) lanServer.close()
+      tunnel.dispose()
       for (const client of clients) {
         client.sessionFollower?.stop()
         client.terminate()