dsh-multi-chat 1.0.5 → 1.0.7

package/README.md

@@ -49,7 +49,8 @@ Install a **multi-window wall** into the official [DeepSeek Harness (DSH)](https
 
 ```bash
 # 1. Install — ONE command straight from the npm registry (no CLI to download):
-dsh plugin --profile web add dsh-multi-chat
+dsh plugin --profile web add dsh-multi-chat       # for `dsh web`
+dsh plugin --profile desktop add dsh-multi-chat   # for the Desktop app
 
 #    …or via the plugin's own npx CLI (packs a tarball and installs it):
 npx dsh-multi-chat install
@@ -114,6 +115,29 @@ dsh plugin --profile web remove dsh-multi-chat
 3. Inside the wall view: auto-discovery (own port excluded), column switching (auto/1/2/3/4/6, horizontally filled by default), click title to maximize, ⟳ refresh one, ↗ open in a new tab, ✕ remove from view, refresh all, and live online status dots. The layout is persisted to `localStorage`.
 4. To exit the wall, click the **"Exit" button in the toolbar's top-right** to switch back to the chat view in one click.
 
+## Launch tokens (DSH 0.2)
+
+Since DSH 0.2, every `dsh web` process mints a **launch token**, answers an unauthenticated `/` with **401**, and only then serves the shell. An unauthenticated liveness probe therefore sees every real instance as dead, and the wall stays empty.
+
+The wall presents the token automatically. `dsh-multi-chat start` reads each instance's token off its console and records it in `$DSH_HOME/multi-wall-instances.json`, which the node half picks up — no configuration needed:
+
+```bash
+dsh-multi-chat start --ports 3080,3081   # tokens captured automatically
+```
+
+Instances you start **some other way** must be listed by hand, either by editing that same JSON file or via the profile patch:
+
+```yaml
+- id: ui-multi-wall
+  name: dsh-multi-chat
+  config:
+    tokens:
+      "3085": "<the token dsh web printed>"
+      "3086": "<the token dsh web printed>"
+```
+
+Tokens are per-process: restarting an instance mints a new one, so re-read it from that instance's startup output. `dsh-multi-chat start` also keeps each instance's full console log in `$DSH_HOME/multi-wall-logs/instance-<port>.log`.
+
 ## Phone / remote access (built-in authenticated gateway)
 
 The official `dsh web` **deliberately forbids `--host 0.0.0.0`** (it would expose remote code execution to the network). This plugin ships a built-in **token-authenticated intranet gateway**: click the "Phone access" button and it **automatically** starts a gateway for the current instance (listening on `0.0.0.0`, reverse-proxying to `127.0.0.1:<this instance's port>`), returning a LAN URL + login token.
@@ -134,7 +158,19 @@ Open that URL on your phone and enter the token to reach the full DSH UI. The ga
 
 ## Distribution & install
 
-`dsh-multi-chat` is published to npm (unscoped public package) and released on GitHub (source zip/tarball per tag). Every channel below ends in the same three things: the package lands as a dependency of the web profile, DSH reconciles it into the bundle layer stack (the package declares `dsh.bundle.patch`, so its own `cordis.patch.yml` is mounted automatically — no manual patch edits), and a `dsh web` restart loads the wall.
+`dsh-multi-chat` is published to npm (unscoped public package) and released on GitHub (source zip/tarball per tag). Every channel below ends in the same three things: the package lands as a dependency of the target profile, DSH reconciles it into the bundle layer stack (the package declares `dsh.bundle.patch`, so its own `cordis.patch.yml` is mounted automatically — no manual patch edits), and a restart of that profile loads the wall.
+
+### Which profile? (`web` or `desktop`)
+
+Both work, and they run the **same** browser surface with the **same** platform module table:
+
+| | `web` (`dsh web`) | `desktop` (the Desktop app) |
+|---|---|---|
+| Host half — `/multi/api/*` routes | ✅ needs the `webServer` service | ✅ `dsh-web-app` provides it |
+| Browser half — slot registrations | ✅ | ✅ identical seed table |
+| Marketplace listing | ✅ | ✅ |
+
+Swap `--profile web` for `--profile desktop` in any command below. `dshmarket` is the precedent: it ships the same `dsh.client.platform: "web"` manifest and runs in both.
 
 ### Install / uninstall cheat-sheet
 
@@ -146,6 +182,8 @@ Open that URL on your phone and enter the token to reach the full DSH UI. The ga
 | **Tarball (offline)** | `npm pack` → `dsh plugin --profile web add ./dsh-multi-chat-*.tgz` | `dsh plugin --profile web remove dsh-multi-chat` |
 | **Git clone** | `node bin/dsh-multi-chat.mjs install` | `dsh plugin --profile web remove dsh-multi-chat` |
 
+> Every row takes `--profile desktop` as well; see [Which profile?](#which-profile-web-or-desktop).
+
 > `dsh plugin --profile web remove dsh-multi-chat` is the **single uninstall
 > command for every channel**: it removes the dependency from the profile, and
 > DSH strips it from the `dsh.profile.bundles` layer stack automatically

package/README.zh.md

@@ -49,7 +49,8 @@
 
 ```bash
 # 1. 安装 —— 从 npm 官方源一条命令搞定（无需下载任何 CLI）：
-dsh plugin --profile web add dsh-multi-chat
+dsh plugin --profile web add dsh-multi-chat       # 适用于 dsh web
+dsh plugin --profile desktop add dsh-multi-chat   # 适用于桌面版应用
 
 #    ……或通过插件自带的 npx CLI（先打包再安装）：
 npx dsh-multi-chat install
@@ -114,6 +115,29 @@ dsh plugin --profile web remove dsh-multi-chat
 3. 墙视图内：自动发现实例（自动排除自身端口）、列数切换（自动/1/2/3/4/6，默认横向铺满）、点标题放大、⟳ 单独刷新、↗ 新标签页打开、✕ 从视图移除、全部刷新、实时在线状态点。布局保存在 localStorage。
 4. 退出墙：点工具栏**右上角的「退出」按钮**，一键切回对话视图。
 
+## 启动令牌（DSH 0.2）
+
+从 DSH 0.2 起，每个 `dsh web` 进程会生成一个**启动令牌（launch token）**，不带令牌的 `/` 请求会得到 **401**，只有带上令牌才返回界面。因此不带令牌的探活会把**每一个真实运行中的实例**都判成离线，墙就会一直是空的。
+
+墙会自动带上这个令牌。用 `dsh-multi-chat start` 启动时，它会从各实例的控制台读到令牌并记录到 `$DSH_HOME/multi-wall-instances.json`，node 半边会自动读取，无需任何配置：
+
+```bash
+dsh-multi-chat start --ports 3080,3081   # 令牌自动捕获
+```
+
+用**其他方式**启动的实例需要手动登记 —— 可以直接编辑上面那个 JSON 文件，或者在 profile 的 patch 层里写：
+
+```yaml
+- id: ui-multi-wall
+  name: dsh-multi-chat
+  config:
+    tokens:
+      "3085": "<dsh web 启动时打印的令牌>"
+      "3086": "<dsh web 启动时打印的令牌>"
+```
+
+令牌是**每进程**的：重启实例会生成新的，记得从该实例的启动输出里重新读取。`dsh-multi-chat start` 同时会把每个实例的完整控制台日志留在 `$DSH_HOME/multi-wall-logs/instance-<port>.log`。
+
 ## 手机 / 远程访问（内置认证网关）
 
 官方 `dsh web` 出于安全**刻意禁止 `--host 0.0.0.0`**（会向网络暴露远程代码执行）。本插件内置了一个**带令牌认证的内联网关**：点工具栏「手机访问」按钮，它会**自动**为本实例启动一个网关（监听 `0.0.0.0`，反向代理到 `127.0.0.1:<本实例端口>`），并返回局域网 URL + 登录口令。
@@ -134,7 +158,19 @@ dsh plugin --profile web remove dsh-multi-chat
 
 ## 分发与安装
 
-`dsh-multi-chat` 已发布到 npm（无作用域公开包），并在 GitHub 按 tag 发布 Release（源码 zip/tarball）。下面每条渠道殊途同归：包成为 web profile 的依赖 → DSH 自动调和进 bundle 层栈（包声明了 `dsh.bundle.patch`，自带 `cordis.patch.yml` 自动挂载，无需手改任何文件）→ 重启 `dsh web` 生效。
+`dsh-multi-chat` 已发布到 npm（无作用域公开包），并在 GitHub 按 tag 发布 Release（源码 zip/tarball）。下面每条渠道殊途同归：包成为目标 profile 的依赖 → DSH 自动调和进 bundle 层栈（包声明了 `dsh.bundle.patch`，自带 `cordis.patch.yml` 自动挂载，无需手改任何文件）→ 重启该 profile 生效。
+
+### 用哪个 profile？（`web` 还是 `desktop`）
+
+两者都支持，而且跑的是**同一套**浏览器界面、**同一张**平台模块表：
+
+| | `web`（`dsh web`） | `desktop`（桌面版应用） |
+|---|---|---|
+| 宿主侧 —— `/multi/api/*` 路由 | ✅ 依赖 `webServer` 服务 | ✅ `dsh-web-app` 已提供 |
+| 浏览器侧 —— slot 注册 | ✅ | ✅ seed 表完全相同 |
+| 市场列表展示 | ✅ | ✅ |
+
+下面任何命令把 `--profile web` 换成 `--profile desktop` 即可。可参照的先例是 `dshmarket`：它同样声明 `dsh.client.platform: "web"`，却在两端都正常运行。
 
 ### 安装 / 卸载速查表
 
@@ -146,6 +182,8 @@ dsh plugin --profile web remove dsh-multi-chat
 | **Tarball（离线）** | `npm pack` → `dsh plugin --profile web add ./dsh-multi-chat-*.tgz` | `dsh plugin --profile web remove dsh-multi-chat` |
 | **Git clone** | `node bin/dsh-multi-chat.mjs install` | `dsh plugin --profile web remove dsh-multi-chat` |
 
+> 上表每一行都可以换成 `--profile desktop`；详见[用哪个 profile？](#用哪个-profileweb-还是-desktop)。
+
 > `dsh plugin --profile web remove dsh-multi-chat` 是**所有渠道统一的卸载命令**：
 > 它从 profile 移除依赖，DSH 会自动把它从 `dsh.profile.bundles` 层栈里剔除
 > （层栈按已安装依赖实时调和，详见 `dsh plugin --help`）。之后重启 `dsh web` 卸载生效。

package/bin/dsh-multi-chat.mjs

@@ -22,7 +22,7 @@
 
 import { spawn, spawnSync } from 'node:child_process'
 import { createServer as createNetServer } from 'node:net'
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdirSync, openSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs'
 import { homedir, networkInterfaces } from 'node:os'
 import { join, dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -62,9 +62,10 @@ function dshHome() {
 
 function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)) }
 
-async function probe(port, timeoutMs = 600) {
+async function probe(port, token = null, timeoutMs = 600) {
+  const url = token === null ? `http://127.0.0.1:${port}/` : `http://127.0.0.1:${port}/?token=${encodeURIComponent(token)}`
   try {
-    const res = await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(timeoutMs) })
+    const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) })
     const body = await res.text()
     return res.status === 200 && body.includes('__DSH_BOOT__')
   } catch {
@@ -72,19 +73,27 @@ async function probe(port, timeoutMs = 600) {
   }
 }
 
-async function waitReady(port, timeoutMs = 20000) {
+async function waitReady(port, token = null, timeoutMs = 60000) {
   const deadline = Date.now() + timeoutMs
   for (;;) {
-    if (await probe(port)) return true
+    // A cold instance accepts the connection but needs noticeably longer than
+    // a warm one to assemble index.html, so the readiness probe gets its own
+    // generous budget; `probe`'s 600ms default is tuned for the wall's liveness
+    // polls against already-running instances, not for boot detection.
+    if (await probe(port, token, 10000)) return true
     if (Date.now() > deadline) return false
     await sleep(400)
   }
 }
 
-function spawnDetached(file, args, { shell = false } = {}) {
+function spawnDetached(file, args, { shell = false, logFile = null } = {}) {
+  // A log file is requested by handing `spawn` the file descriptors, not with
+  // the shell's `>` syntax: a DETACHED shell does not pass our stdio handles on
+  // to the process it wraps, so the redirect silently produces an empty file.
+  const stdio = logFile === null ? 'ignore' : ['ignore', openSync(logFile, 'a'), openSync(logFile, 'a')]
   const child = spawn(file, args, {
     detached: true,
-    stdio: 'ignore',
+    stdio,
     windowsHide: true,
     shell,
   })
@@ -92,6 +101,76 @@ function spawnDetached(file, args, { shell = false } = {}) {
   return child.pid
 }
 
+/**
+ * Resolve the `dsh` CLI's JavaScript entry so an instance can be launched as
+ * `node <entry> web --port <n>` with no shell in between.
+ *
+ * Two reasons this is not optional: on Windows Node refuses to execute the
+ * `dsh.cmd` shim without a shell, and once a shell IS involved the detached
+ * child never receives the stdio handles carrying the launch token. Spawning
+ * the entry directly gives the instance an inherited log handle, which is how
+ * `readLaunchToken` below gets to see the token.
+ * @returns the absolute path to the CLI entry, or null when it cannot be found.
+ */
+function dshCliEntry() {
+  const lookup = spawnSync(isWin ? 'where' : 'which', ['dsh'], { encoding: 'utf8' })
+  const shim = (lookup.stdout ?? '').split(/\r?\n/).map(line => line.trim()).find(Boolean)
+  if (shim === undefined) return null
+  const candidates = isWin
+    // <npm-bin>\dsh.cmd  ->  <npm-bin>\node_modules\@deepseek-ai\dsh\lib\bin.js
+    ? [join(dirname(shim), 'node_modules', '@deepseek-ai', 'dsh', 'lib', 'bin.js')]
+    // <prefix>/bin/dsh is a symlink to .../lib/node_modules/@deepseek-ai/dsh/lib/bin.js
+    : [
+      (() => { try { return join(realpathSync(shim), '..', 'bin.js') } catch { return '' } })(),
+      join(dirname(shim), '..', 'lib', 'node_modules', '@deepseek-ai', 'dsh', 'lib', 'bin.js'),
+    ]
+  return candidates.find(candidate => candidate !== '' && existsSync(candidate)) ?? null
+}
+
+/**
+ * Each `dsh web` process mints one launch token at boot and prints it as
+ * `dsh web: http://127.0.0.1:<port>/?token=<tok>`. Since DSH 0.2 every
+ * instance answers an unauthenticated `/` with 401, so the wall's liveness
+ * probe must present this token or it will mark every instance dead.
+ *
+ * The token is per-process and is never persisted by DSH, so we read it off
+ * the instance's own console output — hence the log file: piping stdout would
+ * leave the detached child writing into a pipe nobody drains once this
+ * process exits.
+ */
+const LAUNCH_TOKEN_RE = /\/\?token=([A-Za-z0-9_-]+)/
+
+async function readLaunchToken(logFile, port, timeoutMs = 30000) {
+  const deadline = Date.now() + timeoutMs
+  const needle = `127.0.0.1:${port}/?token=`
+  for (;;) {
+    let text = ''
+    try { text = readFileSync(logFile, 'utf8') } catch { /* not created yet */ }
+    if (text !== '') {
+      // Match only this port's line: every instance shares one log-free
+      // console, and another port's token would authenticate nothing.
+      const line = text.split(/\r?\n/).find(l => l.includes(needle))
+      const match = line === undefined ? null : LAUNCH_TOKEN_RE.exec(line)
+      if (match !== null) return match[1]
+    }
+    if (Date.now() > deadline) return null
+    await sleep(400)
+  }
+}
+
+/**
+ * The wall runs inside the profile's copy of this package while the CLI may
+ * run from an npx cache, so a package-relative file would never be shared.
+ * `$DSH_HOME` is the one location both sides resolve identically.
+ */
+const INSTANCES_FILE = () => join(dshHome(), 'multi-wall-instances.json')
+
+function writeInstanceTokens(tokens) {
+  const file = INSTANCES_FILE()
+  mkdirSync(dirname(file), { recursive: true })
+  writeFileSync(file, JSON.stringify({ updatedAt: new Date().toISOString(), tokens }, null, 2), 'utf8')
+}
+
 function killPid(pid) {
   if (isWin) {
     spawnSync('taskkill', ['/PID', String(pid), '/F', '/T'], { stdio: 'ignore' })
@@ -254,23 +333,50 @@ async function cmdStart(args) {
     process.stdout.write(`[start] generated gateway token: ${token}  (save it!)\n`)
   }
 
-  // Resolve the dsh launcher once (shell on Windows resolves the .cmd shim).
+  // Resolve the dsh launcher once. The shell form only resolves the .cmd shim;
+  // it is the fallback for when the CLI entry cannot be located.
   const dshFile = 'dsh'
   const dshShell = isWin
+  const dshEntry = dshCliEntry()
 
   const state = { pid: [], ports: [], gateways: [], startedAt: new Date().toISOString() }
   const started = []
 
+  const tokens = {}
+  const logDir = join(dshHome(), 'multi-wall-logs')
+  mkdirSync(logDir, { recursive: true })
+
   for (const port of ports) {
-    const pid = spawnDetached(dshFile, ['web', '--port', String(port)], { shell: dshShell })
+    const logFile = join(logDir, `instance-${port}.log`)
+    // Prefer the shell-free form: only then does the instance inherit the log
+    // handle and its launch token become readable to `readLaunchToken`.
+    const pid = dshEntry === null
+      ? spawnDetached(dshFile, ['web', '--port', String(port)], { shell: dshShell, logFile })
+      : spawnDetached(process.execPath, [dshEntry, 'web', '--port', String(port)], { logFile })
     state.pid.push(pid)
     state.ports.push(port)
     process.stdout.write(`dsh web --port ${port} (pid ${pid})\n`)
-    const ready = await waitReady(port)
-    if (!ready) process.stdout.write(`  ⚠ instance on :${port} did not answer the DSH shell yet — check its console\n`)
+    if (dshEntry === null) {
+      process.stdout.write('  ⚠ dsh CLI entry not resolvable; launch-token capture unavailable\n')
+    }
+    // Read the launch token before probing: an unauthenticated request answers
+    // 401, which would report every freshly started instance as dead.
+    const token = await readLaunchToken(logFile, port)
+    if (token !== null) tokens[port] = token
+    const ready = await waitReady(port, token, 60000)
+    if (!ready) {
+      process.stdout.write(`  ⚠ instance on :${port} did not answer the DSH shell yet — check ${logFile}\n`)
+    } else {
+      process.stdout.write(`  ✓ ready${token === null ? ' (no launch token printed)' : ' (launch token captured)'}\n`)
+    }
     started.push(port)
   }
 
+  if (Object.keys(tokens).length > 0) {
+    writeInstanceTokens(tokens)
+    process.stdout.write(`instance tokens saved to ${INSTANCES_FILE()}\n`)
+  }
+
   if (opts.remote) {
     const explicitGatewayPorts = opts.gatewayPorts !== null
       ? opts.gatewayPorts.split(',').map(p => p.trim()).filter(p => /^\d+$/.test(p)).map(Number)

package/lib/index.js

@@ -1,7 +1,8 @@
 import { execFile, spawn } from "node:child_process";
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
 import { existsSync, readFileSync, readdirSync, readlinkSync } from "node:fs";
-import { networkInterfaces } from "node:os";
+import { homedir, networkInterfaces } from "node:os";
+import { join } from "node:path";
 import z from "@deepseek-ai/schemastery";
 import { connect, createServer } from "node:net";
 
@@ -491,10 +492,37 @@ const Config = z.object({
 	ports: z.array(z.natural()).default([]),
 	publicUrl: z.string().default(""),
 	gatewayPort: z.number().default(0),
-	gatewayToken: z.string().default("")
+	gatewayToken: z.string().default(""),
+	tokens: z.dict(z.string()).default({})
 });
 /** MIME for JSON probe answers. */
 const JSON_TYPE = "application/json; charset=utf-8";
+/** Where `dsh-multi-chat start` records the tokens it captured. */
+const INSTANCE_TOKENS_FILE = "multi-wall-instances.json";
+/**
+
+* Launch tokens published by `dsh-multi-chat start`, keyed by port.
+
+*
+
+* `$DSH_HOME` is the only path both the CLI (which may run from an npx cache)
+
+* and this plugin (installed inside the profile) resolve identically, so the
+
+* handoff has to live there rather than beside either package.
+
+*/
+function launchTokensFromFile() {
+	const home = process.env.DSH_HOME !== void 0 && process.env.DSH_HOME !== "" ? process.env.DSH_HOME : join(homedir(), ".dsh");
+	try {
+		const parsed = JSON.parse(readFileSync(join(home, INSTANCE_TOKENS_FILE), "utf8"));
+		const tokens = {};
+		for (const [port, token] of Object.entries(parsed.tokens ?? {})) if (/^\d+$/.test(port) && typeof token === "string" && token !== "") tokens[port] = token;
+		return tokens;
+	} catch {
+		return {};
+	}
+}
 /** GET one local URL with a short timeout; resolve {status, body} or reject. */
 async function request(url, timeoutMs = 600) {
 	const controller = new AbortController();
@@ -509,10 +537,23 @@ async function request(url, timeoutMs = 600) {
 		clearTimeout(timer);
 	}
 }
-/** Is this local port a live DSH instance (index.html carries __DSH_BOOT__)? */
-async function probePort(port) {
+/**
+
+* Is this local port a live DSH instance?
+
+*
+
+* DSH 0.2 requires the per-process launch token: `/` answers 401 without it,
+
+* which would make every real instance look dead. When a token is known the
+
+* probe presents it; 200 + `__DSH_BOOT__` then means alive as before.
+
+*/
+async function probePort(port, token) {
+	const url = token === void 0 || token === "" ? `http://127.0.0.1:${port}/` : `http://127.0.0.1:${port}/?token=${encodeURIComponent(token)}`;
 	try {
-		const { status, body } = await request(`http://127.0.0.1:${port}/`);
+		const { status, body } = await request(url);
 		return {
 			port,
 			alive: status === 200 && body.includes("__DSH_BOOT__"),
@@ -527,10 +568,10 @@ async function probePort(port) {
 	}
 }
 /** Concurrent probe of many ports (bounded chunking). */
-async function probePorts(ports) {
+async function probePorts(ports, tokens = {}) {
 	const CHUNK = 16;
 	const out = [];
-	for (let i = 0; i < ports.length; i += CHUNK) out.push(...await Promise.all(ports.slice(i, i + CHUNK).map((port) => probePort(port))));
+	for (let i = 0; i < ports.length; i += CHUNK) out.push(...await Promise.all(ports.slice(i, i + CHUNK).map((port) => probePort(port, tokens[String(port)]))));
 	return out;
 }
 /** Send a small JSON response. */
@@ -1062,6 +1103,10 @@ function apply(ctx, config = {}) {
 	const fixedPorts = config.ports ?? [];
 	let gateway = null;
 	let gatewayTargetPort = -1;
+	const tokensFor = () => ({
+		...launchTokensFromFile(),
+		...config.tokens ?? {}
+	});
 	ctx.effect(() => ctx.webServer.register({
 		kind: "exact",
 		path: "/multi/api/ports",
@@ -1080,7 +1125,7 @@ function apply(ctx, config = {}) {
 			const hi = Number.isInteger(qTo) ? qTo : scanTo;
 			const ports = fixedPorts.length > 0 ? [...fixedPorts] : [];
 			if (fixedPorts.length === 0) for (let p = lo; p <= hi; p++) ports.push(p);
-			probePorts(ports).then((results) => {
+			probePorts(ports, tokensFor()).then((results) => {
 				json(res, { ports: results.filter((row) => row.alive) });
 			}).catch(() => json(res, { ports: [] }, 500));
 		}
@@ -1096,7 +1141,7 @@ function apply(ctx, config = {}) {
 			}
 			const url = new URL(req.url ?? "/", "http://x");
 			const ports = (url.searchParams.get("ports") ?? "").split(",").map(Number).filter((p) => Number.isInteger(p) && p > 0);
-			probePorts(ports).then((results) => {
+			probePorts(ports, tokensFor()).then((results) => {
 				json(res, { ports: results });
 			}).catch(() => json(res, { ports: [] }, 500));
 		}