@goodandready/dsh-lanmode 0.1.0 → 0.3.0

package/README.md

@@ -1,77 +1,109 @@
 # dsh-lanmode
 
-**Settings over the LAN** for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) (dsh).
+Open the [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) Web UI from another device — a phone, a tablet, the laptop on the other side of the room — and have **all of it** work, including the parts the UI switches off when the page is not `localhost`.
 
-Open the Web UI at `http://192.168.1.50:3080` instead of `http://localhost:3080` and every settings card in the deployment goes blank — your plugins' cards, and **Settings → Plugins → Plugin configuration** with them. No error appears, the plugins load fine, and reloading does not help. Saving silently does nothing.
+Works whether you put a reverse proxy in front of the harness or let this plugin serve the network itself. Pick a mode, restart, done.
 
-This plugin fixes that. Install it, reload the page, and the settings work from any address.
+## What breaks without it
 
-## Why it happens
+Reach the UI at a LAN address and you get some mix of:
 
-The decision is made in the browser, from the page's hostname:
+- **Settings → Models**: `settings are unavailable in this browser`
+- **Settings → Plugins → Plugin configuration**: empty, no cards at all
+- every plugin's settings card: blank, and saving silently does nothing
+- on plain HTTP, nothing loads at all: sessions and models never render
 
-```js
-isLoopback: pageLocation === undefined || isLoopbackHostname(pageLocation.hostname)
-```
+None of that is the server refusing. The server serves settings over the network perfectly well.
 
-`isLoopbackHostname` accepts `localhost`, `[::1]` and `127.0.0.0/8` — nothing else. A page served at a LAN address is therefore "remote", and the settings service switches to a process-local mode where the shared mirror of the settings document is never read at all:
+## Why it happens
+
+Two independent things.
+
+**The settings service turns itself off.** The UI decides from the page's hostname:
 
 ```js
-ensure() { if (this.persistence === "memory") return Promise.resolve() }
-status: persistence === "host" ? "loading" : "unavailable"
-enqueue() { if (this.persistence === "memory") return Promise.resolve() }
+isLoopback: pageLocation === undefined || isLoopbackHostname(hostname)
 ```
 
-Every bound namespace reports `status: "unavailable"` for the life of the page, and writes are dropped before they reach the wire.
+`isLoopbackHostname` accepts `localhost`, `[::1]` and `127.0.0.0/8`, nothing else. Anything else puts the settings service into a process-local mode where the shared mirror of the settings document is never read, every namespace reports `status: "unavailable"` for the life of the page, and writes are dropped before they reach the wire.
 
-**The server does not share this restriction.** Both `settings.describe` and `settings.mutate` answer normally over the network as long as the request's `Origin` matches the page it came from — which is exactly the case for requests the UI itself makes. Verified against a live harness behind a reverse proxy.
+**Some Web APIs only exist on a secure context.** `crypto.randomUUID` is called on boot-critical paths, and `navigator.clipboard` behind the copy buttons. Over plain HTTP from a LAN address the browser withholds both.
 
 ## What the plugin does
 
-On a loopback page: nothing at all — the core works there, and a second implementation would only be a second source of truth.
+Everything happens through the web server's official index tap: one script is injected into `index.html` ahead of the boot manifest. No product source is modified, and removing the plugin restores the page exactly.
 
-On any other page it stands up its own copy of the same machinery over the same two calls, and publishes it:
+| 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. |
+| `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. |
 
-- as a service named `lanSettings`, for plugins that want to ask for it explicitly;
-- and, if the runtime allows a plugin to claim the name, in place of `settingsScope` — which repairs every settings surface at once, including the core's plugin configuration tab and plugins that know nothing about this one.
+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.
 
-The snapshot it hands out has the same shape the core's has — `status`, `value`, `base`, `user`, `revision`, `writable` — so cards cannot tell the difference.
+## Two modes
 
-## Install
+```yaml
+- id: dsh-lanmode
+  config:
+    mode: proxy        # proxy | direct
+```
 
-```bash
-dsh plugin --profile web add @goodandready/dsh-lanmode
+**`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.
+
+**`direct`** — no proxy anywhere. The plugin opens a listener of its own and forwards to the harness, rewriting `Host` and `Origin` to the loopback authority so the harness's same-origin fence is satisfied:
+
+```yaml
+- id: dsh-lanmode
+  config:
+    mode: direct
+    directHost: '0.0.0.0'   # every interface
+    directPort: 3088
 ```
 
-Restart the Web UI afterwards, then reload the browser.
+Then open `http://<the machine's IP>:3088` from any device on the network.
 
-## Checking it on a machine where it is not needed
+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.
 
-The plugin stands aside on a loopback page, which makes it awkward to try out
-on the machine that runs the harness. A debug switch turns it on there anyway:
+Changing the mode takes effect on restart.
 
-```js
-localStorage.setItem('dsh-lanmode:force', '1'); location.reload()
-```
+## 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` |
+| `directHost` | `0.0.0.0` | `direct`: which address to listen on |
+| `directPort` | `3088` | `direct`: which port to listen on |
+| `settings` | `true` | return the settings service |
+| `randomUuid` | `true` | provide `crypto.randomUUID` on plain HTTP |
+| `clipboard` | `true` | provide a clipboard fallback on plain HTTP |
+
+## Checking it
 
-Remove the key to go back to normal. This is only for looking at the plugin
-itself; nothing in day-to-day use needs it.
+- `?lanmode=invert` — report the loopback flag as `false` even on localhost. The harness then fails exactly the way it does over the LAN; this is how the plugin is verified.
+- `?lanmode=off` — stand the plugin down entirely, to see the page as it would be without it.
+
+On a loopback page the plugin substitutes `true` where the real value is already `true`, so it cannot change behaviour there.
 
 ## What it is not
 
-Not authentication. The plugin does not add a password and does not widen what the server accepts — the harness answers those same calls with or without it. If your harness is reachable by other people, put a real gate in front of it (HTTP auth in your reverse proxy, or a VPN); a plugin cannot do that job, because the web server service hands plugins their own routes and no way to intercept anyone else's.
+**Not authentication.** It adds no password and does not widen what the server accepts — the harness answers those same calls with or without it. `direct` mode does make the harness reachable by anyone who can reach that port, exactly as a reverse proxy would. If other people share your network, put a real gate in front of the harness. A plugin cannot do that job: the web server hands plugins their own routes and no way to intercept anyone else's.
 
-## Structure
+**No microphone over plain HTTP.** Browsers withhold `navigator.mediaDevices` outside a secure context, so voice input plugins stop working on a plain-HTTP LAN address. Nothing can polyfill that. If you need the microphone, keep HTTPS in front and use `proxy` mode.
 
+## Install
+
+```bash
+dsh plugin --profile web add @goodandready/dsh-lanmode
 ```
-dsh-lanmode/
-├── package.json            # dsh bundle/plugin metadata
-├── cordis.patch.yml        # bundle layer: inserts the plugin row
-├── lib/index.js            # host: nothing but a log line — the work is in the browser
-├── lib/client.js           # browser: the settings mirror and namespace scopes
-├── README.md
-└── LICENSE                 # MIT
-```
+
+Restart the harness, then reload the browser.
+
+## Credit
+
+The index-tap approach and the `crypto.randomUUID` polyfill come from [dsh-web-lan-access](https://github.com/AcidGr/dsh-web-lan-access) (MIT), which solves the secure-context half of this problem. Several other plugins in the same space — `dsh-lan-access`, `dsh-lan`, `dsh-LAN`, `dsh-lan-gate`, `dsh-Remote` — cover binding, mobile layout and device approval; none of them return the settings service, which is what this one is for.
 
 ## License
 

package/cordis.patch.yml

@@ -1,10 +1,22 @@
 # dsh-lanmode bundle layer: applied automatically when the package is installed
 # as a profile bundle (package.json declares dsh.bundle.patch).
 #
-# `name` must stay the full npm package name: the client-modules registry
-# resolves the browser bundle by the loader entry name, so a shortened name
-# leaves the UI half silently out of window.__DSH_BOOT__ — and the UI half is
-# the whole plugin here.
+# `name` must stay the full npm package name: the loader entry name is how the
+# served bundle is resolved.
+#
+# Everything is configurable in the `dsh-lanmode` settings namespace, so the
+# row below stays empty. To pin the mode in the tree instead of the settings
+# document, override it in your own profile patch:
+#
+#   - id: dsh-lanmode
+#     config:
+#       mode: direct
+#       directPort: 3088
+#
+# Note there is deliberately no webserver override here. Other plugins in this
+# space rebind the harness to 0.0.0.0; that cannot be switched from inside a
+# plugin and collides with a reverse proxy already holding the port. Direct
+# mode opens a listener of its own instead.
 - insert:
     - id: dsh-lanmode
       name: '@goodandready/dsh-lanmode'

package/lib/bridge.js

@@ -0,0 +1,92 @@
+// Прямой режим: слушатель на сетевом адресе, который передаёт всё харнессу.
+//
+// Зачем не привязка харнесса к 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() }
+}

package/lib/index.js

@@ -1,20 +1,142 @@
 // dsh-lanmode — хост-половина.
 //
-// Работа плагина целиком в браузере: ограничение, которое он снимает, живёт
-// в клиентском коде харнесса, а сервер и без него отдаёт настройки по сети.
-// Хост-половина существует потому, что запись в дереве плагинов — это модуль
-// на хосте; она ничего не регистрирует и ничего не слушает.
+// Плагин возвращает веб-интерфейсу то, что он сам себе запрещает на странице,
+// открытой не с localhost. Три независимых куска, каждый выключается отдельно.
 //
-// Единственное, что здесь есть, — строчка в журнале при запуске, чтобы по
-// логу было видно, что плагин установлен.
+// 1. Настройки. Интерфейс решает по имени хоста страницы:
+//
+//      isLoopback: pageLocation === undefined || isLoopbackHostname(hostname)
+//
+//    и своими считает только localhost, [::1] и 127.0.0.0/8. Дальше сервис
+//    настроек уходит в режим «памяти»: общий вид документа не читается никогда,
+//    каждый раздел получает статус "unavailable", запись выбрасывается до
+//    отправки. Наружу это выглядит как пустые карточки всех плагинов, пустая
+//    вкладка «Настройки плагинов» и страница «Модели» с надписью
+//    "settings are unavailable in this browser". Сервер это ограничение не
+//    разделяет: describe и mutate по сети отвечают штатно.
+//
+// 2. crypto.randomUUID. Существует только на защищённом соединении, а
+//    интерфейс зовёт его на пути загрузки. На чистом HTTP по сетевому адресу
+//    его нет, и каждый вызов к серверу падает. Приём и заготовка заплатки
+//    взяты у dsh-web-lan-access (AcidGr), MIT.
+//
+// 3. navigator.clipboard. Тоже только для защищённого соединения — без него
+//    кнопки «Копировать» молчат. Подставляем запасной путь.
+//
+// Всё это вставляется в index.html через официальную точку webServer.tapIndex.
+//
+// Чего здесь намеренно НЕТ — привязки к 0.0.0.0. Она нужна тем, кто ходит на
+// харнесс напрямую, и ставится отдельным слоем в cordis.patch.yml профиля
+// (образец — в нашем cordis.patch.yml). Включать её вслепую нельзя: если
+// перед харнессом стоит обратный прокси на том же порту, они столкнутся.
+
+import z from '@deepseek-ai/schemastery'
+import { readFileSync } from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { startDirectBridge } from './bridge.js'
 
 export const name = 'dsh-lanmode'
-export const inject = []
+export const inject = ['webServer']
+
+export const Config = z.object({
+  mode: z
+    .string()
+    .description('How the browser reaches the harness. '
+      + '"proxy": something in front of it already listens on the network (nginx and friends) — '
+      + 'the plugin only repairs the page. '
+      + '"direct": the plugin also opens a listener of its own on the network and forwards to the '
+      + 'harness, so nothing else is needed.')
+    .default('proxy'),
+  directHost: z
+    .string()
+    .description('mode=direct: which address to listen on. 0.0.0.0 means every interface.')
+    .default('0.0.0.0'),
+  directPort: z
+    .number()
+    .description('mode=direct: which port to listen on. Keep it clear of whatever else is running.')
+    .default(3088),
+  settings: z
+    .boolean()
+    .description('Return the settings service on pages that are not localhost. '
+      + 'This is the part no other plugin does.')
+    .default(true),
+  randomUuid: z
+    .boolean()
+    .description('Provide crypto.randomUUID where the browser withholds it (plain HTTP). '
+      + 'A no-op on HTTPS and on localhost.')
+    .default(true),
+  clipboard: z
+    .boolean()
+    .description('Provide a fallback for navigator.clipboard.writeText on plain HTTP, '
+      + 'so the copy buttons keep working. A no-op where the real one exists.')
+    .default(true),
+})
+
+const here = path.dirname(fileURLToPath(import.meta.url))
 
-export function apply(ctx) {
+/** Заплатка лежит рядом обычным файлом: так её видно и правится она как код. */
+function shimSource() {
+  return readFileSync(path.join(here, 'shim.js'), 'utf8')
+}
+
+/** Namespace, который плагин объявляет: через него режим правится настройками. */
+const NS = 'dsh-lanmode'
+
+export function apply(ctx, config) {
+  // Значения берём из сервиса настроек, если он есть: тогда режим правится
+  // в настройках, а не только в дереве плагинов. Смена режима требует
+  // перезапуска — слушатель поднимается один раз при старте.
+  ctx.inject(['settings'], (sctx) => {
+    let effective = config
+    try {
+      const scope = sctx.settings.register(NS, Config, { base: config })
+      effective = scope.get() ?? config
+    } catch (alreadyRegistered) {
+      effective = config
+    }
+    start(sctx, effective)
+  })
+
+  // Без сервиса настроек тоже должно работать — тогда только дерево плагинов.
   ctx.effect(() => {
-    // eslint-disable-next-line no-console
-    console.info('[dsh-lanmode] установлен: настройки будут работать и на страницах, открытых не с localhost')
+    if (ctx.get && ctx.get('settings')) return () => {}
+    start(ctx, config)
     return () => {}
-  }, 'dsh-lanmode: отметка о запуске')
+  }, 'dsh-lanmode: запуск без сервиса настроек')
+}
+
+function start(ctx, config) {
+  // Прямой режим: свой слушатель на сетевом адресе. В режиме прокси не
+  // поднимаем ничего — сеть уже обслуживает кто-то другой.
+  if (config.mode === 'direct') {
+    ctx.effect(() => startDirectBridge(ctx, {
+      host: config.directHost || '0.0.0.0',
+      port: config.directPort || 3088,
+      // eslint-disable-next-line no-console
+      log: (message) => console.info('[dsh-lanmode] ' + message),
+    }), 'dsh-lanmode: слушатель прямого режима')
+  }
+
+  const pieces = {
+    settings: config.settings !== false,
+    randomUuid: config.randomUuid !== false,
+    clipboard: config.clipboard !== false,
+  }
+  // Ничего не включено — и вставлять нечего.
+  if (!pieces.settings && !pieces.randomUuid && !pieces.clipboard) return
+
+  const script = '<script data-dsh-lanmode="1">'
+    + 'window.__DSH_LANMODE__=' + JSON.stringify(pieces) + ';'
+    + shimSource()
+    + '</script>'
+
+  ctx.effect(() => ctx.webServer.tapIndex((html) => {
+    if (html.includes('data-dsh-lanmode')) return html
+    // Сразу за <head>: заплатка должна отработать раньше всего остального,
+    // иначе заглушка приедет после первого же вызова, который её ждёт.
+    const at = html.indexOf('<head>')
+    if (at === -1) return script + html
+    return html.slice(0, at + '<head>'.length) + script + html.slice(at + '<head>'.length)
+  }), 'dsh-lanmode: вставка заплатки в index.html')
 }

package/lib/shim.js

@@ -0,0 +1,173 @@
+(function () {
+  // Заплатка выполняется первой на странице, до загрузки чего бы то ни было.
+  // Что включено — решает хост-половина, значения приезжают в __DSH_LANMODE__.
+  var options = window.__DSH_LANMODE__ || {}
+
+  // Отладочные переключатели в адресной строке:
+  //   ?lanmode=off    — не вмешиваться совсем (посмотреть, как без плагина);
+  //   ?lanmode=invert — притвориться чужой страницей на своей же
+  //                     (так проверяется, что заплатка правда управляет флагом).
+  var mode = ''
+  try { mode = new URLSearchParams(location.search).get('lanmode') || '' } catch (noSearch) { mode = '' }
+  if (mode === 'off') return
+  var loopbackAnswer = mode !== 'invert'
+
+  // ------------------------------------------------------- crypto.randomUUID
+  //
+  // Приём и заготовка — из dsh-web-lan-access (AcidGr), MIT. Существует только
+  // на защищённом соединении, а интерфейс зовёт его при загрузке: на чистом
+  // HTTP по сетевому адресу без этого не поднимается вообще ничего.
+  if (options.randomUuid) {
+    var crypto_ = globalThis.crypto
+    if (!crypto_) { try { crypto_ = globalThis.crypto = {} } catch (frozen) { crypto_ = null } }
+    if (crypto_ && typeof crypto_.randomUUID !== 'function' && typeof crypto_.getRandomValues === 'function') {
+      crypto_.randomUUID = function randomUUID() {
+        var bytes = new Uint8Array(16)
+        crypto_.getRandomValues(bytes)
+        bytes[6] = (bytes[6] & 15) | 64
+        bytes[8] = (bytes[8] & 63) | 128
+        var hex = ''
+        for (var i = 0; i < 16; i++) hex += bytes[i].toString(16).padStart(2, '0')
+        return hex.slice(0, 8) + '-' + hex.slice(8, 12) + '-' + hex.slice(12, 16)
+          + '-' + hex.slice(16, 20) + '-' + hex.slice(20)
+      }
+    }
+  }
+
+  // ------------------------------------------------------ navigator.clipboard
+  //
+  // Тоже только для защищённого соединения. Без него кнопки «Копировать»
+  // молча ничего не делают; подставляем старый способ через скрытое поле.
+  if (options.clipboard) {
+    var nav = window.navigator
+    if (nav && (!nav.clipboard || typeof nav.clipboard.writeText !== 'function')) {
+      var writeText = function (text) {
+        return new Promise(function (resolve, reject) {
+          try {
+            var area = document.createElement('textarea')
+            area.value = String(text)
+            area.setAttribute('readonly', '')
+            area.style.position = 'fixed'
+            area.style.opacity = '0'
+            document.body.appendChild(area)
+            area.select()
+            var copied = document.execCommand('copy')
+            document.body.removeChild(area)
+            copied ? resolve() : reject(new Error('copy rejected'))
+          } catch (failure) { reject(failure) }
+        })
+      }
+      try {
+        if (nav.clipboard) nav.clipboard.writeText = writeText
+        else Object.defineProperty(nav, 'clipboard', { configurable: true, value: { writeText: writeText } })
+      } catch (cannotDefine) { /* останется как было */ }
+    }
+  }
+
+  // ------------------------------------------------------------- настройки
+  if (!options.settings) return
+
+  // Флаг читают трое, и третьему подменять нельзя: в результатах работы он
+  // решает, можно ли открыть файл локально, и с подменой браузер просил бы
+  // открыть путь на машине сервера. Поэтому — только два настроечных пакета.
+  var TARGETS = [
+    '@deepseek-ai/dsh-client-ui-settings',
+    '@deepseek-ai/dsh-client-ui-settings-general',
+  ]
+
+  function connectionWithForcedFlag(connection) {
+    if (!connection || typeof connection !== 'object') return connection
+    return new Proxy(connection, {
+      get: function (target, prop) {
+        if (prop === 'isLoopback') return loopbackAnswer
+        var value = Reflect.get(target, prop, target)
+        return typeof value === 'function' ? value.bind(target) : value
+      },
+    })
+  }
+
+  function ctxWithForcedConnection(ctx) {
+    return new Proxy(ctx, {
+      get: function (target, prop) {
+        if (prop === 'get') {
+          return function (nameRequested) {
+            var value = target.get(nameRequested)
+            return nameRequested === 'connection' ? connectionWithForcedFlag(value) : value
+          }
+        }
+        if (prop === 'connection') return connectionWithForcedFlag(Reflect.get(target, prop, target))
+        var value = Reflect.get(target, prop, target)
+        return typeof value === 'function' ? value.bind(target) : value
+      },
+    })
+  }
+
+  function wrap(registration) {
+    if (!registration || TARGETS.indexOf(registration.id) === -1) return registration
+    if (typeof registration.factory !== 'function') return registration
+    var factory = registration.factory
+    var patched = {}
+    for (var key in registration) patched[key] = registration[key]
+    patched.factory = function (requireFn) {
+      var moduleExports = factory(requireFn)
+      if (!moduleExports || typeof moduleExports.apply !== 'function') return moduleExports
+      var originalApply = moduleExports.apply
+      moduleExports.apply = function (ctx) {
+        return originalApply.call(this, ctxWithForcedConnection(ctx))
+      }
+      return moduleExports
+    }
+    return patched
+  }
+
+  // Загрузчик подменяет собственный load, когда переходит из режима очереди в
+  // рабочий, — обёртка при этом слетала бы. Поэтому ставим её через
+  // свойство-аксессор: любая новая функция оборачивается снова.
+  function install(loader) {
+    if (!loader || typeof loader !== 'object') return loader
+    if (loader.load && loader.load.__dshLanmode) return loader
+    var wrapped
+
+    function rewrap(fn) {
+      if (typeof fn !== 'function' || fn.__dshLanmode) { wrapped = fn; return }
+      var inner = fn
+      wrapped = function (registration) { return inner.call(this, wrap(registration)) }
+      wrapped.__dshLanmode = true
+    }
+
+    rewrap(loader.load)
+    try {
+      Object.defineProperty(loader, 'load', {
+        configurable: true,
+        get: function () { return wrapped },
+        set: function (fn) { rewrap(fn) },
+      })
+    } catch (cannotDefine) {
+      loader.load = wrapped
+    }
+
+    // Уже поставленные в очередь до нас — тоже наши.
+    if (Array.isArray(loader.pendingQueue)) {
+      for (var i = 0; i < loader.pendingQueue.length; i++) {
+        loader.pendingQueue[i] = wrap(loader.pendingQueue[i])
+      }
+    }
+    return loader
+  }
+
+  if (window.__ModuleLoader__) {
+    install(window.__ModuleLoader__)
+    return
+  }
+  var held
+  try {
+    Object.defineProperty(window, '__ModuleLoader__', {
+      configurable: true,
+      get: function () { return held },
+      set: function (value) { held = install(value) },
+    })
+  } catch (cannotDefine) {
+    // Свойство неподатливо — молчим: страница останется такой же, какой была
+    // без плагина.
+  }
+})()

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@goodandready/dsh-lanmode",
-  "version": "0.1.0",
-  "description": "Settings over the LAN for DeepSeek Harness: the Web UI turns the settings service off on any page that is not localhost, even though the server serves settings over the network just fine. This plugin brings them back.",
+  "version": "0.3.0",
+  "description": "LAN and reverse-proxy access for the DeepSeek Harness Web UI: returns the settings service on pages that are not localhost, fills in the Web APIs the browser withholds on plain HTTP, and can open a listener of its own so nothing else is needed.",
   "license": "MIT",
   "type": "module",
   "main": "./lib/index.js",
   "exports": {
     ".": "./lib/index.js",
-    "./client": "./lib/client.js",
     "./package.json": "./package.json",
     "./cordis.patch.yml": "./cordis.patch.yml"
   },
@@ -23,7 +22,9 @@
     "deepseek-harness",
     "settings",
     "lan",
-    "remote"
+    "remote",
+    "proxy",
+    "nginx"
   ],
   "repository": {
     "type": "git",
@@ -39,15 +40,10 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
-    },
-    "client": {
-      "platform": "web",
-      "inject": [
-        "@deepseek-ai/dsh-client-runtime"
-      ]
     }
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1"
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6"
   }
 }

package/lib/client.js

@@ -1,253 +0,0 @@
-// dsh-lanmode — клиентская половина.
-//
-// Зачем это существует.
-//
-// Веб-интерфейс харнесса отключает настройки на любой странице, открытой не с
-// localhost. Решение принимается в браузере по имени хоста:
-//
-//   isLoopback: pageLocation === undefined || isLoopbackHostname(pageLocation.hostname)
-//
-// и дальше сервис настроек уходит в режим «памяти»: общее зеркало документа
-// никогда не читается, каждый связанный раздел сразу получает статус
-// "unavailable", а запись молча выбрасывается. Внешне это выглядит как пустые
-// карточки настроек у всех плагинов сразу и пустая вкладка «Настройки
-// плагинов» — при полностью исправном сервере.
-//
-// Сервер этого ограничения не разделяет: и чтение (settings.describe), и
-// запись (settings.mutate) по сети работают штатно, если Origin совпадает с
-// адресом страницы — то есть ровно в том случае, когда запрос шлёт сам
-// интерфейс. Проверено на живом харнессе через обратный прокси.
-//
-// Поэтому плагин делает одно: на не-loopback странице поднимает собственный
-// экземпляр той же механики поверх тех же вызовов и отдаёт его как службу.
-// На loopback-странице он не делает ничего — там ядро справляется само.
-
-window.__ModuleLoader__.load({
-  id: '@goodandready/dsh-lanmode',
-  factory: (require) => {
-    var module = { exports: {} }
-    var exports = module.exports
-
-    // ------------------------------------------------- зеркало документа
-    //
-    // Один читатель settings.describe на всю страницу: разделы выводятся из
-    // него, поэтому они не могут разойтись во мнении о документе.
-    function createMirror(api) {
-      let snapshot = { status: 'idle', view: undefined, error: null }
-      const listeners = new Set()
-      let inFlight
-      let rerun = false
-
-      const notify = () => {
-        for (const listener of [...listeners]) {
-          try { listener() } catch (listenerFailure) { /* чужой слушатель нам не судья */ }
-        }
-      }
-      const put = (next) => { snapshot = next; notify() }
-
-      async function run() {
-        do {
-          rerun = false
-          let outcome
-          try {
-            const response = await api.settings.describe({})
-            outcome = response.result.ok
-              ? { view: response.result.value }
-              : { failure: response.result.error.message }
-          } catch (wireFailure) {
-            outcome = { failure: String(wireFailure && wireFailure.message || wireFailure) }
-          }
-          if (outcome.view !== undefined) {
-            put({ status: 'ready', view: outcome.view, error: null })
-          } else {
-            // Держим то, что уже прочитали: неудачное обновление не должно
-            // опустошать готовые разделы.
-            put({ status: snapshot.view === undefined ? 'idle' : 'ready', view: snapshot.view, error: outcome.failure })
-          }
-        } while (rerun)
-      }
-
-      return {
-        getSnapshot: () => snapshot,
-        subscribe: (listener) => {
-          listeners.add(listener)
-          return () => { listeners.delete(listener) }
-        },
-        load() {
-          if (inFlight !== undefined) { rerun = true; return inFlight }
-          inFlight = run().finally(() => { inFlight = undefined })
-          return inFlight
-        },
-        ensure() {
-          if (inFlight !== undefined) return inFlight
-          if (snapshot.status === 'idle') return this.load()
-          return Promise.resolve()
-        },
-        // Ответ на запись возвращает свежий вид одного раздела — вкладываем его
-        // на место, чтобы не перечитывать весь документ ради одного поля.
-        acceptView(view) {
-          const before = snapshot
-          if (before.view === undefined) { this.load(); return }
-          const known = before.view.namespaces.some((row) => row.ns === view.ns)
-          const namespaces = known
-            ? before.view.namespaces.map((row) => (row.ns === view.ns ? view : row))
-            : before.view.namespaces.concat([view])
-          put({ ...before, view: { ...before.view, namespaces } })
-        },
-      }
-    }
-
-    // ------------------------------------------------------- раздел настроек
-    //
-    // Снимок повторяет форму ядрового: status, value, base, user, revision,
-    // writable. Карточки читают именно эти поля, поэтому подмена для них
-    // незаметна.
-    function createScope(api, mirror, namespace) {
-      let snapshot = {
-        status: 'loading',
-        value: undefined,
-        base: undefined,
-        user: undefined,
-        revision: undefined,
-        writable: false,
-        mode: 'host',
-      }
-      const listeners = new Set()
-      const notify = () => {
-        for (const listener of [...listeners]) {
-          try { listener() } catch (listenerFailure) { /* см. выше */ }
-        }
-      }
-
-      function derive() {
-        const held = mirror.getSnapshot()
-        if (held.view === undefined) return
-        const row = held.view.namespaces.find((candidate) => candidate.ns === namespace)
-        if (row === undefined) {
-          // Хост про такой раздел не знает. Это законное состояние: плагин
-          // может быть ещё не применён.
-          snapshot = { ...snapshot, status: 'unavailable', writable: held.view.writable }
-          notify()
-          return
-        }
-        snapshot = {
-          status: 'ready',
-          value: row.value,
-          base: row.base,
-          user: row.user,
-          revision: row.revision,
-          writable: held.view.writable,
-          mode: 'host',
-        }
-        notify()
-      }
-
-      const off = mirror.subscribe(derive)
-      derive()
-
-      // Записи выстраиваем в очередь: правка ревизии, пришедшая из ответа,
-      // должна попасть в следующий запрос, иначе хост отвергнет его как
-      // устаревший.
-      let tail = Promise.resolve()
-      function write(op) {
-        const task = tail.then(async () => {
-          const revision = snapshot.revision
-          let response
-          try {
-            response = await api.settings.mutate({
-              ns: namespace,
-              ops: [op],
-              ...(revision === undefined ? {} : { expectedRevision: revision }),
-            })
-          } catch (wireFailure) {
-            await mirror.load()
-            throw wireFailure
-          }
-          if (!response.result.ok) {
-            // Чаще всего это разошедшаяся ревизия: перечитываем и отдаём
-            // ошибку наверх, чтобы карточка показала неудачу сохранения.
-            await mirror.load()
-            throw new Error(response.result.error.message)
-          }
-          mirror.acceptView(response.result.value)
-        })
-        tail = task.catch(() => {})
-        return task
-      }
-
-      return {
-        getSnapshot: () => snapshot,
-        subscribe: (listener) => {
-          listeners.add(listener)
-          return () => { listeners.delete(listener) }
-        },
-        set: (field, value) => write({ op: 'set', path: [field], value }),
-        unset: (field) => write({ op: 'unset', path: [field] }),
-        dispose: () => { off() },
-      }
-    }
-
-    exports.inject = ['connection']
-
-    // Отладочный переключатель: включает режим и на loopback-странице, где
-    // ядро и без нас справляется. Нужен, чтобы проверить сам плагин там, где
-    // это удобно сделать:
-    //
-    //   localStorage.setItem('dsh-lanmode:force', '1'); location.reload()
-    //
-    // В обычной работе не нужен и по умолчанию выключен.
-    function forcedOn() {
-      try { return window.localStorage.getItem('dsh-lanmode:force') === '1' }
-      catch (noStorage) { return false }
-    }
-
-    exports.apply = function apply(ctx) {
-      const connection = ctx.get('connection')
-
-      // На loopback-странице ядро работает штатно, и вмешиваться незачем.
-      if (connection.isLoopback && !forcedOn()) return
-
-      const mirror = createMirror(connection.api)
-      const binder = {
-        bind: (spec) => createScope(connection.api, mirror, spec && spec.namespace),
-        describe: () => mirror,
-      }
-
-      // Документ меняют не только из этой вкладки; ядро слушает тот же сигнал.
-      try {
-        const remote = ctx.get('remote')
-        if (remote && typeof remote.$on === 'function') {
-          ctx.effect(() => remote.$on('settings/document-updated', () => { mirror.load() }),
-            'dsh-lanmode: перечитывать документ настроек по сигналу хоста')
-        }
-      } catch (noRemoteService) { /* без сигнала обойдёмся, останется ручное перечитывание */ }
-
-      mirror.ensure()
-
-      // Своя служба: ею может пользоваться любой плагин, которому нужны
-      // настройки по сети.
-      ctx.provide('lanSettings', binder)
-
-      // Попытка встать на место ядровой службы. Если разрешено — оживает весь
-      // интерфейс настроек разом, включая чужие плагины и вкладку ядра.
-      // Если ядро не отдаёт имя, остаёмся со своей службой: наши плагины
-      // умеют её спрашивать.
-      let tookOver = false
-      try {
-        ctx.provide('settingsScope', binder)
-        tookOver = true
-      } catch (nameTaken) {
-        tookOver = false
-      }
-
-      // Одна строка в консоли: без неё непонятно, работает режим или нет.
-      try {
-        console.info('[dsh-lanmode] режим включён (' + location.hostname + (connection.isLoopback ? ', принудительно' : '') + '); '
-          + 'настройки подняты через сеть, ядровая служба '
-          + (tookOver ? 'подменена' : 'оставлена как есть'))
-      } catch (noConsole) { /* незачем */ }
-    }
-
-    return module.exports
-  },
-})