@goodandready/dsh-lanmode 0.3.1 → 0.5.0

package/README.md

@@ -35,18 +35,30 @@ Everything happens through the web server's official index tap: one script is in
 
 | Piece | Setting | What it does |
 |---|---|---|
-| Settings | `settings` | Hands the two settings packages a connection whose `isLoopback` reads `true`. Everything downstream — the shared mirror, every namespace scope, the core's own pages — then behaves as it does on localhost. |
+| Settings | `settings` | Hands every package a connection whose `isLoopback` reads `true`. The shared mirror, every namespace scope, the core's own pages and every plugin's settings section then behave as they do on localhost. |
 | `crypto.randomUUID` | `randomUuid` | Provides an RFC 4122 v4 implementation over `crypto.getRandomValues`, which insecure origins do have. A no-op where the real one exists. |
 | `navigator.clipboard` | `clipboard` | Provides a `writeText` fallback so the copy buttons keep working. A no-op where the real one exists. |
 
-The settings substitution is deliberately narrow. Three packages read that flag, and the third is deliverables, where it decides whether a produced file may be opened locally — forcing it there would ask the Host to open paths on the server's desktop. Only the settings packages see the substitute.
+One package is excluded on purpose: deliverables, where the flag decides whether a produced file may be opened locally. Forcing it there would ask the Host to open paths on the server's desktop. Nothing else in the web UI reads the flag.
+
+The exclusion list replaced an allow list, and the reason is worth writing down. A namespace scope is bound like this:
+
+```js
+bind(spec) {
+  const ctx = this.ctx                      // the caller's context
+  const connection = ctx.get('connection')
+  ... connection.isLoopback ? 'host' : 'memory'
+}
+```
+
+`this.ctx` belongs to whichever plugin calls `bind`, not to the settings package. Handing the substitute to the settings packages alone therefore fixed the shared mirror and the core's own pages, while every plugin's own settings section still went to memory mode and reported that the harness had not announced its settings.
 
 ## Two modes
 
 ```yaml
 - id: dsh-lanmode
   config:
-    mode: proxy        # proxy | direct
+    mode: proxy        # proxy | direct | auto
 ```
 
 **`proxy`** (default) — something already listens on the network in front of the harness: nginx, Caddy, Tailscale serve, an SSH tunnel. The plugin only repairs the page and touches nothing else. This is the safe default: it cannot collide with whatever you already run.
@@ -65,17 +77,127 @@ Then open `http://<the machine's IP>:3088` from any device on the network.
 
 A listener rather than rebinding the harness itself, for two reasons: a bind host lives in the config tree and cannot be a switch inside the plugin, and rebinding to `0.0.0.0` collides with a reverse proxy already holding that port.
 
+**`auto`** — work it out. The plugin knocks on this machine's own network
+addresses at the harness port: the harness itself listens on loopback only, so
+anything answering there is a proxy, and the mode is `proxy`. When nothing
+answers and the direct port is free, it is `direct`. When it cannot tell — no
+addresses, no known port, a probe that errored — it picks `proxy` and opens
+nothing: an unnecessary listener on a network address is an open door, and one
+is not opened on a guess.
+
+What `auto` cannot see is a proxy sitting on a *different* port. From outside
+that is indistinguishable from nobody being there, and the plugin would open its
+own listener beside it. Set the mode by hand in that case.
+
+The decision is logged with its reason and shown on the diagnostics page.
+
 Changing the mode takes effect on restart.
 
+## HTTPS, and the microphone
+
+This is the one thing no substitution can repair. A browser hands out
+`navigator.mediaDevices` only over a secure connection, and behind it is a real
+device — there is nothing to fake. Over plain HTTP on a network address, voice
+input is impossible in principle.
+
+So the direct-mode listener can speak HTTPS:
+
+```yaml
+- id: dsh-lanmode
+  config:
+    mode: direct
+    tls: self-signed     # off | self-signed | files
+```
+
+**`self-signed`** — the plugin issues a certificate itself and keeps it in
+`tlsDir` (by default a folder next to the harness data). It goes into the
+certificate with every address this machine answers on, plus anything in
+`tlsHosts`: a certificate issued for one name is refused for every other, even
+after it has been accepted once. It is reissued when it is about to expire or
+when a new address appears. The fingerprint is printed to the log at startup —
+compare it in the browser instead of accepting blindly.
+
+Issuing needs `openssl` on the machine. Without it the plugin says so plainly
+and falls back to plain HTTP rather than pretending everything is fine.
+
+**`files`** — your own certificate:
+
+```yaml
+    tls: files
+    tlsCert: /path/to/cert.pem
+    tlsKey: /path/to/key.pem
+```
+
+A self-signed certificate is a compromise, not a solution: the browser will
+still ask. But it turns "impossible" into "confirm once", and that is the whole
+difference between voice input working over the network and not.
+
+## Who may connect
+
+The direct listener has no password and will not get one: the plugin does not
+intercept anyone else's routes, and inventing its own way into the harness is
+not its business. But between "no password" and "anyone on the network" there is
+room:
+
+```yaml
+- id: dsh-lanmode
+  config:
+    mode: direct
+    allow:
+      - 192.168.1.0/24
+      - 10.0.0.5
+```
+
+Addresses and CIDR ranges, IPv4 and IPv6. An empty list means everyone, which is
+how the plugin behaves until you fill it in. Refused connections are logged, at
+a limited rate so a scanner cannot drown the log.
+
+Two honest limits. This is not authentication: whoever is on the list gets in
+unchecked. And behind a reverse proxy it means nothing — every request arrives
+from the proxy, so filter there instead.
+
+## Diagnostics
+
+`GET /dsh-lanmode/health` — one page answering the questions that otherwise take
+half an hour: which mode is on and why, what is patched, whether the browser
+considers the connection secure, and why the microphone is silent. Add
+`?format=json` for the same data in a form you can paste into a bug report.
+
+Half the answers can only come from the browser — a secure connection and a
+microphone exist nowhere else — so the page checks those in the browser that
+opened it.
+
+Nothing secret is on that page: it is open to anyone who reached the harness.
+Turn it off with `diagnostics: false`.
+
+## When the harness changes underneath
+
+The plugin holds on to the harness's internals: the index tap, the name of the
+package the substitution must leave alone, the shape of the connection object.
+An upgrade can move any of them, and a plugin that repairs someone else's
+behaviour must not fail quietly — that already happened once, and it took days
+of confusing symptoms to notice.
+
+So at startup it checks its own assumptions and says what it found: one line
+when everything is in place, a loud complaint naming what moved when it is not.
+The same list is on the diagnostics page.
+
 ## Settings
 
 All of it can be edited as the `dsh-lanmode` namespace — in `$DSH_HOME/settings.yaml`, or from the UI once the settings pages work.
 
 | Setting | Default | Meaning |
 |---|---|---|
-| `mode` | `proxy` | `proxy` or `direct` |
+| `mode` | `proxy` | `proxy`, `direct` or `auto` |
 | `directHost` | `0.0.0.0` | `direct`: which address to listen on |
 | `directPort` | `3088` | `direct`: which port to listen on |
+| `tls` | `off` | `direct`: `off`, `self-signed` or `files` — what the microphone hangs on |
+| `tlsDir` | — | `self-signed`: where the issued certificate is kept |
+| `tlsHosts` | `[]` | `self-signed`: extra names and addresses for the certificate |
+| `tlsCert` | — | `files`: path to the certificate in PEM |
+| `tlsKey` | — | `files`: path to the private key in PEM |
+| `allow` | `[]` | `direct`: addresses and CIDR ranges allowed in. Empty means everyone |
+| `diagnostics` | `true` | serve `GET /dsh-lanmode/health` |
 | `settings` | `true` | return the settings service |
 | `randomUuid` | `true` | provide `crypto.randomUUID` on plain HTTP |
 | `clipboard` | `true` | provide a clipboard fallback on plain HTTP |

package/lib/access.js

@@ -0,0 +1,156 @@
+// Кого пускать в прямом режиме.
+//
+// Пароля здесь нет и не будет: плагин чужие маршруты не перехватывает, а
+// придумывать свой вход в харнесс — не его дело. Но между «без пароля» и «кто
+// угодно из сети» есть промежуток, и список разрешённых адресов его занимает.
+//
+// Разбор записи CIDR свой, без зависимостей: адрес превращается в набор байтов,
+// и сравниваются первые N бит. Для IPv4 и IPv6 это одна и та же арифметика,
+// разной длины.
+
+/** Байты адреса IPv4, или `null`, если это не он. */
+function ipv4Bytes(text) {
+  const parts = text.split('.')
+  if (parts.length !== 4) return null
+  const bytes = []
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part)) return null
+    const value = Number(part)
+    if (value > 255) return null
+    bytes.push(value)
+  }
+  return bytes
+}
+
+/**
+ * Байты адреса IPv6, или `null`.
+ *
+ * Отдельно разбирается запись с хвостом IPv4 (`::ffff:192.168.1.5`): именно её
+ * отдаёт Node для обычных подключений на сокете двойного стека, и без неё
+ * список разрешённых адресов не сработал бы вовсе.
+ */
+function ipv6Bytes(text) {
+  let body = text
+  let tail = []
+  const dot = body.lastIndexOf(':')
+  if (body.includes('.')) {
+    const four = ipv4Bytes(body.slice(dot + 1))
+    if (!four) return null
+    tail = four
+    body = body.slice(0, dot + 1) + '0:0'
+  }
+
+  const halves = body.split('::')
+  if (halves.length > 2) return null
+  const head = halves[0] ? halves[0].split(':') : []
+  const rest = halves.length === 2 ? (halves[1] ? halves[1].split(':') : []) : []
+  if (halves.length === 1 && head.length !== 8) return null
+
+  const groups = []
+  for (const group of head) {
+    if (!/^[0-9a-fA-F]{1,4}$/.test(group)) return null
+    groups.push(Number.parseInt(group, 16))
+  }
+  const restGroups = []
+  for (const group of rest) {
+    if (!/^[0-9a-fA-F]{1,4}$/.test(group)) return null
+    restGroups.push(Number.parseInt(group, 16))
+  }
+  const missing = 8 - groups.length - restGroups.length
+  if (missing < 0) return null
+  const all = halves.length === 2
+    ? groups.concat(new Array(missing).fill(0), restGroups)
+    : groups
+
+  const bytes = []
+  for (const group of all) bytes.push(group >> 8, group & 255)
+  if (tail.length) {
+    bytes.splice(12, 4, ...tail)
+  }
+  return bytes.length === 16 ? bytes : null
+}
+
+/** Байты адреса — или `null`, если разобрать не вышло. */
+export function addressBytes(text) {
+  const clean = String(text ?? '').trim()
+  if (!clean) return null
+  if (clean.includes(':')) return ipv6Bytes(clean)
+  return ipv4Bytes(clean)
+}
+
+/**
+ * Адрес IPv4, спрятанный внутри записи IPv6.
+ *
+ * `::ffff:192.168.1.5` — это тот же 192.168.1.5, и правило, написанное для
+ * IPv4, обязано на него распространяться. Иначе список выглядит рабочим, а
+ * пускает мимо.
+ */
+function unwrapped(bytes) {
+  if (!bytes || bytes.length !== 16) return null
+  for (let i = 0; i < 10; i++) if (bytes[i] !== 0) return null
+  if (bytes[10] !== 255 || bytes[11] !== 255) return null
+  return bytes.slice(12)
+}
+
+/**
+ * Разобрать одну запись списка: адрес или подсеть в записи CIDR.
+ *
+ * @returns `{ bytes, bits }` или `null`, если запись непонятна.
+ */
+export function parseRule(text) {
+  const clean = String(text ?? '').trim()
+  if (!clean) return null
+  const slash = clean.lastIndexOf('/')
+  const address = slash === -1 ? clean : clean.slice(0, slash)
+  const bytes = addressBytes(address)
+  if (!bytes) return null
+
+  const full = bytes.length * 8
+  if (slash === -1) return { bytes, bits: full }
+  const bits = Number(clean.slice(slash + 1))
+  if (!Number.isInteger(bits) || bits < 0 || bits > full) return null
+  return { bytes, bits }
+}
+
+/** Разобрать весь список, молча отбрасывая непонятные записи. */
+export function parseAllow(list) {
+  const rules = []
+  const dropped = []
+  for (const item of Array.isArray(list) ? list : []) {
+    const rule = parseRule(item)
+    if (rule) rules.push(rule)
+    else if (String(item ?? '').trim()) dropped.push(String(item))
+  }
+  return { rules, dropped }
+}
+
+/** Совпадают ли первые `bits` бит. */
+function samePrefix(left, right, bits) {
+  if (left.length !== right.length) return false
+  const whole = bits >> 3
+  for (let i = 0; i < whole; i++) if (left[i] !== right[i]) return false
+  const spare = bits & 7
+  if (spare === 0) return true
+  const mask = (255 << (8 - spare)) & 255
+  return (left[whole] & mask) === (right[whole] & mask)
+}
+
+/**
+ * Пускать ли этот адрес.
+ *
+ * Пустой список означает «никого не ограничиваем» — так плагин ведёт себя до
+ * того, как список задали, и так же, если задали одну мусорную строку: тихо
+ * запереть дверь из-за опечатки хуже, чем не запирать вовсе.
+ */
+export function allowed(address, rules) {
+  if (!Array.isArray(rules) || rules.length === 0) return true
+  const bytes = addressBytes(address)
+  if (!bytes) return false
+  const inner = unwrapped(bytes)
+
+  for (const rule of rules) {
+    if (samePrefix(bytes, rule.bytes, rule.bits)) return true
+    if (inner && rule.bytes.length === 4 && samePrefix(inner, rule.bytes, rule.bits)) return true
+  }
+  return false
+}

package/lib/assumptions.js

@@ -0,0 +1,76 @@
+// Проверка точек крепления.
+//
+// Плагин чинит чужое поведение и держится за внутренности харнесса: за точку
+// вставки в index.html, за то, что вставка доезжает до отдаваемой страницы, и
+// за имя пакета, который заплатка обязана обходить стороной. Любая из точек
+// может уехать с обновлением ядра.
+//
+// Так уже было: подмена доходила до настроек ядра, но не до разделов плагинов,
+// и это выяснилось не сразу, а через несколько дней жалоб на пустые карточки.
+// Тихий отказ здесь хуже поломки — поэтому плагин проверяет свои допущения сам
+// и жалуется громко.
+
+/** Пакет, которому заплатка обязана оставлять настоящий ответ. */
+export const EXCLUDED_BUNDLE = '@deepseek-ai/dsh-client-ui-deliverables'
+
+/** Один вывод проверки. */
+function verdict(name, ok, detail) {
+  return { name, ok, detail }
+}
+
+/**
+ * Проверить всё, что можно проверить со стороны хоста.
+ *
+ * Со стороны браузера проверяет страница диагностики: то, что происходит в нём,
+ * отсюда не видно, а гадать — то же самое, что не проверять.
+ *
+ * @param options {{webServer: object, fetchIndex: () => Promise<string>}}
+ */
+export async function checkAssumptions(options) {
+  const results = []
+  const webServer = options.webServer
+
+  results.push(verdict(
+    'точка вставки в index.html',
+    Boolean(webServer && typeof webServer.tapIndex === 'function'),
+    'webServer.tapIndex — то, чем плагин вставляет заплатку на страницу',
+  ))
+
+  results.push(verdict(
+    'порт харнесса известен',
+    Boolean(webServer && webServer.port),
+    'webServer.port — без него не поднять прямой режим и не проверить, кто слушает сеть',
+  ))
+
+  let html = ''
+  try {
+    html = await options.fetchIndex()
+  } catch (unreachable) {
+    results.push(verdict('страница отдаётся', false, String(unreachable.message || unreachable)))
+    return results
+  }
+
+  results.push(verdict(
+    'заплатка попала на страницу',
+    html.includes('data-dsh-lanmode'),
+    'если её там нет, всё остальное не имеет значения',
+  ))
+
+  results.push(verdict(
+    'исключение на месте',
+    html.includes(EXCLUDED_BUNDLE),
+    'пакет ' + EXCLUDED_BUNDLE + ' обходится стороной, потому что решает, можно ли '
+      + 'открыть файл локально. Исчез или переименован — исключение больше ничего не исключает',
+  ))
+
+  return results
+}
+
+/** Свести проверки в одну строку для журнала. */
+export function summarize(results) {
+  const bad = results.filter((item) => !item.ok)
+  if (bad.length === 0) return 'точки крепления на месте: ' + results.length + ' из ' + results.length
+  return 'ТОЧКИ КРЕПЛЕНИЯ УЕХАЛИ (' + bad.length + ' из ' + results.length + '): '
+    + bad.map((item) => item.name).join('; ')
+    + '. Плагин может работать не так, как задумано, — вероятно, обновилось ядро'
+}

package/lib/bridge.js

@@ -1,92 +1,146 @@
-// Прямой режим: слушатель на сетевом адресе, который передаёт всё харнессу.
-//
-// Зачем не привязка харнесса к 0.0.0.0, как делают соседние плагины. Привязка
-// задаётся в дереве конфигурации и меняется только перезапуском, то есть
-// «переключателем в плагине» быть не может. Хуже того, если перед харнессом
-// уже стоит обратный прокси на том же порту, привязка столкнётся с ним лбами.
-// Отдельный слушатель включается и гасится вместе со строкой плагина и живёт
-// рядом с любым прокси.
-//
-// Заголовки Host и Origin переписываются на локальные: харнесс пропускает
-// запрос, только когда Origin совпадает с адресом, по которому он слушает.
-// Это ровно то, что делает любой обратный прокси, и это же означает, что
-// прямой режим открывает харнесс всем, кто дотянется до этого порта, — как и
-// nginx сегодня. Пароля здесь нет и быть не может: плагин чужие маршруты не
-// перехватывает.
-
-import http from 'node:http'
-
-function rewritten(headers, authority) {
-  const out = { ...headers, host: authority }
-  if (out.origin) out.origin = 'http://' + authority
-  if (out.referer) out.referer = String(out.referer).replace(/^https?:\/\/[^/]+/, 'http://' + authority)
-  return out
-}
-
-/**
- * @param ctx контекст плагина (нужен ctx.webServer.port)
- * @param options {{host: string, port: number, log: (message: string) => void}}
- * @returns функция остановки
- */
-export function startDirectBridge(ctx, options) {
-  const upstreamPort = ctx.webServer.port
-  if (!upstreamPort) {
-    options.log('прямой режим не поднят: веб-сервер ещё не сообщил порт')
-    return () => {}
-  }
-  const authority = '127.0.0.1:' + upstreamPort
-
-  const bridge = http.createServer((req, res) => {
-    const upstream = http.request({
-      host: '127.0.0.1',
-      port: upstreamPort,
-      method: req.method,
-      path: req.url,
-      headers: rewritten(req.headers, authority),
-    }, (answer) => {
-      res.writeHead(answer.statusCode || 502, answer.headers)
-      answer.pipe(res)
-    })
-    upstream.on('error', () => {
-      if (!res.headersSent) res.writeHead(502, { 'content-type': 'text/plain; charset=utf-8' })
-      res.end('dsh-lanmode: харнесс не отвечает')
-    })
-    req.pipe(upstream)
-  })
-
-  // Веб-сокеты интерфейса идут через Upgrade: их надо передать сырыми.
-  bridge.on('upgrade', (req, socket, head) => {
-    const upstream = http.request({
-      host: '127.0.0.1',
-      port: upstreamPort,
-      method: req.method,
-      path: req.url,
-      headers: rewritten(req.headers, authority),
-    })
-    upstream.on('upgrade', (answer, upstreamSocket, upstreamHead) => {
-      const lines = ['HTTP/1.1 101 Switching Protocols']
-      for (const [key, value] of Object.entries(answer.headers)) lines.push(key + ': ' + value)
-      socket.write(lines.join('\r\n') + '\r\n\r\n')
-      if (upstreamHead && upstreamHead.length) socket.unshift(upstreamHead)
-      upstreamSocket.pipe(socket)
-      socket.pipe(upstreamSocket)
-      const drop = () => { try { upstreamSocket.destroy() } catch (already) { /* уже мертво */ } }
-      socket.on('error', drop)
-      socket.on('close', drop)
-    })
-    upstream.on('error', () => { try { socket.destroy() } catch (already) { /* уже мертво */ } })
-    if (head && head.length) upstream.write(head)
-    upstream.end()
-  })
-
-  bridge.on('error', (failure) => {
-    options.log('прямой режим не поднялся: ' + String(failure && failure.message || failure))
-  })
-
-  bridge.listen(options.port, options.host, () => {
-    options.log('прямой режим: слушаю ' + options.host + ':' + options.port
-      + ', передаю на ' + authority)
-  })
-
-  return () => { bridge.close() }
-}
+// Прямой режим: слушатель на сетевом адресе, который передаёт всё харнессу.
+//
+// Зачем не привязка харнесса к 0.0.0.0, как делают соседние плагины. Привязка
+// задаётся в дереве конфигурации и меняется только перезапуском, то есть
+// «переключателем в плагине» быть не может. Хуже того, если перед харнессом
+// уже стоит обратный прокси на том же порту, привязка столкнётся с ним лбами.
+// Отдельный слушатель включается и гасится вместе со строкой плагина и живёт
+// рядом с любым прокси.
+//
+// Заголовки Host и Origin переписываются на локальные: харнесс пропускает
+// запрос, только когда Origin совпадает с адресом, по которому он слушает.
+// Это ровно то, что делает любой обратный прокси.
+//
+// Кого пускать — решает список разрешённых адресов, если он задан. Это не
+// замена паролю: тот, кто в списке, входит без всякой проверки. Это сужение
+// круга, и в описании плагина так и сказано.
+
+import http from 'node:http'
+import https from 'node:https'
+
+import { allowed } from './access.js'
+
+function rewritten(headers, authority) {
+  const out = { ...headers, host: authority }
+  if (out.origin) out.origin = 'http://' + authority
+  if (out.referer) out.referer = String(out.referer).replace(/^https?:\/\/[^/]+/, 'http://' + authority)
+  return out
+}
+
+/**
+ * Ограничитель частоты жалоб.
+ *
+ * Сканер из сети даёт сотни отказов в минуту, и без ограничения журнал
+ * превращается в поток одинаковых строк, в котором не видно ничего другого.
+ */
+function throttle(log, everyMs) {
+  let last = 0
+  let skipped = 0
+  return (message) => {
+    const now = Date.now()
+    if (now - last < everyMs) {
+      skipped += 1
+      return
+    }
+    log(skipped ? message + ' (и ещё ' + skipped + ' таких же)' : message)
+    last = now
+    skipped = 0
+  }
+}
+
+/**
+ * @param ctx контекст плагина (нужен ctx.webServer.port)
+ * @param options {{host: string, port: number, log: (message: string) => void,
+ *                  allow?: object[], tls?: {cert: string, key: string}}}
+ * @returns функция остановки
+ */
+export function startDirectBridge(ctx, options) {
+  const upstreamPort = ctx.webServer.port
+  if (!upstreamPort) {
+    options.log('прямой режим не поднят: веб-сервер ещё не сообщил порт')
+    return () => {}
+  }
+  const authority = '127.0.0.1:' + upstreamPort
+  const rules = options.allow ?? []
+  const refuse = throttle(options.log, 10000)
+
+  /** Пускать ли этого гостя; отказ пишется в журнал не чаще раза в десять секунд. */
+  const welcome = (address) => {
+    if (allowed(address, rules)) return true
+    refuse('отказано: адрес ' + String(address) + ' не в списке разрешённых')
+    return false
+  }
+
+  const handle = (req, res) => {
+    if (!welcome(req.socket.remoteAddress)) {
+      res.writeHead(403, { 'content-type': 'text/plain; charset=utf-8' })
+      res.end('forbidden')
+      return
+    }
+    const upstream = http.request({
+      host: '127.0.0.1',
+      port: upstreamPort,
+      method: req.method,
+      path: req.url,
+      headers: rewritten(req.headers, authority),
+    }, (answer) => {
+      res.writeHead(answer.statusCode || 502, answer.headers)
+      answer.pipe(res)
+    })
+    upstream.on('error', () => {
+      if (!res.headersSent) res.writeHead(502, { 'content-type': 'text/plain; charset=utf-8' })
+      res.end('dsh-lanmode: харнесс не отвечает')
+    })
+    req.pipe(upstream)
+  }
+
+  const bridge = options.tls
+    ? https.createServer({ cert: options.tls.cert, key: options.tls.key }, handle)
+    : http.createServer(handle)
+
+  // Веб-сокеты интерфейса идут через Upgrade: их надо передать сырыми. Проверка
+  // адреса здесь такая же: пропустить веб-сокеты — значит не сделать ничего,
+  // весь разговор с агентом идёт именно по ним.
+  bridge.on('upgrade', (req, socket, head) => {
+    if (!welcome(socket.remoteAddress)) {
+      try {
+        socket.write('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n')
+        socket.destroy()
+      } catch (already) { /* уже мертво */ }
+      return
+    }
+    const upstream = http.request({
+      host: '127.0.0.1',
+      port: upstreamPort,
+      method: req.method,
+      path: req.url,
+      headers: rewritten(req.headers, authority),
+    })
+    upstream.on('upgrade', (answer, upstreamSocket, upstreamHead) => {
+      const lines = ['HTTP/1.1 101 Switching Protocols']
+      for (const [key, value] of Object.entries(answer.headers)) lines.push(key + ': ' + value)
+      socket.write(lines.join('\r\n') + '\r\n\r\n')
+      if (upstreamHead && upstreamHead.length) socket.unshift(upstreamHead)
+      upstreamSocket.pipe(socket)
+      socket.pipe(upstreamSocket)
+      const drop = () => { try { upstreamSocket.destroy() } catch (already) { /* уже мертво */ } }
+      socket.on('error', drop)
+      socket.on('close', drop)
+    })
+    upstream.on('error', () => { try { socket.destroy() } catch (already) { /* уже мертво */ } })
+    if (head && head.length) upstream.write(head)
+    upstream.end()
+  })
+
+  bridge.on('error', (failure) => {
+    options.log('прямой режим не поднялся: ' + String(failure && failure.message || failure))
+  })
+
+  bridge.listen(options.port, options.host, () => {
+    options.log('прямой режим: слушаю ' + (options.tls ? 'https://' : 'http://')
+      + options.host + ':' + options.port + ', передаю на ' + authority
+      + (rules.length ? ', пускаю ' + rules.length + ' правил(о) из списка' : ''))
+  })
+
+  return () => { bridge.close() }
+}