dsh-plugin-mobile-gateway 0.4.1 → 0.4.2

package/PROTOCOL.md

@@ -1,8 +1,9 @@
 # dsh Mobile Gateway — WebSocket 协议参考
 
-移动端通过一个经过设备鉴权的 WebSocket 连接与 dsh 通信：订阅 agent 实时输出、发送消息、查询会话/工作区/历史、调整会话配置。本协议由持久化插件 `dsh-plugin-mobile-gateway` 实现（v0.3.0）。
+移动端通过一个经过设备鉴权的 WebSocket 连接与 dsh 通信：订阅 agent 实时输出、发送消息、查询会话/工作区/历史、调整会话配置。本协议由持久化插件 `dsh-plugin-mobile-gateway` 实现（v0.4.2）。
 
 - **本机端点**：`ws://127.0.0.1:3080/ws/mobile`（与 dsh web GUI 同端口）
+- **局域网端点**：`ws://<电脑的私有局域网 IP>:3081/ws/mobile`（插件独立监听，只提供经过鉴权的 WebSocket）
 - **公网端点**：必须由 TLS 反向代理提供 `wss://<域名>/ws/mobile`
 - **帧格式**：全部为 JSON 文本帧（UTF-8）
 - **连接即推送**：连上后服务端立刻发送一条 `hello`，之后 agent 输出以 `event` 帧实时推送
@@ -43,12 +44,12 @@ WebUI 中有两个互相独立的开关。它们是本机管理设置，iOS 客
 |---|---|---|
 | 关闭 | 任意 | WebSocket Upgrade 返回 `503 Service Unavailable` |
 | 开启 | 开启（默认） | 必须使用一次性配对码或长期设备 token，否则返回 `401 Unauthorized` |
-| 开启 | 关闭（仅 Debug） | 允许无凭证连接，`hello.authenticated` 为 `false` |
+| 开启 | 关闭（仅 Debug） | 仅 DSH 本机监听允许无凭证连接，`hello.authenticated` 为 `false`；独立局域网监听仍返回 `401` |
 
 - 移动网关默认关闭。手动开启后，默认 5 分钟内没有客户端成功建立连接就自动关闭。
 - 关闭移动网关会关闭现有连接，WebSocket close code 为 `4004`。
 - 从 Debug 模式重新开启鉴权时，所有无凭证连接会被关闭，close code 为 `4003`。
-- Debug 鉴权开关只在当前 DSH 进程中生效；重启后恢复配置中的 `requireAuth: true`。
+- Debug 鉴权开关只影响 DSH 自带的本机监听，并且只在当前 DSH 进程中生效；独立局域网监听始终强制设备鉴权。
 
 #### 首次配对
 

package/README.md

@@ -24,7 +24,7 @@ dsh plugin --profile web add dsh-plugin-mobile-gateway
 如果希望固定版本，可以在包名后指定版本号：
 
 ```bash
-dsh plugin --profile web add dsh-plugin-mobile-gateway@0.4.1
+dsh plugin --profile web add dsh-plugin-mobile-gateway@0.4.2
 ```
 
 也可以不经过 npm，直接安装 GitHub 版本：
@@ -45,7 +45,19 @@ dsh --profile web --dump-config | grep -A3 mobile-gateway
 
 启动 WebUI 后，左侧边栏底部应出现“移动设备”入口。
 
-### 3. 一条命令配置公网 IP（推荐，无需域名）
+### 3. 局域网直接连接（无需域名、证书或反向代理）
+
+插件安装并重启 `dsh web` 后，会额外创建一个仅用于移动端的局域网监听：
+
+```text
+ws://<运行 DSH 的电脑局域网 IP>:3081/ws/mobile
+```
+
+打开 WebUI 的“移动设备”面板时，插件会自动检测电脑的私有 IPv4，并优先把可用地址填入“WebSocket 地址”。开启移动网关、生成二维码并用 iOS 客户端扫码即可。电脑和手机需要位于可互访的同一局域网；如果系统防火墙询问是否允许 Node 接收入站连接，请允许私有网络访问 TCP `3081`。
+
+该端口只接受来自本机或私有网络地址的 `/ws/mobile` WebSocket Upgrade，不提供 WebUI，也不暴露 `/mgw/*` 管理接口。局域网监听始终要求设备配对鉴权，WebUI 中的 Debug 鉴权开关不会关闭它的鉴权。
+
+### 4. 一条命令配置公网 IP（推荐，无需域名）
 
 如果 Harness 部署在带固定公网 IPv4 的腾讯云 Ubuntu/Debian 服务器上，先在腾讯云安全组中放行入站 TCP `80` 和 `443`，然后在服务器执行：
 
@@ -90,7 +102,7 @@ sudo npx --yes dsh-plugin-mobile-gateway remove
 
 1. 开启“允许移动设备连接”。
 2. 保持“设备鉴权”开启。
-3. 在“公网 WebSocket 地址”中填写手机可以访问的地址。
+3. 在“WebSocket 地址”中填写手机可以访问的地址。
 
 本机浏览器调试可以使用：
 
@@ -98,15 +110,15 @@ sudo npx --yes dsh-plugin-mobile-gateway remove
 ws://127.0.0.1:3080/ws/mobile
 ```
 
-真机不能使用 `127.0.0.1`，因为它在手机上指向手机自身。局域网或公网真机连接应通过 TLS 反向代理提供：
+真机不能使用 `127.0.0.1`，因为它在手机上指向手机自身。同一私有局域网可使用插件自动提供的 `ws://局域网IP:3081/ws/mobile`；公网连接则应通过 TLS 反向代理提供：
 
 ```text
 wss://gateway.example.com/ws/mobile
 ```
 
-非 localhost 的配对地址会强制要求 `wss://`，以免一次性配对信息和长期连接暴露在明文网络中。
+只有 localhost、`.local` 主机名及 RFC 1918/链路本地私有地址允许使用 `ws://`。其他地址会强制要求 `wss://`，以免一次性配对信息和长期连接暴露在公网明文网络中。
 
-### 4. 配对 iOS 客户端
+### 5. 配对 iOS 客户端
 
 1. 在 WebUI 中填写设备名称，例如 `iPhone`。
 2. 点击“生成配对二维码”。
@@ -196,6 +208,10 @@ TLS 证书、域名、防火墙、访问日志保护和代理层速率限制由
     gatewayWaitTimeoutMs: 300000
     requireAuth: true
     adminLoopbackOnly: true
+    lanEnabled: true
+    lanHost: 0.0.0.0
+    lanPort: 3081
+    lanAdvertiseHost: ''
     publicUrl: wss://gateway.example.com/ws/mobile
     publicUrlFile: /etc/dsh-mobile-gateway/public-url
     pairingTtlMs: 300000
@@ -211,7 +227,8 @@ TLS 证书、域名、防火墙、访问日志保护和代理层速率限制由
 | WebUI 没有“移动设备”入口 | 确认使用 `--profile web` 安装；执行 `--dump-config` 检查组合树，然后完整重启 `dsh web` |
 | iOS 连接提示 `503` | 移动网关尚未开启，回到 WebUI 开启“允许移动设备连接” |
 | iOS 连接提示 `401` | 配对码过期、长期凭证无效或设备已被吊销；删除客户端旧凭证后重新配对 |
-| 真机无法连接 `127.0.0.1` | `127.0.0.1` 在手机上不是电脑；配置手机可访问的 `wss://` 地址 |
+| 真机无法连接 `127.0.0.1` | `127.0.0.1` 在手机上不是电脑；局域网使用面板自动显示的 `ws://私有IP:3081/ws/mobile`，公网使用 `wss://` 地址 |
+| 同一 Wi-Fi 仍无法连接局域网地址 | 确认手机与电脑所在网络允许设备互访，并放行电脑入站 TCP 3081；访客 Wi-Fi 通常会启用客户端隔离 |
 | 一键配置无法识别公网 IP | 确认命令运行在腾讯云 CVM 内，或通过 `--ip <公网 IPv4>` 显式指定 |
 | Certbot 申请或续期失败 | 确认腾讯云安全组和服务器防火墙都允许入站 TCP 80/443，并确认公网 IP 没有变化 |
 | 想检查自动续期 | 执行 `sudo systemctl status dsh-mobile-gateway-cert-renew.timer` 和 `sudo npx --yes dsh-plugin-mobile-gateway status` |
@@ -247,6 +264,9 @@ NODE_PATH=/path/to/dsh/node_modules node test/gateway.test.mjs
 
 # 公网 IP 安装器的参数、Nginx 隔离与续期配置
 node test/setup-ip.test.mjs
+
+# 独立局域网监听、强制鉴权与管理接口隔离
+node test/lan.test.mjs
 ```
 
 版本历史与全部 WebSocket 消息类型见 [`PROTOCOL.md`](PROTOCOL.md)。

package/cordis.patch.yml

@@ -13,6 +13,12 @@
         requireAuth: true
         adminLoopbackOnly: true
         pairingTtlMs: 300000
+        # DSH WebUI remains loopback-only on 3080. The plugin owns this
+        # authenticated, WebSocket-only LAN listener for phones on the same
+        # private network.
+        lanEnabled: true
+        lanHost: 0.0.0.0
+        lanPort: 3081
         # Written automatically by `sudo npx dsh-plugin-mobile-gateway setup`.
         publicUrlFile: /etc/dsh-mobile-gateway/public-url
 

package/lib/client.js

@@ -125,6 +125,7 @@ window.__ModuleLoader__.load({
       const [deviceNoticeError, setDeviceNoticeError] = React.useState(false)
       const [revokingIds, setRevokingIds] = React.useState(() => new Set())
       const revokingIdsRef = React.useRef(new Set())
+      const automaticUrlRef = React.useRef('')
 
       const refresh = React.useCallback(async () => {
         try {
@@ -140,7 +141,15 @@ window.__ModuleLoader__.load({
             setDevices((current) => JSON.stringify(current) === JSON.stringify(nextDevices) ? current : nextDevices)
           }
           setStatus((current) => JSON.stringify(current) === JSON.stringify(statusData) ? current : statusData)
-          setPublicUrl((current) => current || statusData.publicUrl || inferredUrl(statusData.wsPath))
+          const lanUrl = statusData.lan && Array.isArray(statusData.lan.urls) ? statusData.lan.urls[0] : ''
+          const preferredUrl = statusData.publicUrl || lanUrl || inferredUrl(statusData.wsPath)
+          setPublicUrl((current) => {
+            if (!current || current === automaticUrlRef.current) {
+              automaticUrlRef.current = preferredUrl
+              return preferredUrl
+            }
+            return current
+          })
           return true
         } catch (cause) {
           setError(cause.message)
@@ -303,7 +312,7 @@ window.__ModuleLoader__.load({
             React.createElement('div', { style: { display: 'flex', justifyContent: 'space-between', gap: 14, alignItems: 'center' } },
               React.createElement('div', null,
                 React.createElement('strong', null, '设备鉴权'),
-                React.createElement('div', { style: { ...styles.muted, marginTop: 4 } }, status && status.requireAuth ? '已开启，仅允许可信设备连接' : '已关闭，仅限 Debug 阶段使用')),
+                React.createElement('div', { style: { ...styles.muted, marginTop: 4 } }, status && status.requireAuth ? '已开启，仅允许可信设备连接' : '已关闭，仅影响本机 Debug 入口')),
               React.createElement('label', { style: { ...styles.switch, opacity: busy || !status ? .55 : 1 }, title: status && status.requireAuth ? '关闭设备鉴权' : '开启设备鉴权' },
                 React.createElement('input', {
                   type: 'checkbox',
@@ -318,15 +327,23 @@ window.__ModuleLoader__.load({
                 React.createElement('span', { style: { ...styles.switchTrack, background: status && status.requireAuth ? colors.success : colors.danger } }),
                 React.createElement('span', { style: { ...styles.switchKnob, left: status && status.requireAuth ? 21 : 3 } }))),
             status && !status.requireAuth
-              ? React.createElement('p', { style: { ...styles.error, margin: '12px 0 0' } }, 'Debug 模式：移动网关连接将跳过设备凭证校验，请勿暴露到公网。')
+              ? React.createElement('p', { style: { ...styles.error, margin: '12px 0 0' } }, 'Debug 模式：本机 DSH 入口将跳过设备凭证校验；独立局域网入口仍强制鉴权。')
               : null),
           React.createElement('section', { style: styles.card },
-            React.createElement('label', { style: styles.label }, '公网 WebSocket 地址'),
-            React.createElement('input', { style: styles.input, value: publicUrl, onChange: (event) => setPublicUrl(event.target.value), placeholder: 'wss://gateway.example.com/ws/mobile', spellCheck: false }),
+            React.createElement('label', { style: styles.label }, 'WebSocket 地址'),
+            React.createElement('input', { style: styles.input, value: publicUrl, onChange: (event) => { automaticUrlRef.current = ''; setPublicUrl(event.target.value) }, placeholder: 'ws://192.168.1.10:3081/ws/mobile', spellCheck: false }),
+            status && status.lan && status.lan.enabled
+              ? React.createElement('div', { style: { ...styles.muted, margin: '-7px 0 10px', color: status.lan.error ? colors.danger : colors.muted } },
+                  status.lan.error
+                    ? `局域网监听失败：${status.lan.error}`
+                    : status.lan.listening
+                      ? `局域网入口已开启${status.lan.urls && status.lan.urls.length ? `：${status.lan.urls.join('、')}` : `，端口 ${status.lan.port}`}`
+                      : '局域网入口启动中…')
+              : null,
             React.createElement('label', { style: styles.label }, '设备名称'),
             React.createElement('input', { style: styles.input, value: deviceName, onChange: (event) => setDeviceName(event.target.value), maxLength: 80, placeholder: 'iPhone' }),
             React.createElement('button', { style: { ...styles.button, ...styles.primary, opacity: busy || !(status && status.gatewayEnabled) ? .65 : 1 }, disabled: busy || !(status && status.gatewayEnabled), onClick: pair }, busy ? '正在生成…' : status && status.gatewayEnabled ? '生成配对二维码' : '请先开启移动网关'),
-            React.createElement('p', { style: { ...styles.muted, margin: '10px 0 0' } }, '公网地址必须使用 wss://。二维码中的配对码只能使用一次，并在 5 分钟内过期。')),
+            React.createElement('p', { style: { ...styles.muted, margin: '10px 0 0' } }, '同一局域网可直接使用私有地址的 ws://；公网地址仍必须使用 wss://。配对码只能使用一次，并在 5 分钟内过期。')),
           qr ? React.createElement('section', { style: { ...styles.card, textAlign: 'center' } },
             React.createElement('strong', null, '使用 iOS 客户端扫码'),
             React.createElement('img', { style: styles.qr, src: `data:image/svg+xml;charset=utf-8,${encodeURIComponent(qr.svg)}`, alt: '一次性设备配对二维码' }),

package/lib/index.mjs

@@ -57,6 +57,7 @@
 //                     { "kind": "event", "sessionId", "seq", "time", "event": { ... } }
 import fs from 'node:fs'
 import fsp from 'node:fs/promises'
+import http from 'node:http'
 import os from 'node:os'
 import path from 'node:path'
 import crypto from 'node:crypto'
@@ -88,6 +89,10 @@ const Config = Schema.object({
   pairingTtlMs: Schema.natural().min(30_000).max(15 * 60 * 1000).default(DEFAULT_PAIRING_TTL_MS),
   allowQueryToken: Schema.boolean().default(false),
   publicUrlFile: Schema.string().default('/etc/dsh-mobile-gateway/public-url'),
+  lanEnabled: Schema.boolean().default(false),
+  lanHost: Schema.string().default('0.0.0.0'),
+  lanPort: Schema.natural().min(1).max(65535).default(3081),
+  lanAdvertiseHost: Schema.string().default(''),
 })
 
 function log(line) {
@@ -665,7 +670,7 @@ function extractClientDeviceId(req) {
 }
 
 function rejectUpgrade(socket, status, message) {
-  const reason = status === 401 ? 'Unauthorized' : status === 503 ? 'Service Unavailable' : 'Bad Request'
+  const reason = status === 401 ? 'Unauthorized' : status === 403 ? 'Forbidden' : status === 404 ? 'Not Found' : status === 503 ? 'Service Unavailable' : 'Bad Request'
   socket.write(`HTTP/1.1 ${status} ${reason}\r\nConnection: close\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Length: ${Buffer.byteLength(message)}\r\n\r\n${message}`)
   socket.destroy()
 }
@@ -675,6 +680,47 @@ function isLocalHostname(hostname) {
   return normalized === 'localhost' || normalized === '::1' || /^127(?:\.\d{1,3}){3}$/.test(normalized)
 }
 
+function isPrivateNetworkHostname(hostname) {
+  let normalized = hostname.replace(/^\[|\]$/g, '').split('%')[0].toLowerCase()
+  if (normalized.startsWith('::ffff:')) normalized = normalized.slice('::ffff:'.length)
+  if (isLocalHostname(normalized) || normalized.endsWith('.local')) return true
+  const octets = normalized.split('.').map((part) => Number(part))
+  if (octets.length === 4 && octets.every((part) => Number.isInteger(part) && part >= 0 && part <= 255)) {
+    return octets[0] === 10 ||
+      (octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31) ||
+      (octets[0] === 192 && octets[1] === 168) ||
+      (octets[0] === 169 && octets[1] === 254)
+  }
+  return /^(?:f[cd][0-9a-f]{2}:|fe[89ab][0-9a-f]:)/i.test(normalized)
+}
+
+function privateLanAddresses() {
+  const physical = []
+  const fallback = []
+  const virtualInterface = /^(?:docker|br-|veth|utun|awdl|llw|vmnet|vbox|virbr|tailscale|wg)/i
+  for (const [name, records] of Object.entries(os.networkInterfaces())) {
+    for (const record of records || []) {
+      if (!record || record.internal || record.family !== 'IPv4' || !isPrivateNetworkHostname(record.address)) continue
+      const target = virtualInterface.test(name) ? fallback : physical
+      if (!target.includes(record.address)) target.push(record.address)
+    }
+  }
+  return physical.length ? physical : fallback
+}
+
+function lanWebSocketUrls(options, wsPath, boundPort) {
+  if (!options.lanEnabled) return []
+  const advertised = typeof options.lanAdvertiseHost === 'string' ? options.lanAdvertiseHost.trim() : ''
+  const hosts = advertised
+    ? [advertised]
+    : options.lanHost && options.lanHost !== '0.0.0.0' && options.lanHost !== '::'
+      ? [options.lanHost]
+      : privateLanAddresses()
+  return hosts
+    .filter((host) => isPrivateNetworkHostname(host))
+    .map((host) => `ws://${host.includes(':') ? `[${host}]` : host}:${boundPort}${wsPath}`)
+}
+
 function badRequest(message) {
   const error = new Error(message)
   error.status = 400
@@ -690,9 +736,9 @@ function normalizePublicUrl(value, req, wsPath) {
   const url = new URL(raw)
   if (url.protocol === 'https:') url.protocol = 'wss:'
   if (url.protocol === 'http:') url.protocol = 'ws:'
-  if (url.protocol !== 'ws:' && url.protocol !== 'wss:') throw badRequest('publicUrl must use wss:// (ws:// is allowed only for localhost)')
+  if (url.protocol !== 'ws:' && url.protocol !== 'wss:') throw badRequest('publicUrl must use wss:// (ws:// is allowed only for localhost and private LAN addresses)')
   if (url.username || url.password || url.search || url.hash) throw badRequest('publicUrl must not contain credentials, query parameters, or a fragment')
-  if (url.protocol === 'ws:' && !isLocalHostname(url.hostname)) throw badRequest('publicUrl must use wss:// for non-localhost endpoints')
+  if (url.protocol === 'ws:' && !isPrivateNetworkHostname(url.hostname)) throw badRequest('publicUrl must use wss:// outside localhost or a private LAN')
   return url.toString()
 }
 
@@ -775,12 +821,22 @@ const plugin = {
       pairingTtlMs: DEFAULT_PAIRING_TTL_MS,
       allowQueryToken: false,
       publicUrlFile: '/etc/dsh-mobile-gateway/public-url',
+      lanEnabled: false,
+      lanHost: '0.0.0.0',
+      lanPort: 3081,
+      lanAdvertiseHost: '',
       ...(config || {}),
     }
     const wsPath = options.path
     if (typeof wsPath !== 'string' || !wsPath.startsWith('/') || wsPath.endsWith('/') || wsPath.includes('?') || wsPath.includes('#')) {
       throw new Error('mobile-gateway: path must be an absolute pathname without a trailing slash, query, or fragment')
     }
+    if (options.lanEnabled === true && (typeof options.lanHost !== 'string' || !options.lanHost.trim())) {
+      throw new Error('mobile-gateway: lanHost must be a non-empty listen address')
+    }
+    if (options.lanEnabled === true && options.lanAdvertiseHost && !isPrivateNetworkHostname(options.lanAdvertiseHost)) {
+      throw new Error('mobile-gateway: lanAdvertiseHost must be localhost or a private LAN address')
+    }
     let requireAuth = options.requireAuth !== false
     const adminLoopbackOnly = options.adminLoopbackOnly !== false
     const deviceFile = options.deviceFile || path.join(os.homedir(), '.dsh', 'mobile-gateway-devices.json')
@@ -802,6 +858,10 @@ const plugin = {
     let connectedSinceEnabled = false
     let lastAuthRejectLogAt = 0
     let suppressedAuthRejects = 0
+    let lanServer = null
+    let lanListening = false
+    let lanListenError = null
+    let lanBoundPort = options.lanPort
     const configuredPublicUrl = () => {
       if (typeof options.publicUrl === 'string' && options.publicUrl.trim()) return options.publicUrl.trim()
       if (typeof options.publicUrlFile !== 'string' || !options.publicUrlFile.trim()) return ''
@@ -880,6 +940,15 @@ const plugin = {
               connectedClients: clients.size,
               wsPath,
               publicUrl: configuredPublicUrl() || null,
+              lan: {
+                enabled: options.lanEnabled === true,
+                listening: lanListening,
+                host: options.lanHost,
+                port: lanBoundPort,
+                urls: lanWebSocketUrls(options, wsPath, lanBoundPort),
+                requireAuth: true,
+                error: lanListenError,
+              },
               pairingTtlMs: options.pairingTtlMs,
               queryTokenAllowed: !!options.allowQueryToken,
             })
@@ -960,9 +1029,7 @@ const plugin = {
     })
     log(`management routes registered: /mgw (loopbackOnly=${adminLoopbackOnly})`)
 
-    const disposeUpgrade = webServer.registerUpgrade({
-      path: wsPath,
-      handler(req, socket, head) {
+    const handleMobileUpgrade = (req, socket, head, transport = {}) => {
         if (!gatewayEnabled) {
           rejectUpgrade(socket, 503, 'mobile gateway is disabled')
           return
@@ -988,7 +1055,11 @@ const plugin = {
           device = registry.authenticate(credential.value, extractClientDeviceId(req))
         }
 
-        if (requireAuth && !device) {
+        // The separately exposed LAN listener is always authenticated. The
+        // management UI's debug auth switch only affects the loopback DSH
+        // listener and can never turn a LAN endpoint into an open control
+        // plane.
+        if ((requireAuth || transport.lan === true) && !device) {
           logAuthRejected(req)
           rejectUpgrade(socket, 401, 'missing or invalid device credential')
           return
@@ -1062,16 +1133,63 @@ const plugin = {
           ws.send(JSON.stringify({
             kind: 'hello',
             protocol: 2,
-            port: webServer.port,
+            port: transport.port || webServer.port,
             clients: clients.size,
             authenticated: !!device,
             ...(device ? { device: { id: device.id, name: device.name } } : {}),
           }))
         })
+    }
+
+    const disposeUpgrade = webServer.registerUpgrade({
+      path: wsPath,
+      handler(req, socket, head) {
+        handleMobileUpgrade(req, socket, head, { port: webServer.port })
       },
     })
     log(`upgrade route registered: ${wsPath}`)
 
+    // DSH intentionally keeps its own WebUI listener on loopback. When LAN
+    // mode is enabled, expose a second, narrowly scoped listener that accepts
+    // only the authenticated mobile WebSocket path. It does not serve the
+    // WebUI or any /mgw management route.
+    if (options.lanEnabled === true) {
+      lanServer = http.createServer((req, res) => {
+        sendJson(res, 404, { error: 'not-found' })
+      })
+      lanServer.on('upgrade', (req, socket, head) => {
+        let pathname
+        try {
+          pathname = new URL(req.url || '/', 'http://lan.invalid').pathname
+        } catch (error) {
+          rejectUpgrade(socket, 400, 'invalid WebSocket path')
+          return
+        }
+        if (pathname !== wsPath) {
+          rejectUpgrade(socket, 404, 'not found')
+          return
+        }
+        if (!req.socket || !req.socket.remoteAddress || !isPrivateNetworkHostname(req.socket.remoteAddress)) {
+          rejectUpgrade(socket, 403, 'LAN listener accepts private-network clients only')
+          return
+        }
+        handleMobileUpgrade(req, socket, head, { lan: true, port: lanBoundPort })
+      })
+      lanServer.on('error', (error) => {
+        lanListening = false
+        lanListenError = error && error.message ? error.message : String(error)
+        log(`LAN listener failed: ${lanListenError}`)
+      })
+      lanServer.listen(options.lanPort, options.lanHost, () => {
+        lanListening = true
+        lanListenError = null
+        const address = lanServer.address()
+        if (address && typeof address === 'object') lanBoundPort = address.port
+        const urls = lanWebSocketUrls(options, wsPath, lanBoundPort)
+        log(`LAN listener ready: ${options.lanHost}:${lanBoundPort}${wsPath}${urls.length ? ` (${urls.join(', ')})` : ''}; authentication forced`)
+      })
+    }
+
     const disposeEvents = ctx.on('session/event', (session, event) => {
       if (clients.size === 0) return
       const wire = buildWireEvent(session, event)
@@ -1089,6 +1207,7 @@ const plugin = {
       disposeUpgrade()
       disposeMgmt()
       disposeEvents()
+      if (lanServer) lanServer.close()
       for (const client of clients) client.terminate()
       clients.clear()
       wss.close()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-mobile-gateway",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Persistent WebSocket gateway for dsh: exposes /ws/mobile on the web server and forwards agent session output to connected mobile clients",
   "main": "lib/index.mjs",
   "files": [
@@ -25,7 +25,7 @@
   },
   "bin": "bin/setup-ip.mjs",
   "scripts": {
-    "test": "node test/setup-ip.test.mjs && node test/gateway.test.mjs && node test/auth.test.mjs"
+    "test": "node test/setup-ip.test.mjs && node test/gateway.test.mjs && node test/auth.test.mjs && node test/lan.test.mjs"
   },
   "exports": {
     ".": "./lib/index.mjs",