dsh-desktop-link 0.0.0-stage → 1.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lzlrt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,197 @@
-# Temporary Holding Version
+# dsh-desktop-link
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+在 **DeepSeek Harness（DSH）** 的侧栏底部加两个按钮：一个点一下就在系统浏览器 / 新标签页里打开**桌面版 DSH** 的 Web GUI，另一个（齿轮）用来**在界面里直接填地址**。
+
+专门为 **DSHA（DeepSeek Harness 安卓启动器）** 设计 —— 在手机上的 DSHA 里点这个按钮，会交给系统浏览器打开你电脑上的 DSH，而 DSHA 自己那套 agent 照常独立运行。
+
+```
+🖥 →  桌面版      ⚙
+```
+
+[![npm](https://img.shields.io/npm/v/dsh-desktop-link?color=cb3837&logo=npm)](https://www.npmjs.com/package/dsh-desktop-link)
+[![license](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+
+```sh
+dsh plugin --profile web add dsh-desktop-link
+```
+
+---
+
+## 它解决什么
+
+DSHA 的内置浏览器只导航它自己的 `http://127.0.0.1:<端口>`，没有「填个网址去连别的机器」的入口。
+但 DSHA 本来就有这条规则：**顶层导航离开本机 DSH 服务时，交给系统浏览器**（`WebPreviewActivity.shouldOverrideUrlLoading` → `ACTION_VIEW`）。
+
+这个插件就是给这条已有规则加一个按钮入口 —— 不改 DSHA、不需要 root、不需要 `am start`。
+
+---
+
+## 行为
+
+| 点击环境 | 结果 |
+|---|---|
+| **手机**（DSHA 的 WebView 或手机浏览器） | 导航离开 DSH 服务 → DSHA 交给系统浏览器 → 打开桌面版 GUI |
+| **电脑浏览器** | `target="_blank"` 开新标签页，当前 GUI 不受影响 |
+
+未配置地址时按钮变灰；此时点它会直接打开齿轮那个设置框，不会跳到一个死链。
+
+---
+
+## 安装
+
+### 从 npm（推荐）
+
+```sh
+dsh plugin --profile web add dsh-desktop-link
+```
+
+### 从本仓库（开发循环）
+
+```sh
+git clone https://github.com/lzlrt/dsha-desktop-link
+dsh plugin --profile web add link:$(pwd)/dsha-desktop-link
+```
+
+### 从打包好的 tgz
+
+```sh
+dsh plugin --profile web add /path/to/dsh-desktop-link-1.2.0.tgz
+```
+
+### 装到手机上的 DSHA
+
+DSHA → 插件 → 添加 → 粘贴一个能下到这个包的 URL，例如：
+
+```
+https://registry.npmjs.org/dsh-desktop-link/-/dsh-desktop-link-1.2.0.tgz
+```
+
+或在 DSHA 插件页直接填包名 `dsh-desktop-link`。
+
+或从本地导入（`adb push` 到 `/sdcard/Download/` 后在插件页选文件）。
+
+装完在插件管理页点「重启 Web」。
+
+---
+
+## 配置地址
+
+### 在界面上填（手机推荐）
+
+点侧栏底部那个**齿轮** → 填两个框 → 保存。写盘、立即生效，不用重启、不用碰命令行。
+
+```
+┌─────────────────────────────┐
+│ 桌面版地址                    │
+│ 填一次就存在这台电脑上，手机和电脑都读同一份。 │
+│ 当前生效（桌面地址文件）：https://…          │
+│                             │
+│ 桌面版地址                    │
+│ [https://xxxx.dsh-market.com] │
+│ 长期地址，留空则自动用固定中继。   │
+│                             │
+│ 点按钮时打开的地址              │
+│ [https://…/open.html?k=…    ] │
+│ 留空就等于上面的地址。          │
+│                   [取消] [保存] │
+└─────────────────────────────┘
+```
+
+保存会写进 `$DSH_HOME/desktop-url.txt`（先写临时文件再 rename，半个文件不会被读走）。
+两个框都清空 = 删掉该文件，退回自动探测。
+
+### 用配置文件
+
+插件自身不带默认地址 —— 它从下面这些地方按顺序找，命中即停：
+
+| 优先级 | 来源 |
+|---|---|
+| 1 | 本行 `config.desktopUrl` / `config.launchUrl`（profile 补丁里） |
+| 2 | 环境变量 `DSH_DESKTOP_URL` / `DSH_DESKTOP_LAUNCH_URL` |
+| 3 | `$DSH_HOME/desktop-url.txt` 第 1 行（桌面地址）/ 第 2 行（点击时打开的地址） |
+| 4 | `$DSH_HOME/remote-web-ui-registry/web.json` 的 `id` → `https://<id>.dsh-market.com`（仅当装了 `dsh-remote-web-ui` 并开了固定域名中继） |
+
+`desktop-url.txt` 是最好改的一个 —— **改完刷新页面即生效**，不用重启：
+
+```text
+# 第一行：桌面版长期地址（书签、复制链接用）
+https://your-desktop.example.com
+
+# 第二行（可选）：点按钮时真正打开的地址。
+# 指向一个「每次铸新配对码」的端点，未配对的手机也能一次进。
+https://your-desktop.example.com/pair-entry
+```
+
+只写一行 = 按钮直接开那一行。删掉文件 = 退回优先级 4。
+
+### 两种地址的区别
+
+| 字段 | 用途 |
+|---|---|
+| `desktopUrl` | 长期地址。锚点的 `href` 用它，中间键 / 复制链接 / 收藏都按这个走 |
+| `launchUrl` | 点击时实际打开的地址。可以是一个会临时铸码的端点，让从未配对过的设备也能一次进入 |
+
+没配 `launchUrl` 时它等于 `desktopUrl`。
+
+---
+
+## 未配对的手机会看到 401
+
+DSH 的远程访问是要配对的。未配对设备直接打开桌面地址会被 harness 的认证栅栏拒绝 —— 这是配对机制正常工作，不是这个插件的 bug。
+
+三种处理方式：
+
+1. **先配对一次**：配对 cookie 默认有效期一年，之后点按钮直接进。
+2. **配 `launchUrl` 指向铸码端点**：每次点击拿新码，永远有效。
+3. **手机端自动铸码**：若本机装了 `dsh-remote-web-ui`，手机点击时插件会先调同源 `/api/pair/issue` 铸一枚一次性码再跳转（该接口只应答回环，所以页面能直接调）。没装则自动退回直接打开 `desktopUrl`。
+
+---
+
+## 接口
+
+| 方法 | 路径 | 说明 |
+|---|---|---|
+| GET | `/api/desktop-link/info` | `{"ok":true,"launchUrl":"…","desktopUrl":"…","source":"…"}` |
+| POST | `/api/desktop-link/config` | body `{"desktopUrl":"…","launchUrl":"…"}` → 写入 `desktop-url.txt`，返回写入后的解析结果与 `path` |
+
+POST 只接受 `http(s)` URL：传了非空值但格式不对会返回 `400` 并说明原因，不会静默清空。
+请求体上限 8 KiB，非 `POST` 返回 `405`。
+
+每次请求重新解析地址，所以改配置文件不需要重启。
+另外 Host 半区会在 `webserver/index-inject` 里注入 `globalThis.__DSHA_DESKTOP_LINK__`，让按钮首帧就能拿到地址；全局缺失时 Client 半区回退到上面那个接口。
+
+---
+
+## 结构
+
+```
+package.json          清单：dsh.bundle.patch + dsh.client(platform: web)
+cordis.patch.yml      插入一行 dsha-desktop-link
+index.js              Host 半区：地址解析 + /info + /config + index 全局
+client.js             Client 半区：注册 sidebar.footer.action ×2 + 设置框
+icon.svg              显示器 + 外跳箭头
+locale/{zh,en}.json   meta.title / meta.description
+```
+
+### 实现要点
+
+- 注册 `sidebar.footer.action` 两次（`replaceRisk: none`）：启动按钮 `order: 10`，齿轮 `order: 11`，都排在官方「远程访问」之后。
+- 设置框跟齿轮挂在同一棵组件树里（`position: fixed` 覆盖层），不额外 `createRoot` —— 这样不依赖 `react-dom/client` 是否在页面可 require 的白名单里。
+- 两个按钮之间的状态用一个模块级 store 同步，保存完另一个立刻拿到新地址，不用刷新。
+- `Config` 导出是**可选**的：`@deepseek-ai/schemastery` 只存在于 DSH 安装内部，运行时按包名 → `process.argv[1]` 上溯 → Node 全局路径依次找；找不到就整个不导出 `Config`，插件照常工作，只是没有 DSH 自带的设置表单。
+- 手机与电脑的分支靠 `navigator.userAgent` 判定；桌面侧完全走原生锚点行为，不拦点击。
+
+---
+
+## 已知限制
+
+1. **Host 半区（`index.js`）改动需要重装插件或重启 `dsh web`**；Client 半区（`client.js`）刷新页面即生效（有 `pnpm run dev:web` 监听时可免刷新）。
+2. 侧栏折叠成 56px 轨道时只显示图标，展开后才显示「桌面版」文字。
+3. 手机端「点击时铸码」依赖本机装了 `dsh-remote-web-ui`（本插件不声明这个依赖，装不装都能用，只是没有自动铸码）。
+4. 需要 DSH `>= 0.2.1-rc.2`（`webserver/index-inject` 事件与 `sidebar.footer.action` 槽位）。
+
+---
+
+## License
+
+MIT

package/client.js

@@ -0,0 +1,570 @@
+window.__ModuleLoader__.load({
+  id: 'dsh-desktop-link',
+  factory(require) {
+    const React = require('react')
+    const h = React.createElement
+
+    /** Locale namespace owned by this plugin. */
+    const NS = 'dsha-desktop-link'
+
+    const zh = {
+      'action': '打开桌面版 DSH',
+      'action.short': '桌面版',
+      'settings': '填桌面地址',
+      'hint.unset': '还没配桌面地址：点右边的齿轮填一个，或把地址写进 ~/.dsh/desktop-url.txt',
+      'form.title': '桌面版地址',
+      'form.intro': '填一次就存在这台电脑上，手机和电脑都读同一份。',
+      'form.desktop': '桌面版地址',
+      'form.desktop.hint': '长期地址，例如 https://xxxx.dsh-market.com。留空则自动用固定中继。',
+      'form.launch': '点按钮时打开的地址',
+      'form.launch.hint': '留空就等于上面的地址。填中转的 /open.html 链接可以每次自动铸新配对码。',
+      'form.save': '保存',
+      'form.cancel': '取消',
+      'form.saving': '保存中…',
+      'form.saved': '已保存',
+      'form.current': '当前生效',
+      'form.close': '关闭',
+      'source.config': '页面配置',
+      'source.env': '环境变量',
+      'source.desktop-url.txt': '桌面地址文件',
+      'source.relay-registry': '固定中继',
+      'source.unset': '未配置',
+    }
+    const en = {
+      'action': 'Open desktop DSH',
+      'action.short': 'Desktop',
+      'settings': 'Set desktop address',
+      'hint.unset': 'No desktop address yet: click the gear to set one, or write it into ~/.dsh/desktop-url.txt',
+      'form.title': 'Desktop address',
+      'form.intro': 'Saved on this computer once; both the phone and the desktop read it.',
+      'form.desktop': 'Desktop address',
+      'form.desktop.hint': 'Long-lived origin, e.g. https://xxxx.dsh-market.com. Empty falls back to the fixed relay.',
+      'form.launch': 'Address opened on click',
+      'form.launch.hint': 'Empty means the same as above. Point it at a relay /open.html link to mint a fresh pair code each time.',
+      'form.save': 'Save',
+      'form.cancel': 'Cancel',
+      'form.saving': 'Saving…',
+      'form.saved': 'Saved',
+      'form.current': 'In effect',
+      'form.close': 'Close',
+      'source.config': 'page config',
+      'source.env': 'environment',
+      'source.desktop-url.txt': 'address file',
+      'source.relay-registry': 'fixed relay',
+      'source.unset': 'not configured',
+    }
+
+    /* 18×18 monitor with an out-arrow — same artwork as icon.svg, inlined so
+       the button costs no extra request. */
+    function Mark() {
+      return h('svg', {
+        viewBox: '0 0 64 64', width: 18, height: 18, 'aria-hidden': true,
+        focusable: false,
+        style: { display: 'block', flex: 'none' },
+      },
+      h('rect', {
+        x: 8, y: 10, width: 48, height: 30, rx: 5,
+        fill: 'none', stroke: 'currentColor', strokeWidth: 4.5,
+      }),
+      h('path', {
+        d: 'M26 54h12M32 46v8', fill: 'none', stroke: 'currentColor',
+        strokeWidth: 4.5, strokeLinecap: 'round',
+      }),
+      h('path', {
+        d: 'M24 25h14M32 18l7 7-7 7', fill: 'none', stroke: 'currentColor',
+        strokeWidth: 4.5, strokeLinecap: 'round', strokeLinejoin: 'round',
+      }))
+    }
+
+    /* 18×18 gear, drawn at the same weight as Mark so the two sit together. */
+    function Gear() {
+      return h('svg', {
+        viewBox: '0 0 64 64', width: 16, height: 16, 'aria-hidden': true,
+        focusable: false, style: { display: 'block', flex: 'none' },
+      },
+      h('circle', {
+        cx: 32, cy: 32, r: 9, fill: 'none', stroke: 'currentColor', strokeWidth: 5,
+      }),
+      h('path', {
+        d: 'M32 6v10M32 48v10M6 32h10M48 32h10M13.6 13.6l7.1 7.1M43.3 43.3l7.1 7.1M50.4 13.6l-7.1 7.1M20.7 43.3l-7.1 7.1',
+        fill: 'none', stroke: 'currentColor', strokeWidth: 5, strokeLinecap: 'round',
+      }))
+    }
+
+    /**
+     * The live address pair, shared by both sidebar items.
+     *
+     * The two items are separate components mounted side by side, so the
+     * settings dialog's save has to reach the launcher without a page reload.
+     * A module-scope store with listeners is the smallest thing that does it —
+     * a window event would work too, but this keeps the shape typed in one
+     * place and lets a late subscriber read the current value synchronously.
+     */
+    const store = (() => {
+      let value = { desktopUrl: '', launchUrl: '', source: 'unset', loaded: false }
+      const listeners = new Set()
+      const emit = () => { for (const fn of [...listeners]) fn(value) }
+      return {
+        get: () => value,
+        set(patch) {
+          const next = { ...value, ...patch }
+          if (next.desktopUrl === value.desktopUrl
+            && next.launchUrl === value.launchUrl
+            && next.source === value.source
+            && next.loaded === value.loaded) return
+          value = next
+          emit()
+        },
+        subscribe(fn) {
+          listeners.add(fn)
+          return () => { listeners.delete(fn) }
+        },
+      }
+    })()
+
+    /**
+     * Seed the store from the index global.
+     *
+     * The global is injected at index render time, so it can be absent on a
+     * page served before the Host half loaded; in that case the info route is
+     * asked once. Either way the result is pushed into the shared store so both
+     * sidebar items agree.
+     */
+    function seed() {
+      const injected = window.__DSHA_DESKTOP_LINK__
+      if (injected && typeof injected === 'object') {
+        store.set({
+          desktopUrl: typeof injected.desktopUrl === 'string' ? injected.desktopUrl : '',
+          launchUrl: typeof injected.launchUrl === 'string' ? injected.launchUrl : '',
+          source: typeof injected.source === 'string' ? injected.source : 'unset',
+          loaded: true,
+        })
+        if (injected.desktopUrl) return Promise.resolve()
+      }
+      return fetch('/api/desktop-link/info', {
+        credentials: 'same-origin',
+        headers: { accept: 'application/json' },
+      }).then((res) => (res.ok ? res.json() : null))
+        .then((body) => {
+          if (!body || !body.ok) return
+          const next = {
+            desktopUrl: typeof body.desktopUrl === 'string' ? body.desktopUrl : '',
+            launchUrl: typeof body.launchUrl === 'string' ? body.launchUrl : '',
+            source: typeof body.source === 'string' ? body.source : 'unset',
+            loaded: true,
+          }
+          window.__DSHA_DESKTOP_LINK__ = { ...(injected || {}), ...next }
+          store.set(next)
+        })
+        .catch(() => { /* the button stays as-is; the gear still opens */ })
+    }
+
+    /** Whether this page runs on a handset (DSHA's WebView or a phone browser). */
+    function isHandset() {
+      const ua = navigator.userAgent || ''
+      return /Android|iPhone|iPad|iPod|HarmonyOS|Mobile/i.test(ua)
+    }
+
+    /** The URL a click should carry, or '' when nothing is configured. */
+    function linkHref(value) {
+      return value.launchUrl || value.desktopUrl
+    }
+
+    /**
+     * Mint a one-shot pair URL from this instance's own pairing service.
+     *
+     * This page is same-origin on the loopback listener and `/api/pair/issue`
+     * answers loopback only, so the browser can ask on the phone's behalf. A
+     * phone that has never paired would otherwise open the published origin and
+     * meet the harness 401 fence; after one pairing the cookie lasts a year.
+     * An instance without the pairing plugin answers 404 — a handled miss.
+     * @returns the pair-accept URL, or an empty string.
+     */
+    function mintPairUrl() {
+      return fetch('/api/pair/issue', {
+        method: 'POST',
+        credentials: 'same-origin',
+        headers: { 'content-type': 'application/json', accept: 'application/json' },
+        body: '{}',
+      }).then((res) => (res.ok ? res.json() : null))
+        .then((body) => (body && typeof body.url === 'string' ? body.url : ''))
+        .catch(() => '')
+    }
+
+    /** The dialog's open state, shared so the launcher can open it too. */
+    const dialog = (() => {
+      let open = false
+      const listeners = new Set()
+      const emit = () => { for (const fn of [...listeners]) fn(open) }
+      return {
+        isOpen: () => open,
+        show() { if (!open) { open = true; emit() } },
+        hide() { if (open) { open = false; emit() } },
+        subscribe(fn) { listeners.add(fn); return () => { listeners.delete(fn) } },
+      }
+    })()
+
+    const baseButtonStyle = (wide) => ({
+      display: 'inline-flex',
+      alignItems: 'center',
+      justifyContent: wide ? 'flex-start' : 'center',
+      flex: 'none',
+      height: 28,
+      minWidth: 28,
+      padding: wide ? '0 8px' : 0,
+      boxSizing: 'border-box',
+      borderRadius: 'var(--dsw-radius-sm, 6px)',
+      color: 'var(--dsw-alias-label-secondary)',
+      background: 'transparent',
+      border: 'none',
+      cursor: 'pointer',
+      fontSize: 13,
+      fontFamily: 'inherit',
+      textDecoration: 'none',
+      whiteSpace: 'nowrap',
+    })
+
+    const hoverIn = (e) => {
+      e.currentTarget.style.background = 'var(--dsw-alias-interactive-bg-hover, rgba(127,127,127,.12))'
+    }
+    const hoverOut = (e) => { e.currentTarget.style.background = 'transparent' }
+
+    /**
+     * Subscribe a component to one of the module-scope stores.
+     *
+     * Deliberately not `useSyncExternalStore`: this plugin must run on whatever
+     * React the page shell ships, and the plain state+effect form works on every
+     * version that has hooks at all.
+     * @param source - object with `subscribe` and a getter.
+     * @param read - selector from the store value to the slice worth rendering.
+     * @returns the current slice, re-rendering on change.
+     */
+    function useStore(source, read) {
+      const [, force] = React.useState(0)
+      React.useEffect(() => source.subscribe(() => force((n) => n + 1)), [source])
+      return read()
+    }
+
+    /**
+     * Row 1: "open the desktop DSH".
+     *
+     * Two paths, both deterministic:
+     * - Handset: no second window exists, so a top-level navigation is the
+     *   answer. It is issued after a short mint call, which a navigation (unlike
+     *   `window.open`) tolerates, and DSHA then hands it to the system browser.
+     * - Desktop: a plain `target="_blank"` anchor opens a second tab and leaves
+     *   the current GUI alone. No script runs, so nothing can be blocked.
+     *
+     * With nothing configured the click opens the settings dialog instead of
+     * doing nothing — that is the only way a phone user can ever get an address
+     * in, since it has no shell to write the file with.
+     */
+    function DesktopLinkButton(props) {
+      const wide = props.wide !== false
+      const t = props.t || ((key) => zh[key] || en[key] || key)
+      const value = useStore(store, () => store.get())
+      const href = linkHref(value)
+
+      React.useEffect(() => { seed() }, [])
+
+      const onClick = (event) => {
+        if (!href) { event.preventDefault(); dialog.show(); return }
+        // Let modifier-clicks and middle-clicks fall through to the anchor.
+        if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return
+        if (!isHandset()) return   // desktop keeps the plain _blank anchor
+        event.preventDefault()
+        // A configured minting endpoint already hands out a fresh token, so
+        // navigating there is enough; otherwise mint here.
+        if (value.launchUrl && value.launchUrl !== value.desktopUrl) {
+          window.location.assign(value.launchUrl)
+          return
+        }
+        mintPairUrl().then((url) => { window.location.assign(url || value.desktopUrl) })
+      }
+
+      return h('a', {
+        href: href || undefined,
+        target: '_blank',
+        rel: 'noopener noreferrer',
+        style: { ...baseButtonStyle(wide), opacity: href ? 1 : 0.45 },
+        title: href || t('hint.unset'),
+        'aria-label': t('action'),
+        'aria-disabled': href ? undefined : 'true',
+        onClick,
+        onMouseEnter: hoverIn,
+        onMouseLeave: hoverOut,
+      },
+      h(Mark),
+      wide
+        ? h('span', {
+          style: { marginLeft: 8, overflow: 'hidden', textOverflow: 'ellipsis', fontSize: 13 },
+        }, t('action.short'))
+        : null)
+    }
+
+    /**
+     * Row 2: the gear.
+     *
+     * A separate slot item rather than a modified click on the launcher: a
+     * long-press has no affordance on a phone, and a second small target next
+     * to the first is the one pattern that reads the same on both platforms.
+     */
+    function DesktopLinkSettingsButton(props) {
+      const wide = props.wide !== false
+      const t = props.t || ((key) => zh[key] || en[key] || key)
+      return h(React.Fragment, null,
+        h('button', {
+          type: 'button',
+          style: baseButtonStyle(false),
+          title: t('settings'),
+          'aria-label': t('settings'),
+          onClick: () => dialog.show(),
+          onMouseEnter: hoverIn,
+          onMouseLeave: hoverOut,
+        }, h(Gear)),
+        h(DesktopLinkSettingsDialog, { t }))
+    }
+
+    const overlayStyle = {
+      position: 'fixed',
+      inset: 0,
+      zIndex: 2147483000,
+      display: 'flex',
+      alignItems: 'center',
+      justifyContent: 'center',
+      padding: 16,
+      background: 'rgba(0,0,0,.45)',
+    }
+    const cardStyle = {
+      width: 'min(520px, 100%)',
+      maxHeight: 'calc(100vh - 32px)',
+      overflow: 'auto',
+      boxSizing: 'border-box',
+      padding: 20,
+      borderRadius: 12,
+      background: 'var(--dsw-alias-bg-overlay, var(--dsw-alias-bg-base, #fff))',
+      color: 'var(--dsw-alias-label-primary, inherit)',
+      boxShadow: '0 12px 40px rgba(0,0,0,.28)',
+      fontFamily: 'inherit',
+      fontSize: 14,
+      lineHeight: 1.5,
+    }
+    const labelStyle = { display: 'block', fontSize: 13, fontWeight: 600, marginBottom: 6 }
+    const inputStyle = {
+      width: '100%',
+      boxSizing: 'border-box',
+      padding: '8px 10px',
+      borderRadius: 8,
+      border: '1px solid var(--dsw-alias-border-weak, rgba(127,127,127,.35))',
+      background: 'var(--dsw-alias-bg-base, transparent)',
+      color: 'inherit',
+      fontFamily: 'inherit',
+      fontSize: 14,
+    }
+    const hintStyle = { margin: '6px 0 0', fontSize: 12, opacity: .7, lineHeight: 1.45 }
+    const actionStyle = (primary) => ({
+      height: 34,
+      padding: '0 16px',
+      borderRadius: 8,
+      border: primary ? 'none' : '1px solid var(--dsw-alias-border-weak, rgba(127,127,127,.35))',
+      background: primary ? 'var(--dsw-alias-brand-primary, #4d6bfe)' : 'transparent',
+      color: primary ? '#fff' : 'inherit',
+      fontFamily: 'inherit',
+      fontSize: 14,
+      cursor: 'pointer',
+    })
+
+    /**
+     * The settings dialog.
+     *
+     * Mounted once, unconditionally, and driven by the shared open flag: a
+     * dialog rendered inside the button would unmount with it, and the sidebar
+     * row can re-render for unrelated reasons.
+     *
+     * Saving posts to the Host, which writes `desktop-url.txt` — the same file
+     * the file-based resolution chain reads — and answers with the resolved
+     * pair, so the form shows what actually took effect rather than what was
+     * typed.
+     */
+    function DesktopLinkSettingsDialog(props) {
+      const t = (props && props.t) || ((key) => zh[key] || en[key] || key)
+      const open = useStore(dialog, () => dialog.isOpen())
+      const value = useStore(store, () => store.get())
+      const [desktop, setDesktop] = React.useState('')
+      const [launch, setLaunch] = React.useState('')
+      const [status, setStatus] = React.useState('idle')
+      const [error, setError] = React.useState('')
+      const fallback = t
+
+      // Seed the fields from the live pair each time the dialog opens, so a
+      // second visit never shows a stale draft.
+      React.useEffect(() => {
+        if (!open) return
+        setDesktop(value.desktopUrl || '')
+        setLaunch(value.launchUrl && value.launchUrl !== value.desktopUrl ? value.launchUrl : '')
+        setStatus('idle')
+        setError('')
+      }, [open])
+
+      React.useEffect(() => {
+        if (!open) return
+        const onKey = (event) => { if (event.key === 'Escape') dialog.hide() }
+        window.addEventListener('keydown', onKey)
+        return () => window.removeEventListener('keydown', onKey)
+      }, [open])
+
+      if (!open) return null
+
+      const submit = (event) => {
+        event.preventDefault()
+        if (status === 'saving') return
+        setStatus('saving')
+        setError('')
+        fetch('/api/desktop-link/config', {
+          method: 'POST',
+          credentials: 'same-origin',
+          headers: { 'content-type': 'application/json', accept: 'application/json' },
+          body: JSON.stringify({ desktopUrl: desktop.trim(), launchUrl: launch.trim() }),
+        })
+          .then((res) => res.json().then((body) => ({ ok: res.ok, body })))
+          .then(({ ok, body }) => {
+            if (!ok || !body || body.ok !== true) {
+              setError((body && body.error) || 'save failed')
+              setStatus('idle')
+              return
+            }
+            const next = {
+              desktopUrl: typeof body.desktopUrl === 'string' ? body.desktopUrl : '',
+              launchUrl: typeof body.launchUrl === 'string' ? body.launchUrl : '',
+              source: typeof body.source === 'string' ? body.source : 'unset',
+              loaded: true,
+            }
+            window.__DSHA_DESKTOP_LINK__ = { ...(window.__DSHA_DESKTOP_LINK__ || {}), ...next }
+            store.set(next)
+            setStatus('saved')
+          })
+          .catch((err) => { setError(String(err && err.message ? err.message : err)); setStatus('idle') })
+      }
+
+      const sourceText = (fallback(`source.${value.source}`))
+      const body = []
+
+      body.push(h('h2', {
+        key: 'title',
+        style: { margin: '0 0 4px', fontSize: 17, fontWeight: 650 },
+      }, fallback('form.title')))
+      body.push(h('p', {
+        key: 'intro',
+        style: { margin: '0 0 16px', fontSize: 12, opacity: .72 },
+      }, fallback('form.intro')))
+
+      if (value.desktopUrl) {
+        body.push(h('p', {
+          key: 'current',
+          style: {
+            margin: '0 0 16px', padding: '8px 10px', borderRadius: 8, fontSize: 12,
+            background: 'var(--dsw-alias-interactive-bg-hover, rgba(127,127,127,.1))',
+            wordBreak: 'break-all',
+          },
+        }, `${fallback('form.current')}（${sourceText}）：${value.launchUrl || value.desktopUrl}`))
+      }
+
+      body.push(h('div', { key: 'desktop', style: { marginBottom: 14 } },
+        h('label', { style: labelStyle, htmlFor: 'dsh-desktop-link-desktop' }, fallback('form.desktop')),
+        h('input', {
+          id: 'dsh-desktop-link-desktop',
+          type: 'url',
+          inputMode: 'url',
+          autoCapitalize: 'off',
+          autoCorrect: 'off',
+          spellCheck: false,
+          placeholder: 'https://xxxx.dsh-market.com',
+          value: desktop,
+          onChange: (e) => setDesktop(e.target.value),
+          style: inputStyle,
+        }),
+        h('p', { style: hintStyle }, fallback('form.desktop.hint'))))
+
+      body.push(h('div', { key: 'launch', style: { marginBottom: 14 } },
+        h('label', { style: labelStyle, htmlFor: 'dsh-desktop-link-launch' }, fallback('form.launch')),
+        h('input', {
+          id: 'dsh-desktop-link-launch',
+          type: 'url',
+          inputMode: 'url',
+          autoCapitalize: 'off',
+          autoCorrect: 'off',
+          spellCheck: false,
+          placeholder: 'https://…/open.html?k=…',
+          value: launch,
+          onChange: (e) => setLaunch(e.target.value),
+          style: inputStyle,
+        }),
+        h('p', { style: hintStyle }, fallback('form.launch.hint'))))
+
+      if (error) {
+        body.push(h('p', {
+          key: 'error',
+          style: { margin: '0 0 12px', fontSize: 12, color: 'var(--dsw-alias-danger, #d64545)' },
+        }, error))
+      }
+
+      body.push(h('div', {
+        key: 'actions',
+        style: { display: 'flex', gap: 8, justifyContent: 'flex-end', alignItems: 'center' },
+      },
+      status === 'saved'
+        ? h('span', { style: { marginRight: 'auto', fontSize: 12, opacity: .75 } }, fallback('form.saved'))
+        : null,
+      h('button', {
+        type: 'button',
+        style: actionStyle(false),
+        onClick: () => dialog.hide(),
+      }, fallback('form.cancel')),
+      h('button', {
+        type: 'submit',
+        style: actionStyle(true),
+        disabled: status === 'saving',
+        onClick: submit,
+      }, status === 'saving' ? fallback('form.saving') : fallback('form.save'))))
+
+      return h('div', {
+        role: 'dialog',
+        'aria-modal': 'true',
+        'aria-label': fallback('form.title'),
+        style: overlayStyle,
+        onClick: (event) => { if (event.target === event.currentTarget) dialog.hide() },
+      }, h('form', {
+        onSubmit: submit,
+        style: cardStyle,
+        onClick: (event) => event.stopPropagation(),
+      }, body))
+    }
+
+    return {
+      inject: ['slots', 'locale'],
+      apply(ctx) {
+        ctx.effect(() => {
+          const offZh = ctx.locale.register(NS, 'zh', zh)
+          const offEn = ctx.locale.register(NS, 'en', en)
+          return () => { offZh(); offEn() }
+        }, 'dsha-desktop-link: dictionaries')
+
+        ctx.slots.inject('sidebar.footer.action', () => ctx.slots.register({
+          name: 'sidebar.footer.action',
+          id: 'dsha-desktop-link',
+          order: 10,
+          label: () => ctx.locale.bind(NS)('action'),
+          locale: NS,
+        }, DesktopLinkButton))
+
+        ctx.slots.inject('sidebar.footer.action', () => ctx.slots.register({
+          name: 'sidebar.footer.action',
+          id: 'dsha-desktop-link-settings',
+          order: 11,
+          label: () => ctx.locale.bind(NS)('settings'),
+          locale: NS,
+        }, DesktopLinkSettingsButton))
+      },
+    }
+  },
+})

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsha-desktop-link
+      name: 'dsh-desktop-link'

package/icon.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Desktop DSH">
+  <rect x="3" y="4" width="58" height="56" rx="14" fill="#0f172a"/>
+  <!-- monitor -->
+  <rect x="12" y="14" width="40" height="26" rx="4" fill="none" stroke="#5eead4" stroke-width="3.2"/>
+  <path d="M24 47h16M32 40v7" fill="none" stroke="#5eead4" stroke-width="3.2" stroke-linecap="round"/>
+  <!-- arrow out of the screen, i.e. "jump to desktop" -->
+  <path d="M25 27h13M33 21l7 6-7 6" fill="none" stroke="#f0abfc" stroke-width="3.2"
+        stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

package/index.js

@@ -0,0 +1,397 @@
+/**
+ * dsh-desktop-link —— 宿主半区。
+ *
+ * 只做一件事：把两个地址交给浏览器半区，并允许在界面上改这两个地址。
+ * 路由（均为同源 JSON）：
+ *
+ *   GET  /api/desktop-link/info
+ *     → { ok, launchUrl, desktopUrl, source }
+ *
+ *   POST /api/desktop-link/config   { desktopUrl?, launchUrl? }
+ *     → { ok, path, launchUrl, desktopUrl, source }；写入 $DSH_HOME/desktop-url.txt
+ *
+ *   launchUrl   点按钮时真正打开的地址（可以是中转的一次性链接）
+ *   desktopUrl  桌面版 GUI 的长期地址（书签用，也是 launchUrl 的兜底）
+ *
+ * desktopUrl 的来源优先级（命中即停）：
+ *   1. 本行 config.desktopUrl
+ *   2. 环境变量 DSH_DESKTOP_URL
+ *   3. $DSH_HOME/desktop-url.txt 第一行
+ *   4. $DSH_HOME/remote-web-ui-registry/web.json 的 id → https://<id>.dsh-market.com
+ *
+ * launchUrl 额外支持 config.launchUrl / 环境变量 DSH_DESKTOP_LAUNCH_URL，
+ * 用来指向 dsha-pair/bridge.py 的 /open.html（每次点都铸一枚新码）。
+ * 没配 launchUrl 时，launchUrl 恒等于 desktopUrl。
+ */
+import { existsSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { homedir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+/**
+ * Resolve `@deepseek-ai/schemastery`, which ships inside the harness
+ * installation rather than as a dependency of this package.
+ *
+ * A bare `import` here fails with ERR_MODULE_NOT_FOUND and takes the whole
+ * plugin down, so the module is located at runtime: first as a normal package
+ * import from this file, then by walking up from the running `dsh` binary (the
+ * harness's own node_modules), and finally by asking Node's global paths. The
+ * `Config` export is omitted entirely when none of those resolve — the plugin
+ * still works from config files, it just has no settings form.
+ * @returns the schemastery `z` function, or undefined.
+ */
+function loadSchemastery() {
+  const requireFrom = createRequire(import.meta.url)
+  const candidates = ['@deepseek-ai/schemastery']
+
+  // The harness entry point: .../node_modules/@deepseek-ai/dsh/lib/bin.js
+  const argv1 = process.argv[1]
+  if (typeof argv1 === 'string' && argv1) {
+    const dir = dirname(resolve(argv1))
+    candidates.push(join(dir, '..', 'node_modules', '@deepseek-ai', 'schemastery'))
+    candidates.push(join(dir, 'node_modules', '@deepseek-ai', 'schemastery'))
+  }
+  try {
+    for (const base of requireFrom.resolve.paths?.('@deepseek-ai/schemastery') ?? []) {
+      candidates.push(join(base, '@deepseek-ai', 'schemastery'))
+    }
+  } catch {
+    // resolve.paths is not on every Node build; the other candidates stand.
+  }
+
+  for (const candidate of candidates) {
+    try {
+      const mod = requireFrom(candidate)
+      const z = mod?.default ?? mod
+      if (typeof z === 'function' && typeof z.object === 'function') return z
+    } catch {
+      // try the next candidate
+    }
+  }
+  return undefined
+}
+
+const z = loadSchemastery()
+
+/**
+ * Row config.
+ *
+ * Everything is optional. An install with no config falls through to the
+ * environment, then to `desktop-url.txt`, then to the relay origin that
+ * `dsh-remote-web-ui` publishes. The form exists so a phone — where there is no
+ * shell to write that file with — can set the address from the GUI.
+ *
+ * The loader validates Config through schemastery's own `meta`/`dict` shape, so
+ * a plain JSON Schema object is not interchangeable here (`undefined.validate`
+ * when it tries). When schemastery cannot be located the export is omitted: no
+ * settings form, but the row still activates.
+ */
+const configSchema = typeof z === 'function'
+  ? z.object({
+    desktopUrl: z.string().description(
+      '桌面版 DSH 的长期地址（书签用），例如 https://xxx.dsh-market.com。'
+      + '留空则依次读环境变量 DSH_DESKTOP_URL、$DSH_HOME/desktop-url.txt、'
+      + 'dsh-remote-web-ui 的固定中继地址。'),
+    launchUrl: z.string().description(
+      '点按钮时真正打开的地址。留空则等于 desktopUrl。'
+      + '填一个会临时铸配对码的端点（如 bridge.py 的 /open.html?k=…），'
+      + '未配对过的手机也能一次进入。'),
+  })
+  : undefined
+
+export { configSchema as Config }
+
+function dshHome() {
+  const fromEnv = process.env.DSH_HOME
+  if (typeof fromEnv === 'string' && fromEnv.trim()) return fromEnv.trim()
+  return join(homedir(), '.dsh')
+}
+
+function urlish(value) {
+  return typeof value === 'string' && /^https?:\/\/\S+$/i.test(value.trim()) ? value.trim() : ''
+}
+
+/**
+ * Every URL in a hand-edited comment-friendly file under the DSH home.
+ *
+ * `desktop-url.txt` takes up to two lines, in this order:
+ *   line 1 = desktopUrl, the long-lived desktop origin (bookmark target)
+ *   line 2 = launchUrl, what a click actually opens (a minting endpoint)
+ * A single line therefore means "open this one thing". `#` comments and blank
+ * lines are skipped, and anything that is not http(s) is ignored rather than
+ * returned half-parsed.
+ * @param name - file name inside the DSH home.
+ * @returns the URLs found, in file order.
+ */
+function readUrlLines(name) {
+  try {
+    const file = join(dshHome(), name)
+    if (!existsSync(file)) return []
+    const found = []
+    for (const raw of readFileSync(file, 'utf8').split(/\r?\n/)) {
+      const line = raw.trim()
+      if (!line || line.startsWith('#')) continue
+      const value = urlish(line)
+      if (value) found.push(value)
+    }
+    return found
+  } catch {
+    return []
+  }
+}
+
+function readRelayOrigin() {
+  try {
+    const file = join(dshHome(), 'remote-web-ui-registry', 'web.json')
+    if (!existsSync(file)) return ''
+    const parsed = JSON.parse(readFileSync(file, 'utf8'))
+    const id = typeof parsed?.id === 'string' ? parsed.id.trim() : ''
+    return /^[A-Za-z0-9-]{8,}$/.test(id) ? `https://${id}.dsh-market.com` : ''
+  } catch {
+    return ''
+  }
+}
+
+/**
+ * Whether this instance has ever paired a device.
+ *
+ * The roster is `dsh-remote-web-ui`'s own persisted store
+ * (`$DSH_HOME/remote-web-ui-devices.json`, 0600, its documented default). It is
+ * read only for this boolean — no ids, no credentials — and a missing or
+ * unreadable file simply means "nothing paired yet", which is the safe answer:
+ * the button then mints a token instead of opening a URL that would 401.
+ * @returns whether at least one device session exists on disk.
+ */
+function hasPairedDevice() {
+  try {
+    const file = join(dshHome(), 'remote-web-ui-devices.json')
+    if (!existsSync(file)) return false
+    const parsed = JSON.parse(readFileSync(file, 'utf8'))
+    const rows = Array.isArray(parsed) ? parsed : (parsed?.devices ?? [])
+    return Array.isArray(rows) ? rows.length > 0 : Boolean(rows && Object.keys(rows).length)
+  } catch {
+    return false
+  }
+}
+
+function resolveUrls(config) {
+  const fileUrls = readUrlLines('desktop-url.txt')
+  const chain = [
+    ['config', () => urlish(config?.desktopUrl)],
+    ['env', () => urlish(process.env.DSH_DESKTOP_URL)],
+    ['desktop-url.txt', () => fileUrls[0] ?? ''],
+    ['relay-registry', readRelayOrigin],
+  ]
+  let desktopUrl = ''
+  let source = 'unset'
+  for (const [label, read] of chain) {
+    const value = read()
+    if (value) { desktopUrl = value; source = label; break }
+  }
+  // launchUrl is what a click opens. In order: the row's config, the
+  // environment, line 2 of desktop-url.txt (a local minting endpoint such as
+  // dsha-pair/bridge.py's /open.html?k=…), then the desktop origin itself.
+  const launchUrl =
+    urlish(config?.launchUrl) ||
+    urlish(process.env.DSH_DESKTOP_LAUNCH_URL) ||
+    fileUrls[1] ||
+    desktopUrl
+  return { launchUrl, desktopUrl, source }
+}
+
+/**
+ * Nothing to do here — kept as the single place that maps a URL string to a
+ * file line, so the write path and the read path agree on what counts as a URL.
+ * @param value - candidate URL.
+ * @returns the trimmed URL, or an empty string when it is not http(s).
+ */
+function cleanUrl(value) {
+  return urlish(value)
+}
+
+/**
+ * Persist both addresses to `$DSH_HOME/desktop-url.txt`.
+ *
+ * Written to a sibling temp file and renamed into place: a half-written file
+ * would be read back by the next `/api/desktop-link/info` and silently point
+ * the button at a truncated URL. An empty pair removes the file entirely, which
+ * restores the relay-registry fallback instead of pinning a dead address.
+ * @param desktopUrl - the long-lived origin, or ''.
+ * @param launchUrl - what a click opens, or '' for "same as desktopUrl".
+ * @returns the file path written, or '' when the file was removed.
+ */
+function writeUrlFile(desktopUrl, launchUrl) {
+  const file = join(dshHome(), 'desktop-url.txt')
+  const lines = []
+  if (desktopUrl) lines.push(desktopUrl)
+  // Line 2 only carries meaning next to a line 1; a lone launchUrl is written
+  // as line 1 so a user who only knows the minting endpoint still gets one.
+  if (launchUrl && launchUrl !== desktopUrl) {
+    if (lines.length === 0) lines.push(launchUrl)
+    else lines.push(launchUrl)
+  }
+  if (lines.length === 0) {
+    try { rmSync(file, { force: true }) } catch { /* already gone */ }
+    return ''
+  }
+  const tmp = `${file}.tmp`
+  writeFileSync(tmp, `${lines.join('\n')}\n`, { encoding: 'utf8', mode: 0o600 })
+  renameSync(tmp, file)
+  return file
+}
+
+/**
+ * Read a small JSON request body.
+ *
+ * Bounded on purpose: this route is reachable from any paired device, and an
+ * unbounded read would let one request hold the process's memory. The cap is
+ * far above the two URLs the form sends.
+ * @param req - the incoming request.
+ * @returns the parsed object, or null when the body is absent, oversized, or
+ * not JSON.
+ */
+function readJsonBody(req) {
+  return new Promise((resolveBody) => {
+    const chunks = []
+    let size = 0
+    let settled = false
+    const finish = (value) => {
+      if (settled) return
+      settled = true
+      resolveBody(value)
+    }
+    req.on('data', (chunk) => {
+      size += chunk.length
+      if (size > 8192) { finish(null); req.destroy(); return }
+      chunks.push(chunk)
+    })
+    req.on('end', () => {
+      if (!chunks.length) return finish({})
+      try {
+        const parsed = JSON.parse(Buffer.concat(chunks).toString('utf8'))
+        finish(parsed && typeof parsed === 'object' ? parsed : null)
+      } catch {
+        finish(null)
+      }
+    })
+    req.on('error', () => finish(null))
+  })
+}
+
+/** Host half: publish the desktop address. */
+export const inject = ['webServer']
+
+/**
+ * Register the info route and the index global.
+ *
+ * The browser half reads `globalThis.__DSHA_DESKTOP_LINK__` synchronously, so
+ * the button is usable on first paint. `paired` tells it whether this instance
+ * ever paired a device: when it never has, the client mints a token itself
+ * through `/api/pair/issue` (same-origin, loopback, so the pairing service
+ * answers) instead of opening a URL that would hit the harness 401 fence.
+ *
+ * `config` is read per request rather than captured once: the settings form
+ * writes through the Host's config layer, and a request that arrived after such
+ * a write must see the new value without a restart.
+ * @param ctx - host plugin context carrying webServer.
+ * @param config - the row's live config (`{ desktopUrl?, launchUrl? }`).
+ */
+export function apply(ctx, config) {
+  /**
+   * A Cordis config value may be a getter-backed proxy that throws when a field
+   * is read outside the loader's own evaluation, so every read is guarded: a
+   * failing field is treated as absent, and the chain simply continues.
+   */
+  const field = (name) => {
+    try {
+      const source = typeof config === 'function' ? config() : config
+      const value = source?.[name]
+      return typeof value === 'string' ? value : ''
+    } catch {
+      return ''
+    }
+  }
+  const live = () => resolveUrls({ desktopUrl: field('desktopUrl'), launchUrl: field('launchUrl') })
+
+  const disposeGlobal = ctx.on('webserver/index-inject', (table) => {
+    table.push({ kind: 'global', name: '__DSHA_DESKTOP_LINK__', value: live() })
+  })
+
+  const info = ctx.webServer.register({
+    kind: 'exact',
+    path: '/api/desktop-link/info',
+    handler(_req, res) {
+      // Re-read per request: editing desktop-url.txt (or saving the settings
+      // form) takes effect on the next click without restarting the profile.
+      // Never let a resolve failure answer with a bare 400 — the button reads
+      // this and a crash here looks exactly like "the plugin is gone".
+      let payload
+      try {
+        payload = { ok: true, ...live() }
+      } catch (error) {
+        payload = { ok: false, error: String(error?.message ?? error) }
+      }
+      const body = JSON.stringify(payload)
+      res.writeHead(200, {
+        'content-type': 'application/json; charset=utf-8',
+        'content-length': Buffer.byteLength(body),
+        'cache-control': 'no-store',
+      })
+      res.end(body)
+    },
+  })
+
+  /**
+   * Save the two addresses.
+   *
+   * This is the form a phone can actually reach: DSH renders a settings form
+   * only for entries it considers editable, and an installed bundle's own row
+   * is not always one of them. The route writes the same file the file-based
+   * chain reads, so both entry points converge on one source of truth.
+   *
+   * POST /api/desktop-link/config  { desktopUrl?, launchUrl? }
+   */
+  const save = ctx.webServer.register({
+    kind: 'exact',
+    path: '/api/desktop-link/config',
+    handler(req, res) {
+      const reply = (status, payload) => {
+        const body = JSON.stringify(payload)
+        res.writeHead(status, {
+          'content-type': 'application/json; charset=utf-8',
+          'content-length': Buffer.byteLength(body),
+          'cache-control': 'no-store',
+        })
+        res.end(body)
+      }
+      if (req.method !== 'POST') return reply(405, { ok: false, error: 'POST only' })
+      readJsonBody(req).then((body) => {
+        if (!body) return reply(400, { ok: false, error: 'invalid JSON body' })
+        const desktopUrl = cleanUrl(body.desktopUrl)
+        const launchUrl = cleanUrl(body.launchUrl)
+        // A supplied non-empty value that fails validation is an error, not a
+        // silent "unset": the user typed something and deserves to know it was
+        // rejected instead of watching the button stay grey.
+        if (body.desktopUrl && !desktopUrl) {
+          return reply(400, { ok: false, error: 'desktopUrl must be an http(s) URL' })
+        }
+        if (body.launchUrl && !launchUrl) {
+          return reply(400, { ok: false, error: 'launchUrl must be an http(s) URL' })
+        }
+        try {
+          const path = writeUrlFile(desktopUrl, launchUrl)
+          return reply(200, { ok: true, path, ...live() })
+        } catch (error) {
+          return reply(500, { ok: false, error: String(error?.message ?? error) })
+        }
+      })
+    },
+  })
+
+  ctx.effect(() => () => {
+    if (typeof disposeGlobal === 'function') disposeGlobal()
+    if (typeof info === 'function') info()
+    if (typeof save === 'function') save()
+  }, 'dsha-desktop-link: info + config routes + index global')
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Desktop DSH shortcut",
+    "description": "Adds one sidebar-foot button that opens the desktop DSH Web GUI in the system browser or a new tab."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "桌面版 DSH 快捷入口",
+    "description": "在侧栏底部加一个按钮：点一下就在系统浏览器 / 新标签页里打开桌面版 DSH 的 Web GUI。"
+  }
+}

package/package.json

@@ -1,6 +1,60 @@
-{
-  "name": "dsh-desktop-link",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+{
+  "name": "dsh-desktop-link",
+  "version": "1.2.0",
+  "type": "module",
+  "icon": "./icon.svg",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "icon.svg",
+    "locale",
+    "assets"
+  ],
+  "dsh": {
+    "engines": {
+      "dsh": ">=0.2.1-rc.2"
+    },
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-sidebar"
+      ]
+    }
+  },
+  "license": "MIT",
+  "author": "lzlrt",
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek",
+    "deepseek-harness",
+    "dsha",
+    "remote",
+    "sidebar",
+    "mobile"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lzlrt/dsha-desktop-link.git"
+  },
+  "homepage": "https://github.com/lzlrt/dsha-desktop-link#readme",
+  "bugs": {
+    "url": "https://github.com/lzlrt/dsha-desktop-link/issues"
+  },
+  "description": "DSH sidebar button: open the desktop DSH Web GUI from DSHA on your phone, in one tap.",
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  }
 }