Browse Source

发布 v0.4.61:完善 Bot、电脑接管与消息展示

Samien 1 tháng trước cách đây
mục cha
commit
c580dc0167
100 tập tin đã thay đổi với 2162 bổ sung và 94 xóa
  1. 4 0
      .env.example
  2. 8 6
      README.md
  3. 0 2
      compose.desktops.cursor.yaml
  4. 0 4
      compose.desktops.yaml
  5. 13 8
      deploy/computer/compose_bridge.py
  6. 45 0
      design-qa-task-interactions.md
  7. 232 1
      design-qa.md
  8. 135 0
      desktop/computer-targets.test.mjs
  9. 44 10
      desktop/computer-viewer.mjs
  10. 15 0
      desktop/environment-exchange.mjs
  11. 48 13
      desktop/environment-host.mjs
  12. 1 0
      desktop/file-transfer.mjs
  13. 12 0
      desktop/host-config.mjs
  14. 115 0
      desktop/host-files.mjs
  15. 99 0
      desktop/host-files.test.mjs
  16. 140 0
      desktop/host-manager.mjs
  17. 135 0
      desktop/host-manager.test.mjs
  18. 23 0
      desktop/host-transfer-transport.test.mjs
  19. 1 1
      desktop/lifecycle.test.mjs
  20. 244 23
      desktop/main.mjs
  21. 76 0
      desktop/mode-switch.test.mjs
  22. 7 4
      desktop/preferences.mjs
  23. 24 3
      desktop/preferences.test.mjs
  24. 8 1
      desktop/preload.cjs
  25. 5 0
      desktop/remote-login-preload.cjs
  26. 21 0
      desktop/remote-login.css
  27. 17 0
      desktop/remote-login.html
  28. 23 0
      desktop/remote-login.js
  29. 62 0
      desktop/remote-login.mjs
  30. 77 0
      desktop/remote-login.test.mjs
  31. 1 1
      docker.env.example
  32. 7 4
      docs/bot-agent-teams.md
  33. 9 1
      docs/bot-collaboration-memory.md
  34. 9 0
      docs/chat-appearance/README.md
  35. BIN
      docs/chat-appearance/approved-design.png
  36. BIN
      docs/chat-appearance/web-chat-dark.jpg
  37. BIN
      docs/chat-appearance/web-desktop-codex.jpg
  38. BIN
      docs/chat-appearance/web-mobile-grok.jpg
  39. 2 2
      docs/computer-provider.md
  40. BIN
      docs/design/approval-card-ios-before.jpg
  41. BIN
      docs/design/approval-card-ios.jpg
  42. BIN
      docs/design/approval-card-reference.png
  43. BIN
      docs/design/approval-card-web-before.jpg
  44. BIN
      docs/design/approval-card-web-dark.jpg
  45. BIN
      docs/design/approval-card-web.jpg
  46. BIN
      docs/design/bot-approval-desktop.jpg
  47. BIN
      docs/design/bot-profile-mobile.jpg
  48. 58 0
      docs/desktop-hosts.md
  49. 4 0
      docs/desktop-lifecycle.md
  50. 7 7
      docs/docker-install.md
  51. 4 3
      docs/local-vm.md
  52. BIN
      docs/media-qa/approved-design.png
  53. BIN
      docs/media-qa/desktop.png
  54. BIN
      docs/media-qa/mobile-dark-order.png
  55. BIN
      docs/media-qa/mobile-light-order.png
  56. BIN
      docs/media-qa/mobile-ordinary.png
  57. BIN
      docs/media-qa/mobile.png
  58. 5 0
      docs/releases/v0.4.26.md
  59. 4 0
      docs/releases/v0.4.27.md
  60. 5 0
      docs/releases/v0.4.28.md
  61. 4 0
      docs/releases/v0.4.29.md
  62. 4 0
      docs/releases/v0.4.30.md
  63. 4 0
      docs/releases/v0.4.31.md
  64. 5 0
      docs/releases/v0.4.32.md
  65. 5 0
      docs/releases/v0.4.33.md
  66. 5 0
      docs/releases/v0.4.34.md
  67. 6 0
      docs/releases/v0.4.35.md
  68. 6 0
      docs/releases/v0.4.36.md
  69. 4 0
      docs/releases/v0.4.37.md
  70. 3 0
      docs/releases/v0.4.38.md
  71. 3 0
      docs/releases/v0.4.39.md
  72. 4 0
      docs/releases/v0.4.40.md
  73. 4 0
      docs/releases/v0.4.41.md
  74. 4 0
      docs/releases/v0.4.42.md
  75. 3 0
      docs/releases/v0.4.43.md
  76. 4 0
      docs/releases/v0.4.44.md
  77. 3 0
      docs/releases/v0.4.45.md
  78. 3 0
      docs/releases/v0.4.46.md
  79. 4 0
      docs/releases/v0.4.47.md
  80. 6 0
      docs/releases/v0.4.48.md
  81. 4 0
      docs/releases/v0.4.49.md
  82. 4 0
      docs/releases/v0.4.50.md
  83. 4 0
      docs/releases/v0.4.51.md
  84. 4 0
      docs/releases/v0.4.52.md
  85. 3 0
      docs/releases/v0.4.53.md
  86. 5 0
      docs/releases/v0.4.54.md
  87. 3 0
      docs/releases/v0.4.55.md
  88. 3 0
      docs/releases/v0.4.56.md
  89. 4 0
      docs/releases/v0.4.57.md
  90. 5 0
      docs/releases/v0.4.58.md
  91. 6 0
      docs/releases/v0.4.59.md
  92. 5 0
      docs/releases/v0.4.60.md
  93. 45 0
      docs/releases/v0.4.61.md
  94. BIN
      docs/system-notices/approved-design.png
  95. 234 0
      docs/system-notices/checks.json
  96. BIN
      docs/system-notices/comparison.png
  97. BIN
      docs/system-notices/desktop-expanded.png
  98. BIN
      docs/system-notices/desktop.png
  99. BIN
      docs/system-notices/mobile-dark-expanded.png
  100. BIN
      docs/system-notices/mobile-dark.png

+ 4 - 0
.env.example

@@ -24,6 +24,10 @@ HERMES_YAOYAO_CHAT_CACHE_MODE=prefer-local
 # HERMES_YAOYAO_FCM_SERVICE_ACCOUNT_FILE=/absolute/path/to/firebase-service-account.json
 # HERMES_YAOYAO_FCM_PROJECT_ID=your-firebase-project-id
 # HERMES_YAOYAO_FCM_PACKAGE_NAME=cn.samien.yaoyao.hermes
+# Bot 模式可选 OpenViking 记忆 Provider。三项同时存在时由环境变量管理并强制启用。
+# HERMES_YAOYAO_OPENVIKING_URL=http://127.0.0.1:1933
+# HERMES_YAOYAO_OPENVIKING_ACCOUNT_ID=your-openviking-account
+# HERMES_YAOYAO_OPENVIKING_ADMIN_KEY=your-openviking-admin-key
 # 固定 Git 发布源。系统更新只接受这里发现的 vX.Y.Z 标签,不接受浏览器指定仓库。
 # HERMES_YAOYAO_RELEASE_SOURCE=https://github.com/Lsamien/yaoyao.git
 # HERMES_YAOYAO_RELEASE_ROOT=/Users/you/.local/share/hermes-yaoyao

+ 8 - 6
README.md

@@ -1,6 +1,6 @@
 # 夭夭 AI
 
-当前 Web 与 macOS 桌面发布版本:**v0.4.22**。桌面版提供 Apple Silicon(arm64)DMG,详见 [发布说明](docs/releases/v0.4.22.md)。
+当前 Web 与 macOS 桌面发布版本:**v0.4.61**。桌面版提供 Apple Silicon(arm64)DMG,详见 [发布说明](docs/releases/v0.4.61.md)。
 
 夭夭 AI 为网页、iOS 和安卓提供统一的 Agent、群聊、文件库及语音配置服务。Hermes 通过标准 9119 HTTP/WebSocket 接口执行任务。
 
@@ -16,6 +16,8 @@
 
 Bot 模式的“工具”菜单提供“自动化”和“已连接应用”两个独立入口。“已连接应用”统一管理应用连接与 MCP;“自动化”使用独立的日历、任务列表和运行日志页面。所有模式均可从底部菜单打开独立的“关于”对话框。这些页面不属于设置中心。
 
+远程电脑:其他 Mac 上的夭夭 App 启动时可选择「登录远程」或「进入本地」;登录远程用服务器地址加账号密码登录(与手机端一致的凭据方式),窗口直接使用远程服务器(15300)的夭夭界面,本机不运行 Web 服务;管理员账号登录同时把这台 Mac 注册为可远程控制的电脑,供服务器上的 Bot 操作。每个机器人可并列启用本地虚拟机、云端和多台 Mac 的电脑控制,工具按在线情况同时可用。详见 [服务器与电脑](docs/desktop-hosts.md)。
+
 ## 运行
 
 需要 Node.js 24 和可通过标准 API 访问的 Hermes 9119 服务。
@@ -38,7 +40,7 @@ Web 数据默认保存在 `~/.yaoyao`,可用 `YAOYAO_HOME` 指定(兼容 `HE
 
 ## macOS 桌面版
 
-在 [v0.4.22 发布页](https://github.com/Lsamien/yaoyao/releases/tag/v0.4.22) 下载 `Yaoyao-0.4.22-arm64.dmg`,将“夭夭”拖到应用程序后打开。首次启动会核对并同步配套本机 Web 服务;普通退出保留后台运行,“停止后台服务并退出”可完整停止本应用管理的后台。详细说明见 [macOS App](docs/macos-app.md)。
+在 [v0.4.61 发布页](https://github.com/Lsamien/yaoyao/releases/tag/v0.4.61) 下载 `Yaoyao-0.4.61-arm64.dmg`,将“夭夭”拖到应用程序后打开。首次启动会核对并同步配套本机 Web 服务;普通退出保留后台运行,“停止后台服务并退出”可完整停止本应用管理的后台。详细说明见 [macOS App](docs/macos-app.md)。
 
 此 DMG 使用 Apple Development 开发签名,未做 Apple 公证。
 
@@ -48,11 +50,11 @@ Web 数据默认保存在 `~/.yaoyao`,可用 `YAOYAO_HOME` 指定(兼容 `HE
 
 | 镜像 | 架构 |
 | --- | --- |
-| `samienluo/yaoyao:v0.4.22-amd` | AMD64 |
-| `samienluo/yaoyao:v0.4.22` | 自动匹配 AMD64 / ARM64 |
-| `samienluo/yaoyao:latest` | 最新稳定版通用镜像,当前与 `v0.4.22` 相同 |
+| `samienluo/yaoyao:v0.4.61-amd` | AMD64 |
+| `samienluo/yaoyao:v0.4.61` | 自动匹配 AMD64 / ARM64 |
+| `samienluo/yaoyao:latest` | 最新稳定版通用镜像,当前与 `v0.4.61` 相同 |
 
-准备好 Docker Engine/Compose 和容器可访问的 Hermes 9119 服务,在仓库目录将 `docker.env.example` 复制为 `docker.env`。配置上游地址,并设置 `HERMES_YAOYAO_IMAGE=samienluo/yaoyao:v0.4.22`(或 `samienluo/yaoyao:latest`),即可使用远程镜像:
+准备好 Docker Engine/Compose 和容器可访问的 Hermes 9119 服务,在仓库目录将 `docker.env.example` 复制为 `docker.env`。配置上游地址,并设置 `HERMES_YAOYAO_IMAGE=samienluo/yaoyao:v0.4.61`(或 `samienluo/yaoyao:latest`),即可使用远程镜像:
 
 ```sh
 docker compose --env-file docker.env pull web

+ 0 - 2
compose.desktops.cursor.yaml

@@ -59,8 +59,6 @@ services:
     mem_limit: 4g
     cpus: 2
     pids_limit: 512
-    security_opt:
-      - no-new-privileges:true
     cap_drop:
       - ALL
     cap_add:

+ 0 - 4
compose.desktops.yaml

@@ -59,8 +59,6 @@ services:
     mem_limit: 4g
     cpus: 2
     pids_limit: 512
-    security_opt:
-      - no-new-privileges:true
     cap_drop:
       - ALL
     cap_add:
@@ -88,8 +86,6 @@ services:
     mem_limit: 4g
     cpus: 2
     pids_limit: 512
-    security_opt:
-      - no-new-privileges:true
     cap_drop:
       - ALL
     cap_add:

+ 13 - 8
deploy/computer/compose_bridge.py

@@ -34,7 +34,8 @@ LEASE = None
 RESTARTING = False
 DRIVER = '/usr/local/libexec/openmausbot/cua-driver'
 CUA_SOCKET = '/run/user/1000/openmausbot-cua.sock'
-ENV = {'PATH': '/opt/venv/bin:/usr/local/bin:/usr/bin:/bin', 'HOME': '/home/cua', 'USER': 'cua', 'DISPLAY': ':1'}
+BASE_ENV = {'PATH': '/opt/venv/bin:/usr/local/bin:/usr/bin:/bin', 'DISPLAY': ':1'}
+ENV = {**BASE_ENV, 'HOME': '/home/cua', 'USER': 'cua'}
 
 def reset_desktop():
     global RESTARTING, LEASE
@@ -52,14 +53,15 @@ def current(body):
         raise ValueError('桌面控制授权已失效')
     return LEASE
 
-def start(argv, cwd):
-    # Change directory after dropping privileges: the persistent workspace is
-    # owned by cua and the bridge does not need DAC_OVERRIDE.
+def start(argv, cwd, user='cua'):
+    # The bridge itself runs as root; commands run in the explicitly selected
+    # guest account without acquiring additional container capabilities.
     wrapper = 'import os,sys;os.chdir(sys.argv[1]);os.execvpe(sys.argv[2],sys.argv[2:],os.environ)'
-    return subprocess.Popen(['python3','-c',wrapper,cwd,*argv], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=ENV, user=1000, group=1000, extra_groups=[], start_new_session=True)
+    uid, environment = (0, {**BASE_ENV, 'HOME': '/root', 'USER': 'root'}) if user == 'root' else (1000, ENV)
+    return subprocess.Popen(['python3','-c',wrapper,cwd,*argv], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=environment, user=uid, group=uid, extra_groups=[], start_new_session=True)
 
-def run(argv, cwd='/home/cua/workspace', data=None, timeout=30):
-    process = start(argv, cwd)
+def run(argv, cwd='/home/cua/workspace', data=None, timeout=30, user='cua'):
+    process = start(argv, cwd, user)
     try:
         stdout, stderr = process.communicate(data, timeout=timeout)
     except subprocess.TimeoutExpired:
@@ -143,11 +145,14 @@ class Handler(http.server.BaseHTTPRequestHandler):
                 cwd = body.get('cwd', '/home/cua/workspace')
                 if not isinstance(cwd, str) or (cwd != '/home/cua/workspace' and not cwd.startswith('/home/cua/workspace/')) or '..' in Path(cwd).parts:
                     raise ValueError('Compose 桌面工作目录必须位于 /home/cua/workspace')
+                user = body.get('user', 'cua')
+                if user not in ('cua', 'root'):
+                    raise ValueError('桌面命令用户无效')
                 with LOCK:
                     lease = current(body)
                     # Spawn while holding the lease lock, then release the lock
                     # before waiting so revocation can stop the container.
-                    process = start(argv, cwd)
+                    process = start(argv, cwd, user)
                     lease['active'] += 1
                 try:
                     data = base64.b64decode(body['input']) if body.get('input') else None

+ 45 - 0
design-qa-task-interactions.md

@@ -0,0 +1,45 @@
+# 交互组件设计 QA
+
+## 对照基准
+
+- 视觉真源:`/Users/samien/.codex/generated_images/01a0bea3-706a-7812-b693-85595b23cbe3/exec-d9fe933f-bbe4-4105-9457-1eebb7c4c03d.png`
+- 真源像素:1536 × 1024;画面同时给出桌面端与手机端目标状态。
+- 实现地址:`http://127.0.0.1:15301/conversations/11111111-1111-4111-8111-111111111111?taskId=22222222-2222-4222-8222-222222222222`
+- 实现截图:Codex 内置浏览器 tab 4 的本轮桌面与手机截图(浏览器后端未提供可持久化的本地截图路径)。
+- 检查视口:桌面 1280 × 720;手机 CSS 视口 390 × 844。
+- 像素密度:浏览器默认 DPR;比较以 CSS 像素布局、层级、颜色、文字密度和交互状态为准。
+
+## 设计意图
+
+- 任务结果通知从居中的系统文字改为可点击的短行动卡,保留任务上下文、复核状态和唯一主行动。
+- 交付进展改为分段进度、四阶段状态和可折叠详情,首屏只保留决策所需信息。
+- 询问问题在桌面端使用紧凑选择卡,在手机端使用底部操作面板;预设答案、自由输入与提交反馈保持一致。
+- 采用克制的蓝色工作流强调色;常规文本和容器继续沿用现有中性色设计系统。
+
+## 对照记录
+
+### 第 1 轮
+
+- P1:桌面端提问卡过高,滚动到底部时标题区域被顶部裁切。
+- P2:进度与选择状态仍使用全局黑色强调色,与视觉真源的蓝色行动层级不一致。
+- P2:390px 手机视口中第 4 个进度步骤被横向裁切。
+
+修正:将自由输入和提交按钮在桌面端合并为一行;新增语义化工作流强调色;手机步骤宽度收紧为 78px,并保留超出 4 项时的横向滚动能力。
+
+### 第 2 轮
+
+- 桌面 1280 × 720:提问标题、两个选项、自由输入与提交按钮在同一可视区完整呈现。
+- 手机 390 × 844:底部操作面板、52px 选项触控区、自由输入与全宽提交按钮完整呈现。
+- 手机进度卡:4 个阶段标记均在首屏卡片内可见,长标题按现有密度截断。
+- 选择状态:原生单选值、蓝色边框、勾选图标和提交按钮同步更新。
+- 任务通知:语义结构、任务链接与复核辅助文字均由可访问性树验证。
+
+## 最终检查
+
+- 布局:通过;桌面与手机断点无横向溢出。
+- 层级与间距:通过;行动卡、进度卡和问答卡均与现有聊天宽度对齐。
+- 颜色与状态:通过;完成、进行中、待复核、禁用和选中状态可区分。
+- 字体与可读性:通过;沿用现有字体与字号体系,长任务名和结果文本有受控换行或截断。
+- 交互:通过;原生 radio、textarea、按钮与 details 均可键盘聚焦,主要触控目标不小于 44px。
+- 基础状态:通过;未选择时提交按钮禁用,选择后启用;详情折叠态和结果态已验证。该组组件没有独立的加载或空数据界面。
+- 结果:通过,无未解决的 P0/P1/P2 视觉问题。

+ 232 - 1
design-qa.md

@@ -1,10 +1,70 @@
+# 聊天气泡外观 · 三端设计验收(2026-09-21)
+
+## Findings
+
+- 没有未解决的 P0/P1/P2 问题。
+- 三套预设为「当前样式」「Grok Bot」「Codex」。Codex 的双方消息都保留填充气泡;Grok Bot 使用黑白灰。
+- 适用范围明确为当前设备上的所有会话。设计中的范围下拉改为静态说明;本次不提供账号同步或单会话覆盖。
+- 文字颜色自动选择可读前景色;不开放可能导致不可读组合的任意文字色。极端渐变增加遮罩以保持正文对比度。
+
+## Source visual truth / normalization
+
+- Source: `/Users/samien/git/yaoyao/docs/chat-appearance/approved-design.png`,1619 × 972 px,用户确认的桌面与移动端并排设计画板。
+- 按画板内桌面/手机内容区域比较,不拉伸整张画板;忽略画板标题、留白和设备系统栏。设计不是等比例设备截图,因此只比较对应布局与控件,不宣称逐像素一致。
+- 对比时将原图与实际截图放在同一工具输入中;深色和实际聊天属于补充状态,设计原图未提供其逐像素目标。
+
+## Required fidelity surfaces
+
+- 字体与排版:沿用产品/平台字体和原有正文层级;中文自然换行,长回复保留 Markdown 标题、列表和行内代码。
+- 间距与布局:桌面左侧设置、右侧预览;移动端预览在上、控制项在下,较长内容可以滚动。颜色选择与预设均有明显选中状态。
+- 颜色:Codex 浅色用户背景 #E4F3FC、蓝色正文,助手 #F1F1F1;Grok Bot 浅色用户 #090909、白字,助手浅灰。深色有独立配色;边框与尾巴、圆角可分别调节。
+- 图像:未新增装饰性位图;聊天头像和图标复用项目原组件,原生端使用系统控件。截图为运行结果,未重绘。
+- 文案:使用「聊天气泡」「预设样式」「自定义微调」「我的气泡」「助手气泡」;三套预设名称与用户确认一致。
+
+## Comparison history
+
+1. 桌面首轮发现形状项挤压底部操作区:压缩分组间距、调整操作栏,最终桌面截图可见圆角、边框、尾巴及恢复入口。
+2. iOS 自动同步十六进制字段时将预设变成自定义:增加相同值短路判断,UI 测试验证 Codex 选中、切换 Grok Bot 后撤销、重启保持。
+3. 检查发现 Bot 聊天使用独立渲染组件:三端同时接入普通聊天与 Bot 聊天,iOS 额外捕获实际 Bot 长回复的浅/深色截图。
+4. 自定义深色气泡可能影响嵌套代码卡片:保留技术卡片自身底色/文字语义,Markdown 正文随气泡配色。浏览器代码块与 iOS 长列表复核通过。
+5. 最终整理发现早期 Web 手机截图停在设置分类:重新通过「外观 → 聊天气泡」捕获实际 Grok Bot 页面,纠正验收附件。
+
+## Remaining scope / checklist
+
+- [x] 预设即时应用、自定义配色、圆角、边框、尾巴、撤销与恢复。
+- [x] 本地持久化、损坏数据回退、深浅色适配。
+- [x] 正式消息组件接入,相关自动化测试与运行截图检查。
+- [ ] 真机和发布包验收未执行;本轮使用浏览器及模拟器。
+
+## Implementation evidence / state
+
+- `docs/chat-appearance/web-desktop-codex.jpg`:1440 × 900 px,CSS viewport 1440 × 900,1×;浅色、Codex 已选、形状项展开。
+- `docs/chat-appearance/web-mobile-grok.jpg`:390 × 844 px,CSS viewport 390 × 844,1×;浅色、Grok Bot 已选、上方预览、下方控件。其余控件可滚动访问。
+- `docs/chat-appearance/web-chat-dark.jpg`:794 × 866 px 的实际 Bot 消息夹具,深色 Grok Bot;标题、列表、链接及代码块可读。
+- 入口夹具:`tests/fixtures/settings-design/index.html?view=bubbles`。消息夹具:`tests/fixtures/chat-appearance/index.html`,均使用正式组件和本地示例数据。
+- Full-view:桌面保持左右分栏并完整展示操作项;手机保持从预览到预设到自定义的顺序,无横向溢出。
+- Focused:预设卡、十六进制字段、色块、用户/助手气泡在原尺寸截图中可直接判读,无需额外裁切;实际消息截图单独验证长回复和代码块。
+
+## Verification
+
+- `npm run typecheck` 通过。
+- `npx vitest run tests/client/chatAppearance.test.ts tests/client/settingsCenterDialog.test.ts`:23 项通过。
+- 浏览器验证预设、移动端导航、深色、刷新持久化;控制台 error 日志为空。
+- 测试包含存储失败、坏数据、极端渐变、用户/助手独立编辑以及普通/Bot 消息在没有新消息时即时重新渲染。
+
+final result: passed
+
+---
+
+以下保留之前功能的验收记录。
+
 # Bot 设置与我的设置 · 第 3 组设计对照
 
 ## Findings
 
 - 当前无未解决的 P0、P1 或 P2 问题。
 - P3:项目成员使用产品现有的真实头像组件,示例图中的纯色圆点与 +1 占位没有照搬。所有成员姓名可以查看。
-- P3:保留原有管理与基础机器人功能,超出设计图显示范围的分类可在左栏滚动访问。
+- P3:普通聊天保留管理与基础机器人功能;Bot 模式的基础机器人配置已按后续批注移入“编辑资料”。
 
 ## Source visual truth
 
@@ -71,3 +131,174 @@
 - [x] 34 项相关组件测试通过,类型检查通过。
 
 final result: passed
+
+## 2026-09-15 后续批注:Bot 编辑资料与权限审批
+
+- Bot 列表右键菜单使用带图标的“编辑资料”,打开独立双栏弹窗。资料始终绑定菜单选中的 Bot,保存不切换当前单聊。
+- Bot 模式“我的设置”移除基础机器人选择器、身份与头像、模型与 Provider;普通聊天保留原入口。
+- 编辑资料包含概览、身份与头像、角色与规则、模型与 Provider、记忆和权限。模型管理复用管理员界面,绑定 Bot 已保存的本地 Profile;更换来源需要先保存。远端模型仍由远端管理。
+- 权限审批按 Bot 保存:询问我(默认)、自动允许、自动拒绝。只答复新出现的工具审批请求;不自动回答澄清,不追溯处理已等待的请求,不建立永久或整个会话的自动授权。
+- 同一 Profile 的 Bot 策略互不影响,旧记录按询问处理,自动创建的成员不能自行获得自动允许。远端引用可以设置本地审批策略,远端资料继续只读。
+- 自动审批复用现有账号、任务、会话身份校验和重复答复保护;失败保留待处理请求,重复事件不触发自动重试。
+- 桌面审批页:`docs/design/bot-approval-desktop.jpg`,1280 × 720。手机概览:`docs/design/bot-profile-mobile.jpg`,390 × 844。截图是实际组件的 CUA 原始捕获。
+- 手机初查发现导航最小宽度撑开内容区,已改为可收缩网格;修正后内容区 clientWidth=scrollWidth=380,侧栏宽 390,无内容横向裁切。
+- 资料、模型、记忆的未保存更改均受到关闭与切换保护;手机导航支持横向滚动,内容和底部保存操作分别定位。
+- 测试覆盖目标 Bot 保存、普通聊天设置保留、模型 Profile 隔离、远端审批、旧记录默认值、并发独立策略、重复请求、澄清和自动审批失败。
+- 最终验证:11 个测试文件共 167 项通过;补充的基础机器人显示名回归测试通过。类型检查与桌面服务构建通过。
+
+## 2026-09-15:聊天审批卡片 · 已选第 1 版
+
+### Findings
+
+- 无未解决的 P0/P1/P2 问题。审批按「允许」「拒绝」「自动允许」横排,明确区分单次答复与 Bot 长期设置。
+- P3:按钮最小高度采用 44px/pt;Android 使用 Material 触控尺寸。图标采用 Tabler / SF Symbols / Material 原生库,细节存在平台差异。
+
+### Source visual truth and evidence
+
+- 用户选中本轮第一张实际展示的生成图:`docs/design/approval-card-reference.png`,853 × 1844,原生成文件 `exec-bf524680-3635-401c-8ab8-74eda9fd1ca4.png`。
+- Web 初查:`docs/design/approval-card-web-before.jpg`;最终:`docs/design/approval-card-web.jpg`,390 × 844。
+- Web 深色长说明:`docs/design/approval-card-web-dark.jpg`,320 × 844。
+- iOS 初查:`docs/design/approval-card-ios-before.jpg`;最终:`docs/design/approval-card-ios.jpg`,440 × 942,来自 iPhone 17 模拟器窗口的 CUA 截图。
+- 预览:`http://127.0.0.1:5173/tests/fixtures/approval-card/`;iOS Debug 场景 `workspace-approval` 使用正式 SwiftUI 组件。预览操作不写入用户数据。
+
+### Viewport, normalization, and comparison
+
+- 对比范围是审批卡片。源图按 390/853 比例对应手机逻辑宽度;Web 为 390px、1x 捕获,卡片外宽 358px。iOS 预览内容最大宽 390pt,卡片宽 358pt;比较时排除模拟器工具栏、设备边框及系统状态栏,并以卡片宽度归一。
+- 白色空白处是隔离验收场景,不作为聊天页面改版内容;真实聊天继续使用已有消息、头像、媒体和输入框。
+- 最终一次比较在同一个工具结果内同时打开源图、Web 最终截图和 iOS 最终截图,直接检查卡片标题、说明、三按钮、两行辅助文字。这个区域内文字与边界清晰,不需要额外放大截图。
+- 320px 深色检查:文档 scrollWidth=320,三按钮各 82px,无文字溢出;长工具说明可滚动,三个操作始终可见。浏览器控制台没有错误。
+
+### Comparison history
+
+1. [P2] 初版 Web 纵向间距偏大,卡片约 204px 高。收紧标题、说明和辅助文字间距,最终约 189px;维持 44px 按钮和 14px 正文。
+2. [P2] 初版 iOS 标题图标偏小、拒绝按钮边界与辅助文字偏淡。改为 24pt 盾形图标,加深边框和文字;重新构建后捕获最终模拟器画面并与源图复核。
+
+### Required fidelity surfaces
+
+- 字体:使用原有 PingFang/SF/系统字体,标题 18、按钮与说明 14、辅助文字 13/12;按钮保持单行,长说明完整滚动显示(Web)。
+- 布局:18px 圆角、14px 内边距、三列等宽按钮、6px 间隔,允许为实色主按钮,拒绝为描边按钮,自动允许为浅灰按钮。
+- 颜色:Web 复用已选设置弹窗语义色,iOS 使用动态系统颜色,Android 使用 Material 前景/背景色;支持深色反转及清楚的禁用状态。
+- 图片:本次卡片没有新栅格资产;盾形及圆形勾选图标来自现有图标库。设计图保留为审核依据。
+- 文案:准确使用「允许」「拒绝」「自动允许」,说明「允许仅本次;自动允许后不再询问」「自动允许会同步此 Bot 的权限设置」。
+
+### Interaction and regression checks
+
+- 浏览器验证单次允许后仍会出现下一次审批;自动允许后,模拟下一次操作直接通过;处理中三按钮禁用。iOS 原生自动允许按钮显示相应完成反馈。
+- 服务端只依据审批记录里的 agentId 更新所属 Bot;发送给 Hermes 的本次答复仍为 once。紧接着出现的请求使用新策略,同 Profile 的其他 Bot 不受影响。
+- 自动允许意图和发送状态在同一事务中保存;上游答复未确认时保留该显式设置并清楚报错,不重复发送不确定请求。已完成请求的重放不会重新覆盖用户后来修改的设置。
+- 审批设置单独变更保留当前有效组队授权,不恢复失效授权。普通聊天审批组件与澄清输入流程保持原有范围。
+- Web 相关测试、类型检查通过;iOS 70 项 WorkspaceChat 测试通过。第一次无签名运行触发了登录测试的 Keychain entitlement 错误,使用项目正常签名后全部通过。
+- Android Compose 编译、模型/网络测试和 Debug APK 构建通过;新增请求测试确认自动允许仅提交审批 ID 和 answer。Android 尚未做设备截图,手机端尚未安装新版。
+
+final result: passed
+
+## 2026-09-21:群聊交付目标入口收进加号菜单
+
+### Findings
+
+- 无未解决的 P0/P1/P2 设计差异。入口默认隐藏在「+」中,启用后显示「交付目标 ×」,退出不清空草稿。
+- 预期差异:保留现有输入框高度、字体栈和思考按钮样式;示意图中的黑色发送按钮在空草稿时沿用产品的灰色禁用状态。只调整入口位置和启用标签,不重做整个输入器。
+
+### Source visual truth / implementation evidence
+
+- 源图:`/Users/samien/.codex/generated_images/01a0bf4c-963e-7eb0-a445-1ec9413c1ed0/exec-9ae39651-447d-412c-a319-91a5e892efc9.png`,1536 × 1024,桌面与 iOS 双栏概念画板。
+- 本地验证:`http://127.0.0.1:5173/test-results/delivery-mode/`,直接渲染正式 `ComposerShell`;夹具不请求生产接口。
+- 全景:`/Users/samien/git/yaoyao/test-results/delivery-mode/desktop-menu.png`、`desktop-active.png`,1200 × 900,CSS viewport 同尺寸、1x。
+- 聚焦证据:同目录 `desktop-menu-focus.png`(776 × 258,原图 x=212/y=634)、`desktop-active-focus.png`(776 × 136,原图 x=212/y=756)。只裁剪原始截图,未重绘 UI。
+- 响应式:同目录 `web-narrow-menu.png`(375 × 812)、`web-320-dark.png`(320 × 740),1x。
+- 将源图与两个聚焦截图放在同一个比较输入中复核。源图不是完整应用页面;按输入器内容区比较层级、顺序、间距和文案,不将整张双栏画板拉伸成网页,也不把密度差异当作缺陷。
+
+### Required fidelity surfaces
+
+- 字体:沿用 Inter / SF Pro / PingFang SC 字体栈;菜单 14px、说明 12px、标签 13px。四字标签与单行说明清晰,无截断;已有思考控件字号不变。
+- 布局:左下「+」锚定上方菜单;附件、提及、分隔线、交付目标顺序一致。开启标签紧随加号,后接思考及提及。菜单宽 280px,视口约束避免越界;桌面标签 36px,窄屏 44px。
+- 颜色:白色菜单、细边框、浮层阴影、浅蓝标签延续源图。新增 `--delivery-accent`:浅色 #245fc5、深色 #78a9ff,12% 底色;计算的文字对比度约 5.02:1 / 6.02:1。
+- 图标/图像:复用现有 AppIcon 和 Tabler 的纸夹、加号、@、Target、关闭图标;标准图标的平台笔画差异可接受,无新增位图、模糊缩放或装饰图形。
+- 文案:菜单为「添加附件」「提及成员」「交付目标」「让团队持续完成一个结果」;启用后占位「描述希望团队交付的结果…」。关闭按钮有完整无障碍标签。
+
+### Comparison history
+
+1. [P2] 初始强调色在浅蓝底上对比约 4.40:1。新增更深的浅色目标专用 token,复核最终 active 截图,现为约 5.02:1;深色维持浅蓝前景。
+2. [P2] 极窄屏工具栏重复保留提及入口会挤压空间。窄屏隐藏重复提及按钮,保留加号菜单中的同一功能。最终 320px 深色截图无裁切:加号 x=27..71,标签 x=74..195,思考 x=198..228,发送 x=259..293。
+
+### Interaction / implementation checklist
+
+- [x] 菜单开启目标、关闭标签、草稿保持、附件入口与提及成员。
+- [x] Escape、方向键、Home/End、Tab、外部点击与焦点恢复。
+- [x] 禁用目标时保留原因;单聊与已有目标不显示创建入口。
+- [x] 真实会话视图集成测试验证 goal/chat 发送模式,不改变后端交付逻辑。
+- [x] 19 项相关测试通过;类型检查及完整 `npm run build` 通过;浏览器控制台无 error/warn。
+- 未部署到服务器;未实际发送生产消息。iOS 原生端证据记录在移动仓库的 `design-qa.md`。
+
+final result: passed
+
+
+---
+
+# 2026-09-21:统一系统提示为居中灰色图标和标题
+
+## Findings
+
+- 无未解决的 P0/P1/P2 视觉问题。任务分派、任务结果、回复中断、响应超时、子任务完成、上下文压缩、后台任务共用同一提示组件。
+- 正文与系统事件分开;任务结果点击打开对应任务,其余提示点击查看完整详情。失败前已生成的正文与附件保留。
+- 普通消息的气泡遵循已有外观设置;设计图的无气泡样式不覆盖用户已有设置。当前确认范围为系统提示。
+
+## Source / evidence / normalization
+
+- 确认图:`docs/system-notices/approved-design.png`,1619 × 971像素。合并比较:`docs/system-notices/comparison.png`,上方为源图,下方为正式 Vue 组件的实际渲染。
+- 截图 `desktop.png`:1440 × 1024,CSS viewport 同尺寸、1x;`mobile.png`、`mobile-dark.png`、`ordinary.png`:390 × 844、1x。
+- 源图是桌面/手机双栏概念画板,按各自消息内容区域归一比较图标、字体、水平对齐和留白,不拉伸整张画板。iOS 原生抽屉交互另见移动仓库验收记录。
+- 同目录 `*-expanded.png` 保留展开详情状态。13px 标签在原尺寸移动截图可直接判断,不需要另做放大裁切;合并图用于全景对照。
+- 本地入口:`http://127.0.0.1:15301/tests/fixtures/system-notices/index.html`,`?ordinary` 为普通聊天,`?dark` 为深色。使用正式消息时间线与本地示例数据。
+
+## Fidelity / comparison history
+
+- 字体:复用产品系统字体,13px 常规字重、1.6 行高;图标16px,间隔6px,支持长标题换行。
+- 布局:相对整条消息时间线居中,无默认背景/边框/阴影,最小点击高度44px。细节内容仅在打开后显示,恢复左对齐。
+- 颜色:浅色标签 rgb(111,111,105),深色 rgb(160,160,154),沿用语义 token。任务结果不再单独使用蓝色卡片。
+- 图像:采用已有线性图标库,无装饰性位图、替代头像或重绘截图。
+- 文案:只显示图标与短标题,去掉默认副标题、状态说明和「打开任务」操作字样;完整内容与导航可访问性标签保留。
+- 首轮发现中断提示仍跟随气泡宽度偏左:移到时间线整行,最终截图及 `checks.json` 中全部提示的水平中心偏差为0px。
+
+## Verification
+
+- 完整 `npm run build` 与 Vue 类型检查通过;5 个相关测试文件共19项通过。
+- 浏览器4组 viewport/theme/surface 检查通过:键盘展开、错误详情、部分回复保留、任务链接、无横向溢出、无页面异常。
+- iOS 与 Android 同步使用灰色居中提示;iOS 按后续要求改为半屏/全屏抽屉,详情不撑开时间线。
+- 未部署到服务器或安装到真机。
+
+final result: passed
+
+
+---
+
+# 2026-09-21:正文、图片、文件按原顺序独立展示
+
+## Findings / scope
+
+- 无未解决的 P0/P1/P2 视觉差异。文件按照用户手机截图:浅灰、贴合内容的圆角块,左侧文件图标,文件名与灰色扩展名,下方仅显示大小。图片独立显示,不套正文气泡。
+- 普通聊天与 Bot 时间线均接入。保留原有外观设置、头像、复制/引用操作、系统提示和预览入口;夹具中的 Grok 配色只是演示,不强制更改产品默认。
+- 内容流保留文字 → 图片 → 文字 → 文件 → 文字的顺序;结构化附件与 Markdown 引用去重。正文中的普通链接和代码示例保留原样。
+
+## Source / normalization / evidence
+
+- 源图:`docs/media-qa/approved-design.png`,1577 × 997。依据用户提供的手机文件块照片修正后的确认稿。
+- 运行截图:`desktop.png` 1040 × 900、`mobile.png` 390 × 844、`mobile-dark-order.png` 390 × 844、`mobile-light-order.png` 与 `mobile-ordinary.png` 375 × 812。CSS viewport 与截图同尺寸,1x。
+- 对照源图及运行截图的消息内容区域,忽略概念图设备栏、画板边距和现有产品操作行;不宣称整页逐像素复刻。文件块在原尺寸截图中可直接判读。
+- 本地入口:`http://127.0.0.1:15301/tests/fixtures/message-media/index.html`;`?ordinary` 普通聊天,`?order` 顺序验证,`?dark` 深色。正式 Vue 组件、本地数据,预览回调用夹具弹窗验证,不访问生产附件。
+
+## Fidelity / comparison history
+
+- 字体:现有产品字体,文件名16px中等字重,扩展名和12px大小使用次要灰色;未知大小不伪造。
+- 布局:文件最小高度64px、圆角20px、内容间隔8px;图片圆角12px,按原比例显示,桌面最大430px宽,手机受可用宽度约束。
+- 颜色:文件底色浅色 #F1F1F1、深色 #262626。首轮发现 scoped 深色选择器失效导致深色页面文件块发白,已改为主题 token,截图复核通过。
+- 图像:复用现有线性图标;竹叶图是根据用户照片生成的测试素材,仅用于夹具。图片自身显示,不额外加标题框、边框或阴影。
+- 文案:`bamboo-sample.txt`、`134 B`;移除文件块中多余的「预览/下载」文字,保留按钮的完整可访问名称。
+
+## Verification
+
+- 完整 `npm run build`(含类型检查)通过;9个相关测试文件58项通过,覆盖外观、Markdown、文件顺序、去重、普通/Bot 时间线以及系统提示回归。
+- 浏览器实测375px无横向溢出:scrollWidth=375;文件块218 × 64,图片约337 × 190且加载完成。文件与图片点击均触发对应预览回调,控制台 error 为空。
+- 未发布到服务器;浏览器预览和源代码已完成。
+
+final result: passed

+ 135 - 0
desktop/computer-targets.test.mjs

@@ -0,0 +1,135 @@
+import {test} from 'node:test'
+import assert from 'node:assert/strict'
+import {mkdtemp,writeFile,mkdir,rm} from 'node:fs/promises'
+import {tmpdir} from 'node:os'
+import {join,resolve} from 'node:path'
+import {pathToFileURL} from 'node:url'
+import {spawn} from 'node:child_process'
+import {_electron as electron,expect} from '@playwright/test'
+
+const root=resolve(import.meta.dirname,'..')
+test('selected previews reach the matching native desktop and switch only after returning the old lease',{timeout:120000},async()=>{
+ const home=await mkdtemp(join(tmpdir(),'yaoyao-computer-targets-')),origin='http://127.0.0.1:18865'
+ const server=spawn(process.execPath,['--import','tsx','tests/fixtures/workspace-server.ts'],{cwd:root,
+  env:{...process.env,WORKSPACE_FIXTURE_HOME:home,WORKSPACE_FIXTURE_TEAM_TOOLS:'1',WORKSPACE_FIXTURE_PORT:'18865',WORKSPACE_FIXTURE_UPSTREAM_PORT:'19165'},stdio:'ignore'})
+ let app
+ try{
+  await expect.poll(async()=>{try{return(await fetch(origin+'/healthz')).status}catch{return 0}},{timeout:30000}).toBe(200)
+  const harness=join(home,'main.mjs')
+  await writeFile(harness,`import {app,BrowserWindow} from 'electron';
+import {installComputerViewer} from '${pathToFileURL(join(root,'desktop/computer-viewer.mjs')).href}';
+app.setPath('userData',${JSON.stringify(join(home,'chromium'))});
+app.whenReady().then(async()=>{let quitting=false;app.on('before-quit',()=>quitting=true);
+const owner=new BrowserWindow({width:1440,height:900,webPreferences:{preload:${JSON.stringify(join(root,'desktop/preload.cjs'))},sandbox:true,contextIsolation:true}});
+installComputerViewer({owner:()=>owner,origin:()=>${JSON.stringify(origin)},preload:${JSON.stringify(join(root,'desktop/preload.cjs'))},quitting:()=>quitting});
+await owner.loadURL(${JSON.stringify(origin+'/conversations')});});`)
+  app=await electron.launch({args:[harness],cwd:root})
+  const page=await app.firstWindow()
+  await page.getByRole('textbox',{name:'账号',exact:true}).fill('fixture')
+  await page.getByRole('textbox',{name:'密码',exact:true}).fill('fixture-pass')
+  await page.getByRole('button',{name:'登录',exact:true}).click()
+  await expect(page.locator('.desktop-sidebar .sidebar-create-trigger')).toBeVisible()
+  const seed=await(await page.request.post(origin+'/__test/computer',{data:{}})).json()
+  const targets=[
+   {key:'desktop:local',backend:'desktop',host:'local',name:'服务器',color:'#263f59'},
+   {key:'desktop:client-mac',backend:'desktop',host:'client-mac',name:'Mac Studio 客户端',color:'#245b49'},
+   {key:'cloud',backend:'cloud',name:'Grok Bot 云端',color:'#6a405e'},
+   {key:'vm',backend:'vm',name:'独立虚拟机',color:'#65502c'},
+  ]
+  const images=await page.evaluate(targets=>Object.fromEntries(targets.map(target=>{
+   const canvas=document.createElement('canvas');canvas.width=1280;canvas.height=800
+   const ctx=canvas.getContext('2d');ctx.fillStyle=target.color;ctx.fillRect(0,0,1280,800)
+   ctx.fillStyle='#ffffff';ctx.font='52px sans-serif';ctx.fillText(target.name,70,180)
+   ctx.font='28px sans-serif';ctx.fillText('验证桌面 · '+target.key,70,245)
+   return [target.key,canvas.toDataURL('image/png').split(',')[1]]
+  })),targets)
+  const permission={supported:true,authorized:true,screen:true,accessibility:true,ready:true,fullAuthorized:true}
+  const hosts=targets.filter(t=>t.backend==='desktop').map(t=>({id:t.host,name:t.name,online:true,local:permission,browser:{available:false}}))
+  const calls=[],leases=new Set()
+  let refuseGiveback=false
+  await app.context().route('**/api/app/settings/host-tools',route=>route.fulfill({json:{scriptMachine:true,serverComputer:true,vm:true,cloud:true}}))
+  await app.context().route('**/api/app/agents/*/**',async route=>{
+   const url=new URL(route.request().url()),path=url.pathname
+   if(!path.startsWith(`/api/app/agents/${seed.agentId}/`))return route.continue()
+   if(path.endsWith('/desktop-environment'))return route.fulfill({json:{hosts,online:true,local:permission}})
+   if(path.endsWith('/cloud-computer')||path.endsWith('/cloud-computer/open'))return route.fulfill({json:{configured:true,running:true,connected:true}})
+   if(path.endsWith('/local-vm'))return route.fulfill({json:{enabled:true,image:true,container:'running',ready:true,mode:'per-bot',fixedCapacity:true}})
+   if(!path.includes('/computer'))return route.continue()
+   const backend=url.searchParams.get('backend'),host=url.searchParams.get('host')
+   const key=backend==='desktop'?'desktop:'+host:backend
+   const target=targets.find(t=>t.key===key)
+   if(!target)return route.fulfill({status:409,json:{error:'Fixture requires an explicit computer target'}})
+   if(path.endsWith('/frame'))return route.fulfill({json:{id:key,data:images[key],width:1280,height:800,generation:1}})
+   if(route.request().method()==='POST'){
+    const op=path.split('/').at(-1);calls.push({op,key})
+    if(op==='giveback'&&refuseGiveback)return route.fulfill({status:409,json:{error:'Fixture giveback temporarily unavailable'}})
+    if(op==='take')leases.add(key)
+    if(op==='giveback')leases.delete(key)
+   }
+   return route.fulfill({json:{mode:leases.has(key)?'human':'idle',backend:backend==='desktop'?'local':backend==='cloud'?'grok':'docker',
+    hostName:target.name,generation:1,controlId:leases.has(key)?key:undefined,token:'fixture-token'}})
+  })
+  await page.goto(origin+'/conversations/'+seed.conversationId)
+  await page.getByRole('button',{name:'电脑与定时任务',exact:true}).click()
+  const dock=page.getByRole('complementary',{name:'机器人电脑面板'})
+  await expect(dock.getByRole('combobox',{name:'显示的桌面'})).toBeVisible()
+  let viewer,previousKey
+  for(const target of targets){
+   await dock.getByRole('combobox',{name:'显示的桌面'}).selectOption(target.key)
+   await expect(dock.locator('.preview img')).toHaveAttribute('src','data:image/png;base64,'+images[target.key])
+   const opened=app.waitForEvent('window')
+   await dock.locator('.preview').click()
+   const oldViewer=viewer;viewer=await opened
+   await expect(viewer.locator('.computer-panel.standalone')).toContainText('人工控制中')
+   await expect(viewer.locator('.computer-screen img')).toHaveAttribute('src','data:image/png;base64,'+images[target.key])
+   const url=new URL(viewer.url())
+   assert.equal(url.searchParams.get('backend'),target.backend)
+   assert.equal(url.searchParams.get('host'),target.host??null)
+   if(oldViewer){
+    assert.equal(oldViewer.isClosed(),true)
+    assert.ok(calls.findIndex(c=>c.op==='giveback'&&c.key===previousKey)<calls.findIndex(c=>c.op==='take'&&c.key===target.key))
+   }
+   assert.deepEqual([...leases],[target.key])
+   previousKey=target.key
+   if(target.host==='client-mac'){
+    const output=join(root,'docs/verification/2026-09-19-computer-targets');await mkdir(output,{recursive:true})
+    await viewer.screenshot({path:join(output,'client-desktop.png')})
+    await page.setViewportSize({width:390,height:844});await page.screenshot({path:join(output,'selected-client-mobile.png')})
+    await page.setViewportSize({width:1440,height:900})
+   }
+  }
+  // Reopening an unchanged target focuses its existing window.
+  await page.evaluate(({id,target})=>window.yaoyaoDesktop.openComputer(id,target),{id:seed.agentId,target:{backend:'vm'}})
+  assert.equal(viewer.isClosed(),false);assert.equal(app.windows().length,2)
+  const rejected=await page.evaluate(async id=>{try{await window.yaoyaoDesktop.openComputer(id,{backend:'vm',host:'client-mac'});return false}catch{return true}},seed.agentId)
+  assert.equal(rejected,true);assert.equal(viewer.isClosed(),false)
+  refuseGiveback=true
+  const beforeFailedSwitch=calls.length
+  const failedSwitch=await page.evaluate(async id=>{
+   try{await window.yaoyaoDesktop.openComputer(id,{backend:'desktop',host:'local'});return ''}
+   catch(error){return error.message}
+  },seed.agentId)
+  assert.match(failedSwitch,/尚未交还/)
+  assert.equal(viewer.isClosed(),false);assert.deepEqual([...leases],['vm'])
+  assert.equal(calls.slice(beforeFailedSwitch).some(c=>c.op==='take'),false)
+  refuseGiveback=false
+  // A manual change inside the viewer must update the identity used for reuse.
+  await viewer.getByRole('button',{name:'键盘与操作',exact:true}).click()
+  await viewer.getByRole('button',{name:'结束控制',exact:true}).click()
+  await viewer.getByRole('combobox',{name:'切换电脑环境'}).selectOption('desktop:local')
+  await expect(viewer.locator('.computer-screen img')).toHaveAttribute('src','data:image/png;base64,'+images['desktop:local'])
+  const reopened=app.waitForEvent('window'),oldViewer=viewer
+  await page.evaluate(id=>window.yaoyaoDesktop.openComputer(id,{backend:'vm'}),seed.agentId)
+  viewer=await reopened
+  await expect(viewer.locator('.computer-panel')).toContainText('人工控制中')
+  assert.equal(oldViewer.isClosed(),true)
+  await expect(viewer.locator('.computer-screen img')).toHaveAttribute('src','data:image/png;base64,'+images.vm)
+  await viewer.getByRole('button',{name:'交还并关闭',exact:true}).click()
+  await expect.poll(()=>viewer.isClosed()).toBe(true)
+  assert.equal(leases.size,0)
+ }finally{
+  await app?.close().catch(()=>{})
+  server.kill('SIGTERM');if(server.exitCode===null)await new Promise(done=>server.once('exit',done))
+  await rm(home,{recursive:true,force:true})
+ }
+})

+ 44 - 10
desktop/computer-viewer.mjs

@@ -2,18 +2,47 @@ import { BrowserWindow, ipcMain } from 'electron'
 
 /** Local authenticated viewer. Agent ownership and control leases remain server-authoritative. */
 export function installComputerViewer({ owner, origin, preload, quitting = () => false }) {
-  let viewer, agentId, approvedClose = false
+  let viewer, viewerURL, currentTargetURL, approvedClose = false, opening = Promise.resolve()
   const trusted = event => event.sender === owner()?.webContents && event.senderFrame === event.sender.mainFrame
     && new URL(event.senderFrame.url).origin === origin()
-  ipcMain.handle('desktop-computer:open', async (event, id) => {
-    if (!trusted(event) || typeof id !== 'string' || !/^[\w-]{1,128}$/.test(id)) throw new Error('电脑窗口请求无效')
+  const targetURL = (id, target = {}) => {
+    if (typeof id !== 'string' || !/^[\w-]{1,128}$/.test(id)) throw new Error('电脑窗口请求无效')
+    if (!target || typeof target !== 'object' || Array.isArray(target)
+      || Object.keys(target).some(key => !['backend', 'host'].includes(key))
+      || (target.backend !== undefined && !['desktop', 'cloud', 'vm'].includes(target.backend))
+      || (target.host !== undefined && (target.backend !== 'desktop' || typeof target.host !== 'string' || !/^[\w-]{1,128}$/.test(target.host))))
+      throw new Error('所选电脑无效,请重新选择')
+    const url = new URL(`/conversations/computer/${encodeURIComponent(id)}`, origin())
+    if (target.backend) url.searchParams.set('backend', target.backend)
+    if (target.backend === 'desktop') url.searchParams.set('host', target.host || 'local')
+    return url.href
+  }
+  ipcMain.handle('desktop-computer:open', (event, id, target) => {
+    if (!trusted(event)) throw new Error('电脑窗口请求无效')
+    const requestedURL = targetURL(id, target)
+    const pending = opening.catch(() => {}).then(() => open(requestedURL))
+    opening = pending
+    return pending
+  })
+  async function open(url) {
+    if (quitting()) return false
     if (viewer && !viewer.isDestroyed()) {
-      viewer.show(); viewer.focus()
-      if (agentId !== id) throw new Error('请先交还并关闭当前电脑,再接管另一台电脑')
-      return true
+      if (currentTargetURL === url) { viewer.show(); viewer.focus(); return true }
+      // The old page must return its lease before another target can open.
+      const previous = viewer
+      await new Promise((resolve, reject) => {
+        const closed = () => { clearTimeout(timeout); resolve() }
+        const timeout = setTimeout(() => {
+          previous.removeListener('closed', closed)
+          if (!previous.isDestroyed()) { previous.show(); previous.focus() }
+          reject(new Error('当前电脑尚未交还,请在电脑窗口交还并关闭后重试'))
+        }, 15000)
+        previous.once('closed', closed)
+        previous.close()
+      })
     }
-    const url = new URL(`/conversations/computer/${encodeURIComponent(id)}`, origin()).href
-    agentId = id; approvedClose = false
+    if (quitting()) return false
+    viewerURL = url; currentTargetURL = url; approvedClose = false
     const current = viewer = new BrowserWindow({ parent: owner(), modal: false, width: 1220, height: 820,
       minWidth: 760, minHeight: 520, show: false, title: '电脑接管 · 夭夭 AI', backgroundColor: '#111315', autoHideMenuBar: true,
       webPreferences: { preload, sandbox: true, contextIsolation: true, nodeIntegration: false, webSecurity: true } })
@@ -26,14 +55,19 @@ export function installComputerViewer({ owner, origin, preload, quitting = () =>
         event.preventDefault(); current.webContents.send('desktop-computer:request-close')
       }
     })
-    current.on('closed', () => { if (viewer === current) { viewer = undefined; agentId = undefined } })
+    current.on('closed', () => { if (viewer === current) { viewer = undefined; viewerURL = undefined; currentTargetURL = undefined } })
     current.once('ready-to-show', () => { current.show(); current.focus() })
     try { await current.loadURL(url) } catch (error) { approvedClose = true; current.close(); throw error }
     return true
+  }
+  ipcMain.handle('desktop-computer:target', (event, target) => {
+    if (event.sender !== viewer?.webContents || event.senderFrame !== event.sender.mainFrame
+      || event.senderFrame.url !== viewerURL) throw new Error('电脑窗口身份无效')
+    currentTargetURL = targetURL(decodeURIComponent(new URL(viewerURL).pathname.split('/').at(-1)), target)
   })
   ipcMain.handle('desktop-computer:closed', event => {
     if (event.sender !== viewer?.webContents || event.senderFrame !== event.sender.mainFrame
-      || new URL(event.senderFrame.url).pathname !== `/conversations/computer/${agentId}`) throw new Error('电脑窗口身份无效')
+      || event.senderFrame.url !== viewerURL) throw new Error('电脑窗口身份无效')
     approvedClose = true; viewer.close()
   })
   const close = () => { approvedClose = true; viewer?.destroy() }

+ 15 - 0
desktop/environment-exchange.mjs

@@ -0,0 +1,15 @@
+import {request} from 'node:http'
+
+// A 10 MiB receive command expands to about 14 MiB as JSON/base64.
+export function exchangeDesktopEnvironment(record,body){return new Promise((resolve,reject)=>{
+ const url=new URL('/desktop/environment',record.url)
+ if(url.protocol!=='http:'||url.hostname!=='127.0.0.1')return reject(new Error('桌面服务地址无效'))
+ const bytes=Buffer.from(JSON.stringify(body))
+ const req=request(url,{method:'POST',headers:{'x-yaoyao-desktop-token':record.token,'content-type':'application/json','content-length':bytes.length}},res=>{
+  let size=0;const chunks=[]
+  res.on('data',chunk=>{size+=chunk.length;if(size>16*1024*1024)res.destroy(new Error('桌面命令超过限制'));else chunks.push(chunk)})
+  res.on('error',reject)
+  res.on('end',()=>{try{if(res.statusCode!==200)throw new Error('桌面服务未连接');resolve(JSON.parse(Buffer.concat(chunks)))}catch(error){reject(error)}})
+ })
+ req.on('error',reject);req.setTimeout(5000,()=>req.destroy(new Error('桌面连接超时')));req.end(bytes)
+})}

+ 48 - 13
desktop/environment-host.mjs

@@ -3,26 +3,55 @@ import {hostname} from 'node:os'
 import {readFileSync,writeFileSync,mkdirSync} from 'node:fs'
 import {join} from 'node:path'
 import {randomUUID} from 'node:crypto'
-import {request} from 'node:http'
 import {execFile} from 'node:child_process'
 import {BrowserEnvironment} from './browser-environment.mjs'
+import {listHostFiles,readHostFile,writeHostFile,receiveHostFile,execHostShell} from './host-files.mjs'
+import {exchangeDesktopEnvironment as exchange} from './environment-exchange.mjs'
+import {FileTransferFiles} from './file-transfer.mjs'
 
-function exchange(record,body){return new Promise((resolve,reject)=>{const url=new URL('/desktop/environment',record.url);if(url.protocol!=='http:'||url.hostname!=='127.0.0.1')return reject(new Error('桌面服务地址无效'));const bytes=Buffer.from(JSON.stringify(body)),req=request(url,{method:'POST',headers:{'x-yaoyao-desktop-token':record.token,'content-type':'application/json','content-length':bytes.length}},res=>{let size=0;const chunks=[];res.on('data',chunk=>{size+=chunk.length;if(size>256*1024)res.destroy(new Error('桌面命令超过限制'));else chunks.push(chunk)});res.on('error',reject);res.on('end',()=>{try{if(res.statusCode!==200)throw new Error('桌面服务未连接');resolve(JSON.parse(Buffer.concat(chunks)))}catch(error){reject(error)}})});req.on('error',reject);req.setTimeout(5000,()=>req.destroy(new Error('桌面连接超时')));req.end(bytes)})}
-export class DesktopEnvironmentHost {
- constructor({manager,root,dataRoot}){this.manager=manager;this.root=root;this.dataRoot=dataRoot;this.id=randomUUID();this.results=[];this.running=new Set();this.closed=false;this.browser=new BrowserEnvironment(join(dataRoot,'bot-browsers'));this.approved=new Set();this.permissionsFile=join(dataRoot,'computer-permissions.json');try{const list=JSON.parse(readFileSync(this.permissionsFile,'utf8'));if(Array.isArray(list))for(const key of list)if(/^[a-f0-9]{64}$/.test(key))this.approved.add(key)}catch{}this.frames=new Map()}
- info(){return {id:this.id,name:hostname(),platform:process.platform,screen:process.platform==='darwin'&&systemPreferences.getMediaAccessStatus('screen')==='granted',accessibility:process.platform==='darwin'&&systemPreferences.isTrustedAccessibilityClient(false),approved:[...this.approved]}}
- async revoke(){this.approved.clear();this.save();this.frames.clear();this.id=randomUUID()}
- save(){mkdirSync(this.dataRoot,{recursive:true,mode:0o700});writeFileSync(this.permissionsFile,JSON.stringify([...this.approved]),{mode:0o600})}
+/** Command execution shared by the loopback server and remote computers. */
+export class DesktopHostCore {
+ constructor({root,dataRoot}){this.root=root;this.dataRoot=dataRoot;this.home=process.env.HOME||'/';this.id=randomUUID();this.results=[];this.running=new Set();this.closed=false;this.browser=new BrowserEnvironment(join(dataRoot,'bot-browsers'));this.approved=new Set();this.approvedFull=new Set();this.permissionsFile=join(dataRoot,'computer-permissions.json');try{const stored=JSON.parse(readFileSync(this.permissionsFile,'utf8'));const screen=Array.isArray(stored)?stored:stored.screen;const full=Array.isArray(stored)?[]:stored.full;if(Array.isArray(screen))for(const key of screen)if(/^[a-f0-9]{64}$/.test(key))this.approved.add(key);if(Array.isArray(full))for(const key of full)if(/^[a-f0-9]{64}$/.test(key))this.approvedFull.add(key)}catch{}this.frames=new Map()}
+ transfers=new Map()
+ info(){return {id:this.id,name:hostname(),platform:process.platform,screen:process.platform==='darwin'&&systemPreferences.getMediaAccessStatus('screen')==='granted',accessibility:process.platform==='darwin'&&systemPreferences.isTrustedAccessibilityClient(false),approved:[...this.approved],full:[...this.approvedFull],fileTransferVersion:1}}
+ async clearTransfers(){const transfers=[...this.transfers.values()];this.transfers.clear();await Promise.allSettled(transfers.map(transfer=>transfer.close()))}
+ async revoke(){this.approved.clear();this.approvedFull.clear();this.save();this.frames.clear();this.id=randomUUID();await this.clearTransfers()}
+ async recycle(){this.results=[];this.id=randomUUID();await this.clearTransfers();await this.browser.close()}
+ save(){mkdirSync(this.dataRoot,{recursive:true,mode:0o700});writeFileSync(this.permissionsFile,JSON.stringify({screen:[...this.approved],full:[...this.approvedFull]}),{mode:0o600})}
+ takeResults(){const sent=this.results.slice();this.results.splice(0,sent.length);return sent}
+ async handle(commands){for(const c of commands??[]){if(this.running.has(c.id))continue;this.running.add(c.id);const epoch=this.id;void this.execute(c).then(value=>{if(epoch===this.id)this.results.push({id:c.id,value})},error=>{if(epoch===this.id)this.results.push({id:c.id,error:String(error.message).slice(0,500)})}).finally(()=>this.running.delete(c.id))}}
  async execute(c){const epoch=this.id;if(Date.now()>c.deadline||this.closed)throw new Error('桌面请求已过期');if(!/^[a-f0-9]{64}$/.test(c.owner))throw new Error('桌面请求身份无效')
   if(c.operation==='authorize'){
    if(process.platform!=='darwin')throw new Error('此电脑暂不支持本机控制')
-   const {response}=await dialog.showMessageBox({type:'question',title:'授权本机控制',message:`允许夭夭账号「${String(c.account??'当前账号').slice(0,100)}」的机器人查看和操作这台 Mac?`,detail:'授权后,机器人和该账号的 Web、手机端可以查看屏幕,并在接管时操作鼠标和键盘。你可以在夭夭菜单中撤销。',buttons:['取消','允许并检查系统权限'],defaultId:0,cancelId:0})
-   if(response!==1||Date.now()>c.deadline||this.closed||epoch!==this.id)throw new Error('本机控制授权已取消')
-   this.approved.add(c.owner);this.save()
+   const full=c.scope==='full'
+   const {response}=await dialog.showMessageBox({type:'question',title:full?'授权文件与命令':'授权本机控制',
+    message:`允许夭夭账号「${String(c.account??'当前账号').slice(0,100)}」的机器人${full?'使用这台 Mac 的文件并执行命令':'查看和操作这台 Mac'}?`,
+    detail:full?'机器人可以列出、读取和写入你用户主目录内的文件,并在这台 Mac 上执行 shell 命令。仅对信任的机器人开启;可随时在夭夭菜单中撤销。':'授权后,机器人和该账号的 Web、手机端可以查看屏幕,并在接管时操作鼠标和键盘。你可以在夭夭菜单中撤销。',
+    buttons:full?['取消','允许文件与命令']:['取消','允许并检查系统权限'],defaultId:0,cancelId:0})
+   if(response!==1||Date.now()>c.deadline||this.closed||epoch!==this.id)throw new Error(full?'文件与命令授权已取消':'本机控制授权已取消')
+   if(full)this.approvedFull.add(c.owner);else this.approved.add(c.owner);this.save()
+   if(full)return {ok:true}
    if(!systemPreferences.isTrustedAccessibilityClient(false))systemPreferences.isTrustedAccessibilityClient(true)
    if(systemPreferences.getMediaAccessStatus('screen')!=='granted'){await desktopCapturer.getSources({types:['screen'],thumbnailSize:{width:1,height:1}}).catch(()=>{});if(systemPreferences.getMediaAccessStatus('screen')!=='granted')await shell.openExternal('x-apple.systempreferences:com.apple.preference.security?Privacy_ScreenCapture')}
    return {ok:true}
   }
+  if(c.operation==='file'||c.operation==='shell'){
+   if(process.platform!=='darwin')throw new Error('此电脑暂不支持文件与命令')
+   if(!this.approvedFull.has(c.owner))throw new Error('请在桌面端授权文件与命令访问')
+   if(c.operation==='shell')return execHostShell(this.home,c.action)
+   const action=c.action??{}
+   if(typeof action.op==='string'&&action.op.startsWith('transfer-')){
+    const key=c.owner+':'+c.resource
+    let files=this.transfers.get(key)
+    if(!files){files=new FileTransferFiles(this.home);this.transfers.set(key,files)}
+    return files.call(action,()=>{if(this.closed||epoch!==this.id||!this.approvedFull.has(c.owner)||Date.now()>c.deadline)throw new Error('文件传输授权已失效')})
+   }
+   if(action.op==='list')return listHostFiles(this.home,action.path)
+   if(action.op==='read')return readHostFile(this.home,action.path)
+   if(action.op==='write')return writeHostFile(this.home,action)
+   if(action.op==='receive')return receiveHostFile(this.home,action)
+   throw new Error('文件操作无效')
+  }
   if(!['local','browser'].includes(c.mode)||!['persistent','temporary'].includes(c.profile)||!['open','view','input','browser','browser-state'].includes(c.operation))throw new Error('桌面命令无效')
   if(c.mode==='browser'){
    if(!/^[a-f0-9]{64}$/.test(c.resource))throw new Error('浏览器资源无效')
@@ -39,7 +68,13 @@ export class DesktopEnvironmentHost {
   const f=this.frames.get(c.resource),d=screen.getPrimaryDisplay();if(!f||f.display!==d.id||JSON.stringify(f.bounds)!==JSON.stringify(d.bounds)||f.width!==c.frame?.width||f.height!==c.frame?.height)throw new Error('显示器已变化,请刷新画面')
   return new Promise((resolve,reject)=>{const child=execFile(join(this.root,app.isPackaged?'computer-helper':'computer-helper-dev'),[],{timeout:10000,maxBuffer:65536},(error,stdout,stderr)=>{if(error)reject(new Error(stderr.trim()||'系统未接受电脑输入'));else{try{resolve(JSON.parse(stdout))}catch{reject(new Error('电脑助手响应无效'))}}});child.stdin.end(JSON.stringify({action:c.action,frame:f}))})
  }
- async cycle(){if(this.closed)return;try{const record=await this.manager.readRecord();if(record){const verified=await this.manager.verify(record);record.url=verified.url;if(this.instance&&this.instance!==record.instanceId){this.results=[];this.id=randomUUID();await this.browser.close()}this.instance=record.instanceId;const sent=this.results.slice(),value=await exchange(record,{host:this.info(),results:sent});this.results.splice(0,sent.length);for(const c of value.commands??[]){if(this.running.has(c.id))continue;this.running.add(c.id);const epoch=this.id;void this.execute(c).then(value=>{if(epoch===this.id)this.results.push({id:c.id,value})},error=>{if(epoch===this.id)this.results.push({id:c.id,error:String(error.message).slice(0,500)})}).finally(()=>this.running.delete(c.id))}}}catch{}finally{if(!this.closed)this.timer=setTimeout(()=>void this.cycle(),400)}}
- start(){this.closed=false;void this.cycle()}
- async close(){this.closed=true;clearTimeout(this.timer);this.id=randomUUID();this.results=[];await this.browser.close()}
+ async close(){this.closed=true;await this.recycle()}
+}
+
+export class DesktopEnvironmentHost {
+ constructor({manager,root,dataRoot}){this.manager=manager;this.core=new DesktopHostCore({root,dataRoot});this.closed=false;this.timer=undefined;this.instance=undefined}
+ revoke(){return this.core.revoke()}
+ async cycle(){if(this.closed)return;try{const record=await this.manager.readRecord();if(record){const verified=await this.manager.verify(record);record.url=verified.url;if(this.instance&&this.instance!==record.instanceId)await this.core.recycle();this.instance=record.instanceId;const value=await exchange(record,{host:this.core.info(),results:this.core.takeResults()});await this.core.handle(value.commands??[])}}catch{}finally{if(!this.closed)this.timer=setTimeout(()=>void this.cycle(),400)}}
+ start(){this.closed=false;this.core.closed=false;void this.cycle()}
+ async close(){this.closed=true;clearTimeout(this.timer);await this.core.close()}
 }

+ 1 - 0
desktop/file-transfer.mjs

@@ -0,0 +1 @@
+export { FileTransferFiles } from '../src/shared/fileTransferEndpoint.mjs'

+ 12 - 0
desktop/host-config.mjs

@@ -0,0 +1,12 @@
+/** desktop-host.json downloaded once from the server's computer settings panel. */
+export function parseDesktopHostConfiguration(value){
+ if(!value||typeof value!=='object'||Array.isArray(value))throw new Error('电脑配置无效')
+ if(value.protocol!==1)throw new Error('电脑配置协议不兼容,请更新夭夭')
+ let web
+ try{web=new URL(value.serverURL)}catch{throw new Error('夭夭服务地址无效')}
+ if(!['http:','https:'].includes(web.protocol)||web.username||web.password||web.search||web.hash||web.pathname!=='/')throw new Error('夭夭服务地址无效')
+ if(web.protocol==='http:'&&!['127.0.0.1','localhost','[::1]'].includes(web.hostname)&&value.allowInsecureLan!==true)throw new Error('远程电脑需要 HTTPS,或使用注册时勾选可信局域网 HTTP 的配置')
+ if(!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(String(value.hostId)))throw new Error('电脑编号无效,请从夭夭重新下载配置')
+ if(typeof value.token!=='string'||value.token.length<32||value.token.length>4096)throw new Error('电脑凭据无效,请从夭夭重新下载配置')
+ return {protocol:1,serverURL:web.origin,hostId:value.hostId,token:value.token,allowInsecureLan:value.allowInsecureLan===true}
+}

+ 115 - 0
desktop/host-files.mjs

@@ -0,0 +1,115 @@
+import {readdir,readFile,writeFile,mkdir,stat,realpath,open,link,rename,unlink} from 'node:fs/promises'
+import {createHash,randomUUID} from 'node:crypto'
+import {join,resolve,sep} from 'node:path'
+import {homedir} from 'node:os'
+import {execFile} from 'node:child_process'
+
+export const FILE_READ_LIMIT=12*1024*1024
+export const FILE_WRITE_LIMIT=10*1024*1024
+export const FILE_LIST_LIMIT=500
+export const SHELL_OUTPUT_LIMIT=512*1024
+export const SHELL_TIMEOUT_MAX=120000
+
+/** Resolve a user-supplied path inside an allowed root, refusing escapes
+ *  through .., absolute outsiders and symlinks pointing out of the root. */
+export async function resolveWithin(root,input,kind='target'){
+  const base=await realpath(root)
+  const raw=String(input??'').replace(/^~\//,'').replace(/^~$/,'')
+  if(/\u0000/.test(raw))throw new Error('路径无效')
+  const target=resolve(base,raw)
+  let real=target
+  try{real=await realpath(target)}catch(error){
+    if(kind==='existing')throw new Error('文件或目录不存在')
+    if(kind==='write'){
+      let directory=join(target,'..')
+      for(;;){
+        try{
+          const parent=await realpath(directory)
+          if(parent!==base&&!parent.startsWith(base+sep))throw new Error('路径超出允许范围')
+          break
+        }catch(failure){
+          if(failure.message==='路径超出允许范围')throw failure
+          const next=join(directory,'..')
+          if(directory===next)throw error
+          directory=next
+        }
+      }
+      return {base,target}
+    }
+  }
+  if(real!==base&&!real.startsWith(base+sep))throw new Error('路径超出允许范围')
+  return {base,target}
+}
+
+export async function listHostFiles(root,input){
+  const {target}=await resolveWithin(root,input,'existing')
+  const info=await stat(target).catch(()=>{throw new Error('文件或目录不存在')})
+  if(!info.isDirectory())throw new Error('不是目录')
+  const entries=await readdir(target,{withFileTypes:true})
+  const limited=entries.slice(0,FILE_LIST_LIMIT)
+  const rows=await Promise.all(limited.map(async entry=>{
+    const full=join(target,entry.name)
+    const details=await stat(full).then(value=>({size:value.size,mtime:Math.round(value.mtimeMs)})).catch(()=>({size:0,mtime:0}))
+    return {name:entry.name,type:entry.isDirectory()?'directory':entry.isSymbolicLink()?'symlink':'file',...details}
+  }))
+  return {path:String(input),entries:rows,truncated:entries.length>FILE_LIST_LIMIT}
+}
+
+export async function readHostFile(root,input){
+  const {target}=await resolveWithin(root,input,'existing')
+  const info=await stat(target).catch(()=>{throw new Error('文件不存在')})
+  if(!info.isFile())throw new Error('不是文件')
+  if(info.size>FILE_READ_LIMIT)throw new Error(`文件超过读取上限(${Math.round(FILE_READ_LIMIT/1024/1024)} MB)`)
+  const bytes=await readFile(target)
+  return {path:String(input),size:bytes.length,data:bytes.toString('base64')}
+}
+
+export async function writeHostFile(root,input){
+  const bytes=Buffer.from(String(input?.data??''),'base64')
+  if(!bytes.length)throw new Error('文件内容为空')
+  if(bytes.length>FILE_WRITE_LIMIT)throw new Error(`内容超过写入上限(${Math.round(FILE_WRITE_LIMIT/1024/1024)} MB)`)
+  if(bytes.toString('base64')!==String(input?.data??''))throw new Error('文件内容必须是 base64')
+  const {target}=await resolveWithin(root,input?.path,'write')
+  await mkdir(join(target,'..'),{recursive:true})
+  await writeFile(target,bytes,{mode:0o600})
+  return {path:String(input?.path),size:bytes.length}
+}
+
+/** Receive a brokered copy: verify bytes, stage beside the destination, then
+ *  commit atomically. An older client rejects the new op instead of clobbering. */
+export async function receiveHostFile(root,input){
+  if(typeof input?.data!=='string'||input.data.length>14*1024*1024)throw new Error('传输文件内容无效或超过 10 MiB')
+  if(typeof input?.overwrite!=='boolean')throw new Error('传输覆盖选项无效')
+  const bytes=Buffer.from(input.data,'base64')
+  if(bytes.length>FILE_WRITE_LIMIT||bytes.toString('base64')!==input.data)throw new Error('传输文件内容无效或超过 10 MiB')
+  const sha256=createHash('sha256').update(bytes).digest('hex')
+  if(input.sha256!==sha256)throw new Error('传输文件校验失败,未写入目标文件')
+  const {target}=await resolveWithin(root,input.path,'write')
+  await mkdir(join(target,'..'),{recursive:true})
+  const temporary=join(target,'..','.yaoyao-transfer-'+randomUUID())
+  const handle=await open(temporary,'wx+',0o600)
+  try{
+    await handle.writeFile(bytes);await handle.sync()
+    const stored=Buffer.alloc(bytes.length);let offset=0
+    while(offset<stored.length){const {bytesRead}=await handle.read(stored,offset,stored.length-offset,offset);if(!bytesRead)break;offset+=bytesRead}
+    if(offset!==bytes.length||createHash('sha256').update(stored).digest('hex')!==sha256)throw new Error('目标文件写入校验失败')
+    await resolveWithin(root,input.path,'write')
+    if(input.overwrite)await rename(temporary,target)
+    else await link(temporary,target).catch(error=>{if(error.code==='EEXIST')throw new Error('目标文件已存在,未覆盖;只有用户要求覆盖时才设置 overwrite=true');throw error})
+    return {path:input.path,size:bytes.length,sha256}
+  }finally{await handle.close();await unlink(temporary).catch(error=>{if(error.code!=='ENOENT')throw error})}
+}
+
+export async function execHostShell(root,input){
+  const command=String(input?.command??'')
+  if(!command.trim())throw new Error('命令为空')
+  const timeout=Math.min(Math.max(Number(input?.timeoutMs)||60000,1000),SHELL_TIMEOUT_MAX)
+  let cwd
+  try{cwd=resolve(String(root),String(input?.cwd??'').replace(/^~\//,'').replace(/^~$/,''))}catch{cwd=String(root)}
+  return new Promise(done=>{
+    execFile('/bin/zsh',['-c',command],{cwd,timeout,killSignal:'SIGKILL',maxBuffer:1024*1024,env:{...process.env,TERM:'dumb'}},(error,stdout,stderr)=>{
+      const clip=value=>Buffer.from(value??'','utf8').subarray(0,SHELL_OUTPUT_LIMIT).toString('utf8')
+      done({command,exitCode:error?typeof error.code==='number'?error.code:1:0,timedOut:error?.killed===true&&error?.signal==='SIGKILL',stdout:clip(stdout),stderr:clip(stderr)})
+    })
+  })
+}

+ 99 - 0
desktop/host-files.test.mjs

@@ -0,0 +1,99 @@
+import {test} from 'node:test'
+import assert from 'node:assert/strict'
+import {mkdtemp,mkdir,writeFile,readFile,readdir,symlink,rm} from 'node:fs/promises'
+import {createHash} from 'node:crypto'
+import {tmpdir} from 'node:os'
+import {join} from 'node:path'
+import {listHostFiles,readHostFile,writeHostFile,receiveHostFile,execHostShell,resolveWithin} from './host-files.mjs'
+
+test('lists, reads and writes files inside the allowed root',async()=>{
+ const root=await mkdtemp(join(tmpdir(),'yaoyao-host-files-'))
+ try{
+  await mkdir(join(root,'docs'))
+  await writeFile(join(root,'docs','note.txt'),'你好,世界','utf8')
+  const listing=await listHostFiles(root,'docs')
+  assert.equal(listing.entries.length,1)
+  assert.deepEqual(listing.entries[0],{name:'note.txt',type:'file',size:Buffer.byteLength('你好,世界'),mtime:listing.entries[0].mtime})
+  const file=await readHostFile(root,'docs/note.txt')
+  assert.equal(Buffer.from(file.data,'base64').toString('utf8'),'你好,世界')
+  const written=await writeHostFile(root,{path:'docs/out/new.bin',data:Buffer.from([1,2,3]).toString('base64')})
+  assert.equal(written.size,3)
+  assert.deepEqual(Buffer.from(await readHostFile(root,'docs/out/new.bin').then(value=>Buffer.from(value.data,'base64'))),Buffer.from([1,2,3]))
+  await assert.rejects(()=>listHostFiles(root,'missing'),/不存在/)
+  await assert.rejects(()=>readHostFile(root,'docs'),/不是文件/)
+  await assert.rejects(()=>writeHostFile(root,{path:'x.txt',data:'not base64!!'}),/base64/)
+ }finally{await rm(root,{recursive:true,force:true})}
+})
+
+test('path escapes are refused for every operation',async()=>{
+ const root=await mkdtemp(join(tmpdir(),'yaoyao-host-files-'))
+ const outside=await mkdtemp(join(tmpdir(),'yaoyao-host-files-out-'))
+ try{
+  await writeFile(join(outside,'secret.txt'),'secret','utf8')
+  await symlink(outside,join(root,'escape'))
+  await writeFile(join(root,'keep.txt'),'keep','utf8')
+  await assert.rejects(()=>resolveWithin(root,'../x'),/超出允许范围/)
+  await assert.rejects(()=>resolveWithin(root,'/etc/passwd'),/超出允许范围/)
+  await assert.rejects(()=>readHostFile(root,'escape/secret.txt'),/超出允许范围/)
+  await assert.rejects(()=>listHostFiles(root,'escape'),/超出允许范围/)
+  await assert.rejects(()=>writeHostFile(root,{path:'escape/evil.txt',data:Buffer.from('x').toString('base64')}),/超出允许范围/)
+  await assert.rejects(()=>readHostFile(root,'keep.txt\u0000'),/路径无效/)
+  assert.equal((await readHostFile(root,'keep.txt')).size,4)
+ }finally{
+  await rm(root,{recursive:true,force:true});await rm(outside,{recursive:true,force:true})
+ }
+})
+
+test('receives verified binary and empty files atomically and preserves existing files unless overwrite was requested',async()=>{
+ const source=await mkdtemp(join(tmpdir(),'yaoyao-copy-source-')),target=await mkdtemp(join(tmpdir(),'yaoyao-copy-target-'))
+ try{
+  await mkdir(join(source,'Desktop'))
+  const bytes=Buffer.alloc(300_000);for(let i=0;i<bytes.length;i++)bytes[i]=i%256
+  await writeFile(join(source,'Desktop','a.bin'),bytes)
+  const file=await readHostFile(source,'Desktop/a.bin'),sha256=createHash('sha256').update(bytes).digest('hex')
+  const input={path:'Desktop/a.bin',data:file.data,sha256,overwrite:false}
+  assert.deepEqual(await receiveHostFile(target,input),{path:input.path,size:bytes.length,sha256})
+  assert.deepEqual(await readFile(join(source,'Desktop','a.bin')),bytes)
+  assert.deepEqual(await readFile(join(target,'Desktop','a.bin')),bytes)
+  await assert.rejects(()=>receiveHostFile(target,{...input,sha256:'wrong'}),/校验失败/)
+  const next=Buffer.from('replacement'),replacement={...input,data:next.toString('base64'),sha256:createHash('sha256').update(next).digest('hex')}
+  await assert.rejects(()=>receiveHostFile(target,replacement),/已存在/)
+  assert.deepEqual(await readFile(join(target,'Desktop','a.bin')),bytes)
+  await receiveHostFile(target,{...replacement,overwrite:true})
+  assert.deepEqual(await readFile(join(target,'Desktop','a.bin')),next)
+  const empty={...input,path:'Desktop/empty',data:'',sha256:createHash('sha256').update('').digest('hex')}
+  assert.equal((await receiveHostFile(target,empty)).size,0)
+  assert.equal((await readFile(join(target,'Desktop','empty'))).length,0)
+  await symlink(source,join(target,'escape'))
+  await assert.rejects(()=>receiveHostFile(target,{...input,path:'escape/evil.bin'}),/超出允许范围/)
+  assert.deepEqual((await readdir(join(target,'Desktop'))).sort(),['a.bin','empty'])
+ }finally{await rm(source,{recursive:true,force:true});await rm(target,{recursive:true,force:true})}
+})
+
+test('shell execution reports stdout, exit codes, timeouts and cwd stays in root',async()=>{
+ const root=await mkdtemp(join(tmpdir(),'yaoyao-host-files-'))
+ try{
+  await mkdir(join(root,'work'))
+  const ok=await execHostShell(root,{command:'pwd',cwd:'work'})
+  assert.equal(ok.exitCode,0)
+  assert.ok(ok.stdout.includes(`${root}/work`),ok.stdout)
+  const failing=await execHostShell(root,{command:'echo boom >&2; exit 7'})
+  assert.equal(failing.exitCode,7);assert.equal(failing.stderr.trim(),'boom')
+  const timed=await execHostShell(root,{command:'sleep 5',timeoutMs:1000})
+  assert.equal(timed.timedOut,true);assert.notEqual(timed.exitCode,0)
+  const escaped=await execHostShell(root,{command:'cd / && pwd'})
+  assert.equal(escaped.exitCode,0)
+  await assert.rejects(()=>execHostShell(root,{command:'  '}),/命令为空/)
+ }finally{await rm(root,{recursive:true,force:true})}
+})
+
+test('tilde home paths resolve inside the allowed root', async () => {
+ const root = await mkdtemp(join(tmpdir(), 'yaoyao-host-files-'))
+ await mkdir(join(root, 'Desktop'), { recursive: true })
+ await writeFile(join(root, 'Desktop', 'a.txt'), 'x')
+ const listing = await listHostFiles(root, '~/Desktop')
+ assert.equal(listing.entries[0].name, 'a.txt')
+ const home = await listHostFiles(root, '~')
+ assert.ok(home.entries.some(e => e.name === 'Desktop'))
+ await assert.rejects(() => listHostFiles(root, '/Desktop'), /超出允许范围|不存在/)
+})

+ 140 - 0
desktop/host-manager.mjs

@@ -0,0 +1,140 @@
+import {readFile,writeFile,rename,mkdir,rm,link} from 'node:fs/promises'
+import {join} from 'node:path'
+import {randomUUID} from 'node:crypto'
+import {request as httpRequest} from 'node:http'
+import {request as httpsRequest} from 'node:https'
+import {parseDesktopHostConfiguration} from './host-config.mjs'
+
+const FATAL = Symbol('desktop-host-fatal')
+
+export function remoteExchange(config,body){return new Promise((resolve,reject)=>{
+ const url=new URL(`/api/desktop-host/v1/${config.hostId}/exchange`,config.serverURL)
+ if(!['http:','https:'].includes(url.protocol))return reject(new Error('夭夭服务地址无效'))
+ const bytes=Buffer.from(JSON.stringify(body)),send=url.protocol==='https'?httpsRequest:httpRequest
+ const req=send(url,{method:'POST',headers:{Authorization:`Bearer ${config.token}`,'x-desktop-host-protocol':'1','content-type':'application/json','content-length':bytes.length}},res=>{
+  let size=0;const chunks=[]
+  res.on('data',chunk=>{size+=chunk.length;if(size>16*1024*1024)res.destroy(new Error('桌面命令超过限制'));else chunks.push(chunk)})
+  res.on('error',reject)
+  res.on('end',()=>{try{
+   if(res.statusCode===401||res.statusCode===403){const error=new Error('电脑授权已失效,请重新登录授权这台电脑');error[FATAL]=true;throw error}
+   if(res.statusCode===409){const error=new Error('电脑连接协议不兼容,请更新夭夭后重新授权');error[FATAL]=true;throw error}
+   if(res.statusCode!==200)throw new Error(`电脑未连接(HTTP ${res.statusCode})`)
+   resolve(JSON.parse(Buffer.concat(chunks).toString()))
+  }catch(error){reject(error)}})
+ })
+ req.on('error',reject)
+ req.setTimeout(10000,()=>req.destroy(new Error('电脑连接超时')))
+ req.end(bytes)
+})}
+
+/** Remote computer: imports an encrypted pairing config and exchanges
+ *  commands with the paired server. Native-only; no browser IPC. */
+export class DesktopHostManager {
+ constructor(options){
+  if(typeof options?.createCore!=='function')throw new Error('电脑需要命令执行核心')
+  this.options=options
+  this.path=join(options.home,'desktop-host.enc')
+  this.createCore=options.createCore
+  this.state='未配置电脑'
+  this.core=undefined
+  this.config=undefined
+  this.timer=undefined
+  this.backoff=400
+  this.chain=Promise.resolve()
+  this.generation=0
+ }
+ publish(message){this.state=message;this.options.onState?.(message)}
+ async installIdentity(){
+  const path=join(this.options.home,'desktop-install-id')
+  const readIdentity=async()=>{
+   const id=(await readFile(path,'utf8')).trim()
+   if(!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id))throw new Error('本机设备标识损坏,请恢复原设备标识后重试')
+   return id
+  }
+  try{return await readIdentity()}catch(error){if(error.code!=='ENOENT')throw error}
+  const id=randomUUID()
+  await mkdir(this.options.home,{recursive:true,mode:0o700})
+  const temporary=`${path}.${id}`
+  try{
+   // Publish a complete identity without overwriting a concurrent login's ID.
+   await writeFile(temporary,id,{flag:'wx',mode:0o600})
+   try{await link(temporary,path);return id}catch(error){if(error.code!=='EEXIST')throw error}
+   return await readIdentity()
+  }finally{await rm(temporary,{force:true})}
+ }
+ serial(work){const result=this.chain.catch(()=>{}).then(work);this.chain=result;return result}
+ async read(){
+  let encrypted
+  try{encrypted=await readFile(this.path)}catch(error){if(error.code==='ENOENT')return;throw error}
+  try{return parseDesktopHostConfiguration(JSON.parse(await this.options.decrypt(encrypted)))}
+  catch{throw new Error('无法解锁电脑配置,请检查钥匙串或重新导入')}
+ }
+ importFile(path){
+  const generation=++this.generation
+  return this.serial(async()=>{
+   let config
+   try{config=parseDesktopHostConfiguration(JSON.parse(await readFile(path,'utf8')))}
+   catch(error){throw error instanceof Error?error:new Error('电脑配置无效,请从夭夭重新下载配置')}
+   await this.store(config,generation)
+  })
+ }
+ /** Adopt a config obtained in-process (e.g. after a native remote login). */
+ adopt(value){
+  const generation=++this.generation
+  return this.serial(async()=>{
+   const config=parseDesktopHostConfiguration(value)
+   await this.store(config,generation)
+  })
+ }
+ async store(config,generation){
+   // Encrypt before stopping a working host: failed Keychain access preserves it.
+   if(generation!==this.generation)return
+   const bytes=await this.options.encrypt(JSON.stringify(config))
+   if(generation!==this.generation)return
+   await this.stopLoop()
+   if(generation!==this.generation)return
+   await mkdir(this.options.home,{recursive:true,mode:0o700})
+   const temporary=`${this.path}.${randomUUID()}`
+   try{await writeFile(temporary,bytes,{flag:'wx',mode:0o600});await rename(temporary,this.path)}
+   finally{await rm(temporary,{force:true})}
+   if(generation!==this.generation)return
+   await this.startLoop(config)
+ }
+ start(){const generation=++this.generation;return this.serial(async()=>{const config=await this.read();if(generation!==this.generation)return;if(config)await this.startLoop(config)})}
+ async startLoop(config){
+  await this.stopLoop()
+  this.config=config
+  this.core=this.createCore({root:this.options.root,dataRoot:this.options.dataRoot})
+  this.backoff=400
+  this.publish(`电脑正在连接 ${new URL(config.serverURL).host}`)
+  this.timer=setTimeout(()=>void this.cycle(),400)
+  this.timer.unref?.()
+ }
+ async cycle(){
+  const config=this.config,core=this.core
+  if(!config||!core||this.core!==core)return
+  try{
+   const value=await remoteExchange(config,{host:core.info(),results:core.takeResults()})
+   this.backoff=400
+   if(this.config!==config||this.core!==core)return
+   this.publish(`电脑已连接 ${new URL(config.serverURL).host}`)
+   await core.handle(value.commands??[])
+  }catch(error){
+   if(this.config!==config||this.core!==core)return
+   if(error&&error[FATAL]){this.publish(error.message);await this.stopLoop();return}
+   this.backoff=Math.min(this.backoff*2,5000)
+   this.publish(`电脑连接中断,正在重试:${String(error.message).slice(0,120)}`)
+  }finally{
+   if(this.core===core){this.timer=setTimeout(()=>void this.cycle(),this.backoff);this.timer.unref?.()}
+  }
+ }
+ async stopLoop(){
+  clearTimeout(this.timer);this.timer=undefined
+  const core=this.core
+  this.core=undefined;this.config=undefined
+  if(core)await core.close().catch(()=>{})
+ }
+ stop(){this.generation++;return this.serial(()=>this.stopLoop())}
+ forget(){this.generation++;return this.serial(async()=>{await this.stopLoop();await rm(this.path,{force:true});this.publish('未配置电脑')})}
+ revoke(){return this.serial(async()=>{await this.core?.revoke()})}
+}

+ 135 - 0
desktop/host-manager.test.mjs

@@ -0,0 +1,135 @@
+import {test} from 'node:test'
+import assert from 'node:assert/strict'
+import {mkdtemp,readFile,writeFile,stat,rm} from 'node:fs/promises'
+import {tmpdir} from 'node:os'
+import {join} from 'node:path'
+import {createServer} from 'node:http'
+import {randomUUID,randomBytes,createCipheriv,createDecipheriv} from 'node:crypto'
+import {DesktopHostManager} from './host-manager.mjs'
+import {parseDesktopHostConfiguration} from './host-config.mjs'
+
+const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms))
+
+test('computer configuration validation mirrors the runner rules',()=>{
+ const base={protocol:1,serverURL:'https://yaoyao.example.com',hostId:randomUUID(),token:randomBytes(32).toString('base64url')}
+ assert.deepEqual(parseDesktopHostConfiguration(base),{...base,allowInsecureLan:false})
+ assert.deepEqual(parseDesktopHostConfiguration({...base,serverURL:'http://127.0.0.1:15300'}).serverURL,'http://127.0.0.1:15300')
+ assert.throws(()=>parseDesktopHostConfiguration({...base,protocol:2}),/协议不兼容/)
+ assert.throws(()=>parseDesktopHostConfiguration({...base,serverURL:'http://192.168.1.4:15300'}),/HTTPS/)
+ assert.equal(parseDesktopHostConfiguration({...base,serverURL:'http://192.168.1.4:15300',allowInsecureLan:true}).allowInsecureLan,true)
+ assert.throws(()=>parseDesktopHostConfiguration({...base,serverURL:'https://example.com/path'}),/服务地址/)
+ assert.throws(()=>parseDesktopHostConfiguration({...base,hostId:'not-a-uuid'}),/电脑编号/)
+ assert.throws(()=>parseDesktopHostConfiguration({...base,token:'short'}),/电脑凭据/)
+})
+
+async function fixture(config){
+ const home=await mkdtemp(join(tmpdir(),'yaoyao-desktop-host-')),key=randomBytes(32)
+ const encrypt=value=>{const iv=randomBytes(12),cipher=createCipheriv('aes-256-gcm',key,iv);const bytes=Buffer.concat([cipher.update(value),cipher.final()]);return Buffer.concat([iv,cipher.getAuthTag(),bytes])}
+ const decrypt=bytes=>{const cipher=createDecipheriv('aes-256-gcm',key,bytes.subarray(0,12));cipher.setAuthTag(bytes.subarray(12,28));return Buffer.concat([cipher.update(bytes.subarray(28)),cipher.final()]).toString()}
+ const cores=[],handled=[]
+ const manager=new DesktopHostManager({home,root:'/app',dataRoot:home,
+  encrypt,decrypt,
+  createCore:()=>{const core={id:randomUUID(),closed:false,results:[],exchanges:0,
+    info(){core.exchanges++;return {id:core.id,name:'测试 Mac',platform:'darwin',screen:true,accessibility:true,approved:[]}},
+    takeResults(){return core.results.splice(0,core.results.length)},
+    async handle(commands){handled.push(...commands??[])},
+    async revoke(){core.id=randomUUID()},
+    async close(){core.closed=true}}
+  cores.push(core);return core}})
+ const configPath=join(home,'desktop-host.json')
+ if(config)await writeFile(configPath,JSON.stringify(config))
+ return {manager,home,configPath,cores,handled}
+}
+
+test('concurrent first logins share one persistent installation identity',async()=>{
+ const {manager,home}=await fixture()
+ try{
+  const managers=Array.from({length:20},()=>new DesktopHostManager(manager.options))
+  const ids=await Promise.all(managers.map(item=>item.installIdentity()))
+  assert.equal(new Set(ids).size,1,'one installation must not register as multiple computers')
+  assert.equal(await readFile(join(home,'desktop-install-id'),'utf8'),ids[0])
+  await manager.forget()
+  assert.equal(await new DesktopHostManager(manager.options).installIdentity(),ids[0])
+  assert.equal((await stat(join(home,'desktop-install-id'))).mode&0o077,0)
+ }finally{await rm(home,{recursive:true,force:true})}
+})
+
+test('a damaged installation identity is not silently replaced by a new computer',async()=>{
+ const {manager,home}=await fixture()
+ try{
+  await writeFile(join(home,'desktop-install-id'),'damaged')
+  await assert.rejects(()=>manager.installIdentity(),/设备标识/)
+  assert.equal(await readFile(join(home,'desktop-install-id'),'utf8'),'damaged')
+ }finally{await rm(home,{recursive:true,force:true})}
+})
+
+test('imports an encrypted config, exchanges with the paired server and stops on revocation',async()=>{
+ const token=randomBytes(32).toString('base64url'),hostId=randomUUID()
+ const exchanges=[]
+ const server=createServer((req,res)=>{
+  if(!req.url.includes(`/api/desktop-host/v1/${hostId}/exchange`)){res.statusCode=404;res.end();return}
+  if(req.headers.authorization!==`Bearer ${token}`||req.headers['x-desktop-host-protocol']!=='1'){res.statusCode=403;res.end(JSON.stringify({error:'unauthorized'}));return}
+  let body='';req.on('data',chunk=>{body+=chunk});req.on('end',()=>{
+   exchanges.push(JSON.parse(body))
+   res.setHeader('content-type','application/json')
+   res.end(JSON.stringify(exchanges.length===1?{commands:[{id:randomUUID(),deadline:Date.now()+30000,mode:'local',owner:'a'.repeat(64),resource:'local',profile:'persistent',operation:'open'}]}:{commands:[]}))
+  })
+ })
+ await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve))
+ const {manager,home,configPath,cores,handled}=await fixture({protocol:1,serverURL:`http://127.0.0.1:${server.address().port}`,hostId,token})
+ try{
+  await manager.importFile(configPath)
+  const mode=await stat(join(home,'desktop-host.enc'))
+  assert.equal(mode.mode&0o077,0)
+  await sleep(1500)
+  assert.ok(cores.length>=1)
+  assert.equal(cores[0].closed,false)
+  assert.equal(exchanges.length>=2,true)
+  assert.equal(exchanges[0].host.name,'测试 Mac')
+  assert.equal(handled.length,1)
+  assert.equal(handled[0].operation,'open')
+  assert.match(manager.state,/已连接/)
+  await manager.forget()
+  assert.equal(cores[0].closed,true)
+  assert.equal(manager.state,'未配置电脑')
+  await assert.rejects(()=>readFile(join(home,'desktop-host.enc')),{code:'ENOENT'})
+ }finally{
+  await manager.stop().catch(()=>{})
+  server.close();server.closeAllConnections?.()
+ }
+})
+
+test('a revoked token stops the loop with a clear state instead of retrying',async()=>{
+ const token=randomBytes(32).toString('base64url')
+ let requests=0
+ const server=createServer((req,res)=>{requests++;res.statusCode=403;res.end(JSON.stringify({error:'revoked'}))})
+ await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve))
+ const {manager,configPath,cores}=await fixture({protocol:1,serverURL:`http://127.0.0.1:${server.address().port}`,hostId:randomUUID(),token})
+ try{
+  await manager.importFile(configPath)
+  await sleep(1200)
+  assert.match(manager.state,/授权已失效/)
+  assert.equal(cores[0].closed,true)
+  const settled=requests
+  await sleep(1200)
+  assert.equal(requests,settled)
+ }finally{
+  await manager.stop().catch(()=>{})
+  server.close();server.closeAllConnections?.()
+ }
+})
+
+test('network failures back off but keep retrying',async()=>{
+ const token=randomBytes(32).toString('base64url')
+ const {manager,home,configPath,cores}=await fixture({protocol:1,serverURL:'http://127.0.0.1:1',hostId:randomUUID(),token})
+ try{
+  await manager.importFile(configPath)
+  await sleep(900)
+  assert.match(manager.state,/正在重试/)
+  assert.equal(cores[0].closed,false)
+  await manager.stop()
+  assert.equal(cores[0].closed,true)
+ }finally{
+  await rm(home,{recursive:true,force:true})
+ }
+})

+ 23 - 0
desktop/host-transfer-transport.test.mjs

@@ -0,0 +1,23 @@
+import {test} from 'node:test'
+import assert from 'node:assert/strict'
+import {createServer} from 'node:http'
+import {randomUUID} from 'node:crypto'
+import {exchangeDesktopEnvironment} from './environment-exchange.mjs'
+import {remoteExchange} from './host-manager.mjs'
+
+for(const kind of ['server','client'])test(`${kind} transport accepts a complete 10 MiB file and still bounds oversized commands`,async()=>{
+ const data=Buffer.alloc(10*1024*1024,255).toString('base64'),hostId=randomUUID(),seen=[]
+ let response={commands:[{id:randomUUID(),operation:'file',action:{op:'receive',path:'Desktop/a.bin',data}}]}
+ const server=createServer(async(req,res)=>{let body='';for await(const chunk of req)body+=chunk;seen.push({path:req.url,headers:req.headers,body:JSON.parse(body)});res.writeHead(200,{'content-type':'application/json'});res.end(JSON.stringify(response))})
+ await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve))
+ const url=`http://127.0.0.1:${server.address().port}`
+ const exchange=()=>kind==='server'?exchangeDesktopEnvironment({url,token:'fixture'},{results:[]}):remoteExchange({serverURL:url,hostId,token:'fixture'},{results:[]})
+ try{
+  const result=await exchange()
+  assert.equal(result.commands[0].action.data,data)
+  assert.equal(seen[0].path,kind==='server'?'/desktop/environment':`/api/desktop-host/v1/${hostId}/exchange`)
+  assert.equal(kind==='server'?seen[0].headers['x-yaoyao-desktop-token']:seen[0].headers.authorization,kind==='server'?'fixture':'Bearer fixture')
+  response={commands:[],padding:'x'.repeat(16*1024*1024)}
+  await assert.rejects(exchange,/超过限制/)
+ }finally{server.closeAllConnections();await new Promise(resolve=>server.close(resolve))}
+})

+ 1 - 1
desktop/lifecycle.test.mjs

@@ -92,7 +92,7 @@ test('real desktop launches its bundled service, survives window close and recov
     assert.equal(updateStatus.installationMode,'desktop');assert.equal(updateStatus.supported,false)
     assert.equal(await desktop.evaluate(({Menu})=>Menu.getApplicationMenu().getMenuItemById('desktop-background').checked),false)
     await desktop.evaluate(async({Menu})=>{const item=Menu.getApplicationMenu().getMenuItemById('desktop-background');await item.click(item)})
-    assert.deepEqual(await until(async()=>JSON.parse(await readFile(join(home,'desktop-preferences.json'),'utf8')),value=>value.backgroundAtLogin===true,5000),{backgroundAtLogin:true})
+    assert.deepEqual(await until(async()=>JSON.parse(await readFile(join(home,'desktop-preferences.json'),'utf8')),value=>value.backgroundAtLogin===true,5000),{backgroundAtLogin:true,startupChoice:'ask',remoteServer:''})
     const external = new DesktopServiceManager({ home, port, fork: () => { throw new Error('must not fork a second service') } })
     assert.equal((await external.start()).external, true)
     await external.stop()

+ 244 - 23
desktop/main.mjs

@@ -1,7 +1,7 @@
-import { app, BrowserWindow, ipcMain, Menu, Tray, nativeImage, shell, utilityProcess, powerMonitor, systemPreferences, dialog, safeStorage, net } from 'electron'
+import { app, BrowserWindow, ipcMain, Menu, Tray, nativeImage, shell, utilityProcess, powerMonitor, systemPreferences, dialog, safeStorage, net, session as electronSession } from 'electron'
 import { appendFileSync, mkdirSync, readFileSync, realpathSync } from 'node:fs'
 import { join, dirname } from 'node:path'
-import { homedir } from 'node:os'
+import { homedir, hostname } from 'node:os'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import { DesktopServiceManager } from './service-manager.mjs'
 import { DesktopRunnerManager } from './runner-manager.mjs'
@@ -9,7 +9,9 @@ import { DesktopPreferences } from './preferences.mjs'
 import { DesktopCredentials } from './credentials.mjs'
 import { synchronizeLocalService, stopLocalService, migrateLocalData } from './service-sync.mjs'
 import { resolveDataHome } from './data-home.mjs'
-import { DesktopEnvironmentHost } from './environment-host.mjs'
+import { DesktopEnvironmentHost, DesktopHostCore } from './environment-host.mjs'
+import { DesktopHostManager } from './host-manager.mjs'
+import { remoteSession, enrollDesktopHost, normalizeServerURL } from './remote-login.mjs'
 import { DesktopUpdateManager } from './update-manager.mjs'
 import { installComputerViewer } from './computer-viewer.mjs'
 
@@ -21,8 +23,14 @@ app.setName('夭夭')
 if (!app.requestSingleInstanceLock()) { app.quit() }
 else {
   let window, tray, manager, runnerManager, quitting = false, closing = false, timer
-  let updateWindow, updater, environmentHost
-  const closeComputerViewer = installComputerViewer({ owner: () => window, origin: () => manager?.state.url,
+  let updateWindow, updater, environmentHost, hostManager, loginWindow
+  let remoteMode = false, remoteURL = '', serverModeActive = false, switchingMode = false
+  const serviceURL = () => remoteMode ? remoteURL : manager?.state.url
+  const serviceOrigins = () => {
+    try { return remoteMode && remoteURL ? [new URL(remoteURL).origin] : manager?.state.url ? [new URL(manager.state.url).origin] : [] }
+    catch { return [] }
+  }
+  const closeComputerViewer = installComputerViewer({ owner: () => window, origin: () => serviceURL(),
     preload: join(desktopRoot, 'preload.cjs'), quitting: () => quitting })
   app.on('will-quit', closeComputerViewer)
   const updateURL = pathToFileURL(join(desktopRoot, 'update.html')).href
@@ -102,7 +110,7 @@ else {
     if (closing || quitting) return
     if (!window || window.isDestroyed()) createWindow()
     window.show(); window.focus()
-    if (manager) void manager.reconnect().then(() => stateChanged(manager.state)).catch(error => log(error.message))
+    if (serverModeActive && manager) void manager.reconnect().then(() => stateChanged(manager.state)).catch(error => log(error.message))
   }
   function safeExternal(url) {
     try { const parsed = new URL(url); if (['https:', 'http:', 'mailto:'].includes(parsed.protocol)) void shell.openExternal(url) }
@@ -115,20 +123,21 @@ else {
         webSecurity: true, preload: join(desktopRoot, 'preload.cjs') } })
     window.webContents.setWindowOpenHandler(({ url }) => {
       try {
-        if (manager?.state.url && new URL(url).origin === manager.state.url) void window.loadURL(url)
+        if (serviceOrigins().includes(new URL(url).origin)) void window.loadURL(url)
         else safeExternal(url)
       } catch { /* Invalid navigation is denied. */ }
       return { action: 'deny' }
     })
     const guardNavigation = (event, url) => {
-      if (url === bootURL || (manager?.state.url && new URL(url).origin === manager.state.url)) return
+      try { if (url === bootURL || serviceOrigins().includes(new URL(url).origin)) return }
+      catch { /* Invalid navigation is denied. */ }
       event.preventDefault(); safeExternal(url)
     }
     window.webContents.on('will-navigate', guardNavigation)
     window.webContents.on('will-redirect', guardNavigation)
     window.webContents.on('will-attach-webview', event => event.preventDefault())
     const trustedService = (contents, url) => {
-      try { return contents === window?.webContents && !!manager?.state.url && new URL(url).origin === manager.state.url }
+      try { return contents === window?.webContents && serviceOrigins().includes(new URL(url).origin) }
       catch { return false }
     }
     window.webContents.session.setPermissionCheckHandler((contents, permission, origin) =>
@@ -143,14 +152,15 @@ else {
     })
     window.on('close', event => { if (!quitting) { event.preventDefault(); window.hide() } })
     window.once('ready-to-show', () => { if (!startHidden) window.show() })
-    if (manager?.state.phase === 'ready') void window.loadURL(manager.state.url)
+    if (remoteMode && remoteURL) void window.loadURL(remoteURL)
+    else if (manager?.state.phase === 'ready') void window.loadURL(manager.state.url)
     else void window.loadFile(join(desktopRoot, 'boot.html'))
   }
   function stateChanged(state) {
     log(`${state.phase}: ${state.message}`)
     // Quit owns the window from this point on. A detached connection is not a
     // stopped server and must never navigate the closing window to boot.html.
-    if (closing || quitting) return
+    if (closing || quitting || remoteMode) return
     const serviceStatus=Menu.getApplicationMenu()?.getMenuItemById('desktop-service-status')
     if(serviceStatus)serviceStatus.label=state.phase==='ready'?'后台服务运行中':state.message
     const localVmMenu=Menu.getApplicationMenu()?.getMenuItemById('desktop-local-vm')
@@ -174,13 +184,14 @@ else {
   function requestQuit(stopBackground = false) {
     if (closing || quitting) return
     closing = true; clearInterval(timer)
-    updater?.cancel(); updateWindow?.close()
+    updater?.cancel(); updateWindow?.close(); loginWindow?.close()
     window?.hide()
     // Native Cmd+Q can enter before-quit from Cocoa's termination callback.
     // Both cleanup and the final quit must run after that callback unwinds.
     setImmediate(() => { void (async()=>{
       try {
         await environmentHost?.close()
+        await hostManager?.stop()
         await runnerManager?.stop()
         if (stopBackground) await manager?.stopBackground()
         else await manager?.stop()
@@ -193,10 +204,13 @@ else {
         if(choice.response===1){quitting=true;setImmediate(()=>app.quit())}
         else {
           closing=false
-          await manager?.reconnect().catch(error=>log(error.message))
-          await runnerManager?.start().catch(error=>log(error.message))
+          if(remoteMode)await hostManager?.start().catch(error=>log(error.message))
+          else{
+            await manager?.reconnect().catch(error=>log(error.message))
+            await runnerManager?.start().catch(error=>log(error.message))
+          }
           stateChanged(manager.state)
-          timer=setInterval(()=>{void manager.check()},10000);timer.unref()
+          timer=setInterval(()=>{if(serverModeActive)void manager.check()},10000);timer.unref()
           show()
         }
       }
@@ -247,6 +261,191 @@ else {
       fork:()=>utilityProcess.fork(join(root,'runner.mjs'),['--desktop-ipc'],{cwd:root,stdio:'pipe',env:{HOME:homedir(),PATH:[join(homedir(),'.local/bin'),join(homedir(),'.orbstack/bin'),'/opt/homebrew/bin','/usr/local/bin',process.env.PATH||'/usr/bin:/bin'].join(':'),NODE_ENV:'production',NODE_USE_ENV_PROXY:'0'}}),
     })
     async function runnerAction(action){try{await action()}catch(error){await dialog.showMessageBox(window,{type:'error',message:'执行节点操作未完成',detail:error.message})}}
+    hostManager=new DesktopHostManager({home,root,dataRoot:app.getPath('userData'),
+      createCore:({root,dataRoot})=>new DesktopHostCore({root,dataRoot}),
+      encrypt:value=>credentials.encrypt(value),
+      decrypt:bytes=>credentials.decrypt(bytes),
+      onState:message=>{log(`电脑: ${message}`);const item=Menu.getApplicationMenu()?.getMenuItemById('desktop-host-status');if(item)item.label=message}})
+    ipcMain.handle('desktop:device-host', async event => {
+      try {
+        const trusted = event.sender === window?.webContents && event.senderFrame === event.sender.mainFrame
+          && serviceOrigins().includes(new URL(event.senderFrame.url).origin)
+        if (!trusted || closing || quitting) throw new Error('不允许此页面读取设备身份')
+      } catch (error) {
+        if (error.message === '不允许此页面读取设备身份') throw error
+        throw new Error('不允许此页面读取设备身份')
+      }
+      if (remoteMode) {
+        const enrolled = await hostManager.read().catch(() => undefined)
+        return { deviceHost: enrolled && new URL(enrolled.serverURL).origin === new URL(remoteURL).origin ? enrolled.hostId : null }
+      }
+      return { deviceHost: 'local' }
+    })
+    async function hostAction(action){try{await action()}catch(error){await dialog.showMessageBox(window,{type:'error',message:'电脑操作未完成',detail:error.message})}}
+    const appDialog = options => window && !window.isDestroyed() ? dialog.showMessageBox(window, options) : dialog.showMessageBox(options)
+    async function authorizeComputer(server,session){
+      const previous=await hostManager.read().catch(()=>undefined)
+      const previousHostId=previous&&new URL(previous.serverURL).origin===new URL(server).origin?previous.hostId:undefined
+      const registration=await enrollDesktopHost(session,{name:hostname(),installId:await hostManager.installIdentity(),previousHostId})
+      await hostManager.adopt({protocol:1,serverURL:server,hostId:registration.host.id,token:registration.token,...(server.startsWith('http://')?{allowInsecureLan:true}:{})})
+      return registration
+    }
+    function requireModePage(event){
+      let trusted=false
+      try{trusted=event.sender===window?.webContents&&event.senderFrame===window.webContents.mainFrame
+        &&serviceOrigins().includes(new URL(event.senderFrame.url).origin)}catch{}
+      if(!trusted||closing||quitting)throw new Error('不允许此页面切换桌面运行模式')
+    }
+    ipcMain.handle('desktop:mode-state',event=>{
+      requireModePage(event)
+      return {mode:remoteMode?'client':'server',serverURL:serviceURL()||'',switching:switchingMode}
+    })
+    ipcMain.handle('desktop:mode-switch',async(event,mode)=>{
+      requireModePage(event)
+      if(mode!=='client'&&mode!=='server')throw new Error('运行模式无效')
+      return switchMode(mode==='client'?'remote':'local',false)
+    })
+    ipcMain.handle('desktop:remote-login',event=>{
+      requireModePage(event)
+      if(switchingMode)throw new Error('正在切换运行模式,请稍候')
+      openRemoteLogin()
+    })
+    ipcMain.handle('desktop:computer-authorize',async(event,csrfToken)=>{
+      requireModePage(event)
+      if(!remoteMode||!remoteURL)return {registered:false}
+      try{
+        const token=String(csrfToken??'').trim()
+        if(!token)throw new Error('登录状态缺少安全令牌,请重新登录')
+        const cookies=await electronSession.defaultSession.cookies.get({url:remoteURL})
+        const registration=await authorizeComputer(remoteURL,{origin:remoteURL,csrfToken:token,cookies:cookies.map(cookie=>[cookie.name,cookie.value])})
+        return {registered:true,hostId:registration.host.id}
+      }catch(error){
+        const message=error instanceof Error?error.message:'电脑授权恢复失败'
+        hostManager.publish(`电脑授权未恢复:${message}`)
+        await appDialog({type:'warning',message:'账号已登录,但电脑授权未恢复',detail:`${message}\n\n请在“电脑”菜单中选择“重新授权…”。`})
+        return {registered:false}
+      }
+    })
+    async function importDesktopHost(){
+      const selection=window&&!window.isDestroyed()
+        ?await dialog.showOpenDialog(window,{title:'导入电脑配置',properties:['openFile'],filters:[{name:'电脑配置',extensions:['json']}]})
+        :await dialog.showOpenDialog({title:'导入电脑配置',properties:['openFile'],filters:[{name:'电脑配置',extensions:['json']}]})
+      if(!selection.canceled&&selection.filePaths[0]&&!closing)await hostAction(()=>hostManager.importFile(selection.filePaths[0]))
+    }
+    function openRemoteLogin(){
+      if(closing||quitting)return
+      if(loginWindow&&!loginWindow.isDestroyed()){loginWindow.show();loginWindow.focus();return}
+      loginWindow=new BrowserWindow({width:420,height:580,minWidth:360,minHeight:440,show:false,title:'登录远程',backgroundColor:'#f7f7f7',
+        webPreferences:{contextIsolation:true,nodeIntegration:false,sandbox:true,webSecurity:true,preload:join(desktopRoot,'remote-login-preload.cjs')}})
+      loginWindow.once('ready-to-show',()=>{if(loginWindow)loginWindow.show()})
+      loginWindow.on('closed',()=>{loginWindow=undefined})
+      const stored=preferences.value.remoteServer
+      void loginWindow.loadFile(join(desktopRoot,'remote-login.html'),stored?{query:{server:stored}}:undefined)
+    }
+    async function enterRemoteMode(){
+      const enrolled=await hostManager.read().catch(error=>{log(error.message);return undefined})
+      let server=''
+      const candidate=preferences.value.remoteServer||enrolled?.serverURL
+      if(candidate){try{server=normalizeServerURL(candidate)}catch(error){log(error.message)}}
+      if(!server){openRemoteLogin();return false}
+      serverModeActive=false
+      await environmentHost?.close().catch(error=>log(error.message))
+      await runnerManager?.stop().catch(error=>log(error.message))
+      await manager?.stop().catch(error=>log(error.message))
+      remoteMode=true;remoteURL=server
+      await preferences.setRemoteServer(server).catch(error=>log(error.message))
+      await preferences.setStartupChoice('remote').catch(error=>log(error.message))
+      if(enrolled&&new URL(enrolled.serverURL).origin===new URL(server).origin)await hostManager.start().catch(error=>{hostManager.publish(error.message)})
+      const status=Menu.getApplicationMenu()?.getMenuItemById('desktop-service-status')
+      if(status)status.label=`已登录远程 · ${new URL(server).host}`
+      tray?.setToolTip(`夭夭 · 远程 ${new URL(server).host}`)
+      syncModeMenu()
+      log(`远程模式:${server}`)
+      if(!fixtureHome){
+        try{
+          const probe=await net.fetch(new URL('/api/app/bootstrap',server),{headers:{accept:'application/json'},redirect:'error'})
+          const info=await probe.json().catch(()=>undefined)
+          if(info?.authenticated!==true)openRemoteLogin()
+        }catch{openRemoteLogin()}
+      }
+      return true
+    }
+    function syncModeMenu(){
+      const menu=Menu.getApplicationMenu()
+      const useRemote=menu?.getMenuItemById('desktop-host-use-remote'),useLocal=menu?.getMenuItemById('desktop-host-use-local'),ask=menu?.getMenuItemById('desktop-host-ask')
+      if(useRemote)useRemote.enabled=!switchingMode&&!remoteMode
+      if(useLocal)useLocal.enabled=!switchingMode&&!serverModeActive
+      const status=menu?.getMenuItemById('desktop-mode-status')
+      if(status)status.label=switchingMode?'正在切换运行模式…':remoteMode?'当前:客户端模式':serverModeActive?'当前:服务器模式':'请选择运行模式'
+      if(ask)ask.checked=preferences.value.startupChoice==='ask'
+    }
+    async function switchMode(mode,notify=true){
+      if(closing||quitting)return {ok:false,error:'App 正在退出'}
+      if(switchingMode)return {ok:false,error:'正在切换运行模式,请稍候'}
+      if(mode==='remote'&&remoteMode||mode==='local'&&serverModeActive)return {ok:true}
+      switchingMode=true;syncModeMenu()
+      try{
+        if(mode==='remote'){
+          if(await enterRemoteMode()){
+            if(window&&!window.isDestroyed())void window.loadURL(remoteURL)
+          }else return {ok:true,pendingLogin:true}
+        }else{
+          loginWindow?.close()
+          serverModeActive=true;remoteMode=false;remoteURL=''
+          await hostManager?.stop().catch(error=>log(error.message))
+          await preferences.setStartupChoice('local').catch(error=>log(error.message))
+          if(window&&!window.isDestroyed())void window.loadFile(join(desktopRoot,'boot.html'))
+          await manager?.start().catch(error=>log(error.message))
+          if(!closing)environmentHost?.start()
+        }
+        return {ok:true}
+      }catch(error){
+        if(notify)await appDialog({type:'error',message:'切换使用方式未完成',detail:error.message})
+        return {ok:false,error:error.message}
+      }finally{switchingMode=false;syncModeMenu()}
+    }
+    ipcMain.handle('desktop-remote-login:submit',async(_event,value)=>{
+      if(closing||quitting)return {ok:false,error:'App 正在退出'}
+      try{
+        const server=normalizeServerURL(value?.serverURL)
+        const auth=await remoteSession(server,{username:value?.username,password:value?.password})
+        let registered=false
+        if(auth.user?.role==='admin'){
+          await authorizeComputer(server,auth)
+          registered=true
+        }
+        try{
+          for(const [name,cookie] of auth.cookies)
+            await electronSession.defaultSession.cookies.set({url:server,name,value:cookie,httpOnly:true,secure:server.startsWith('https://')})
+        }catch(error){log(`远程会话 Cookie 写入失败:${error.message}`)}
+        await preferences.setRemoteServer(server)
+        await enterRemoteMode()
+        if(!window||window.isDestroyed())createWindow()
+        else void window.loadURL(server)
+        loginWindow?.close()
+        if(!registered)await appDialog({type:'info',message:'已登录远程服务器',detail:'当前账号不是管理员:窗口将使用远程夭夭。要把这台 Mac 注册为可远程控制的电脑,请使用管理员账号重新登录。'})
+        return {ok:true,hostRegistered:registered,user:{username:auth.user.username,role:auth.user.role}}
+      }catch(error){return {ok:false,error:error instanceof Error?error.message:'登录失败'}}
+    })
+    ipcMain.handle('desktop-remote-login:use-local',async()=>{
+      loginWindow?.close()
+      if(!serverModeActive){
+        if(!window||window.isDestroyed())createWindow()
+        await switchMode('local')
+      }
+      return {ok:true}
+    })
+    async function chooseStartupMode(){
+      if(fixtureHome)return 'local'
+      const stored=preferences.value.startupChoice
+      if(stored==='local'||stored==='remote')return stored
+      const choice=await dialog.showMessageBox({type:'question',title:'夭夭',message:'这台 Mac 如何使用夭夭?',
+        detail:'「登录远程」用夭夭服务器的地址和账号密码登录另一台电脑上的夭夭:本机不运行 Web 服务,窗口直接使用远程夭夭;管理员账号还会把这台 Mac 注册为可远程控制的电脑。只有「作为服务器运行」会启动这台 Mac 的服务,并使用服务器上的 Hermes。客户端不需要安装 Hermes。',
+        buttons:['连接服务器(客户端)','作为服务器运行'],defaultId:0,cancelId:0,checkboxLabel:'记住选择,之后启动不再询问',checkboxChecked:false,noLink:true})
+      const mode=choice.response===0?'remote':'local'
+      if(choice.checkboxChecked)await preferences.setStartupChoice(mode).catch(error=>log(error.message))
+      return mode
+    }
     async function importRunner(){
       const selection=await dialog.showOpenDialog(window,{title:'导入执行节点配置',properties:['openFile'],filters:[{name:'Runner 配置',extensions:['json']}]})
       if(!selection.canceled&&selection.filePaths[0]&&!closing)await runnerAction(()=>runnerManager.importFile(selection.filePaths[0]))
@@ -254,7 +453,7 @@ else {
     Menu.setApplicationMenu(Menu.buildFromTemplate([
       { label: '夭夭', submenu: [{ role: 'about', label: '关于夭夭' }, { type: 'separator' },
         { id:'desktop-service-status',label:'正在连接后台服务…',enabled:false },
-        { label: '显示窗口', click: show }, { label: '在浏览器中打开', click: () => { if (manager.state.url) safeExternal(manager.state.url) } },
+        { label: '显示窗口', click: show }, { label: '在浏览器中打开', click: () => { const url = serviceURL(); if (url) safeExternal(url) } },
         { id:'desktop-local-vm',label:'本地虚拟机设置…',enabled:false,click:()=>{if(manager.state.phase==='ready'){show();void window.webContents.executeJavaScript("window.dispatchEvent(new CustomEvent('yaoyao:local-vm-settings'))")}} },
         { label: '查看服务日志', click: () => shell.showItemInFolder(logFile) },
         { id:'desktop-sync-notice', label:'Web 同步待完成:服务忙碌', enabled:false, visible:false },
@@ -271,13 +470,24 @@ else {
         { type: 'separator' },
         { role: 'hide', label: '隐藏夭夭' }, { role: 'hideOthers', label: '隐藏其他' }, { role: 'unhide', label: '显示全部' },
         { type: 'separator' },
-        {label:'撤销本机控制授权',click:()=>environmentHost.revoke()},
+        {label:'撤销本机控制授权',click:()=>{void environmentHost.revoke();void hostManager?.revoke()}},
         { id:'desktop-quit',label:'退出夭夭(后台继续运行)',accelerator:'CommandOrControl+Q',click:()=>requestQuit() },
         { id:'desktop-stop-and-quit',label:'停止后台服务并退出',click:()=>requestQuit(true) }] },
       {label:'执行节点',submenu:[{id:'runner-status',label:'未配置执行节点',enabled:false},{type:'separator'},
         {id:'runner-import',label:'导入节点配置…',click:importRunner},
         {id:'runner-reconnect',label:'重新连接',click:()=>runnerAction(()=>runnerManager.start())},
         {id:'runner-forget',label:'断开并忘记配置',click:()=>runnerAction(()=>runnerManager.forget())}]},
+      {label:'运行模式',submenu:[{id:'desktop-mode-status',label:'请选择运行模式',enabled:false},{type:'separator'},
+        {id:'desktop-host-use-remote',label:'客户端模式(连接服务器)',enabled:!remoteMode,click:()=>void switchMode('remote')},
+        {id:'desktop-host-use-local',label:'服务器模式(本机运行)',enabled:!serverModeActive,click:()=>void switchMode('local')},
+        {label:'更换服务器…',click:openRemoteLogin},{type:'separator'},
+        {id:'desktop-host-ask',label:'启动时询问运行模式',type:'checkbox',checked:preferences.value.startupChoice==='ask',
+          click:item=>{void preferences.setStartupChoice(item.checked?'ask':remoteMode?'remote':'local').catch(async error=>{item.checked=preferences.value.startupChoice==='ask';await appDialog({type:'error',message:'无法保存启动偏好',detail:error.message})})}}]},
+      {label:'电脑',submenu:[{id:'desktop-host-status',label:'未配置电脑',enabled:false},{type:'separator'},
+        {id:'desktop-host-authorize',label:'重新授权…',click:openRemoteLogin},
+        {id:'desktop-host-import',label:'导入电脑配置…',click:importDesktopHost},
+        {id:'desktop-host-reconnect',label:'重新连接',click:()=>hostAction(()=>hostManager.start())},
+        {id:'desktop-host-forget',label:'断开并忘记配置',click:()=>hostAction(()=>hostManager.forget())}]},
       { role: 'editMenu', label: '编辑' }, { role: 'viewMenu', label: '显示' }, { role: 'windowMenu', label: '窗口' },
     ]))
     const icon = nativeImage.createFromPath(join(desktopRoot, 'icon.png')).resize({ width: 20, height: 20 })
@@ -286,11 +496,22 @@ else {
     tray.setToolTip('夭夭')
     tray.setContextMenu(Menu.buildFromTemplate([{ label: '打开夭夭', click: show }, { label: '查看日志', click: () => shell.showItemInFolder(logFile) }, { type: 'separator' }, { label: '退出夭夭(后台继续运行)', click: () => requestQuit() }, { label: '停止后台服务并退出', click: () => requestQuit(true) }]))
     tray.on('click', show)
-    createWindow()
-    powerMonitor.on('resume', () => { if(!closing&&!quitting)void manager.check() })
-    timer = setInterval(() => { void manager.check() }, 10_000); timer.unref()
-    await manager.start().catch(error => log(error.message))
-    if(!closing)environmentHost.start()
-    if(!closing&&manager.state.phase==='ready')await runnerManager.start().catch(error=>{runnerManager.publish(error.message)})
+    let startupRemote=false,startupLogin=false
+    serverModeActive=(await chooseStartupMode())==='local'
+    if(!serverModeActive){
+      const enrolled=await hostManager.read().catch(()=>undefined)
+      if(preferences.value.remoteServer||enrolled)startupRemote=await enterRemoteMode()
+      startupLogin=!startupRemote
+    }
+    if(!startupLogin)createWindow()
+    powerMonitor.on('resume', () => { if(!closing&&!quitting&&serverModeActive)void manager.check() })
+    timer = setInterval(() => { if(serverModeActive)void manager.check() }, 10_000); timer.unref()
+    if(startupLogin)openRemoteLogin()
+    else if(serverModeActive){
+      syncModeMenu()
+      await manager.start().catch(error => log(error.message))
+      if(!closing)environmentHost.start()
+    }
+    if(!startupLogin&&!startupRemote&&manager.state.phase==='ready')await runnerManager.start().catch(error=>{runnerManager.publish(error.message)})
   }).catch(error => { log(error.stack || error.message); quitting = true; app.quit() })
 }

+ 76 - 0
desktop/mode-switch.test.mjs

@@ -0,0 +1,76 @@
+import {test} from 'node:test'
+import assert from 'node:assert/strict'
+import {mkdtemp,readFile,writeFile,realpath,rm} from 'node:fs/promises'
+import {tmpdir} from 'node:os'
+import {join,resolve} from 'node:path'
+import {createServer} from 'node:http'
+import {_electron as electron,expect} from '@playwright/test'
+import {dataKey} from './service-manager.mjs'
+
+test('signed-in desktop pages can switch both ways; other windows cannot control the runtime',{timeout:60000},async()=>{
+  const root=resolve(import.meta.dirname,'..'),home=await realpath(await mkdtemp(join(tmpdir(),'yaoyao-mode-switch-')))
+  const version=JSON.parse(await readFile(join(root,'.desktop-build/release.json'),'utf8')).webVersion
+  const identity={protocol:1,instanceId:'mode-switch',pid:process.pid,dataKey:dataKey(home),version}
+  let releaseIdentity
+  const identityReady=new Promise(resolve=>{releaseIdentity=resolve})
+  const local=createServer(async(req,res)=>{
+    if(req.url==='/desktop/service'){await identityReady;res.setHeader('Content-Type','application/json');res.end(JSON.stringify(identity))}
+    else {res.setHeader('Content-Type','text/html; charset=utf-8');res.end('<title>已登录的本机页面</title>')}
+  })
+  const remote=createServer((_req,res)=>{res.setHeader('Content-Type','text/html; charset=utf-8');res.end('<title>已登录的服务器页面</title>')})
+  await new Promise(done=>local.listen(0,'127.0.0.1',done))
+  await new Promise(done=>remote.listen(0,'127.0.0.1',done))
+  const origin=`http://127.0.0.1:${local.address().port}`,remoteURL=`http://127.0.0.1:${remote.address().port}`
+  await writeFile(join(home,'service-instance.json'),JSON.stringify({...identity,url:origin,token:'fixture'}))
+  await writeFile(join(home,'desktop-preferences.json'),JSON.stringify({startupChoice:'local',remoteServer:remoteURL,backgroundAtLogin:false}))
+  let app
+  try{
+    app=await electron.launch({args:[root],cwd:root,env:{...process.env,HERMES_YAOYAO_DESKTOP_TEST_HOME:home,HERMES_YAOYAO_DESKTOP_PORT:String(local.address().port),HERMES_YAOYAO_DESKTOP_TEST_SYNC:'0'}})
+    const page=await app.firstWindow();releaseIdentity();await page.waitForURL(origin+'/**')
+    assert.deepEqual(await page.evaluate(()=>window.yaoyaoDesktop.modeState()),{mode:'server',serverURL:origin,switching:false})
+    assert.deepEqual(await page.evaluate(()=>window.yaoyaoDesktop.authorizeComputer('csrf-test')),{registered:false})
+    assert.equal(await page.evaluate(()=>window.yaoyaoDesktop.switchMode('invalid').then(()=>false,()=>true)),true)
+    await page.evaluate(()=>{void window.yaoyaoDesktop.switchMode('client')})
+    await page.waitForURL(remoteURL+'/**')
+    assert.deepEqual(await page.evaluate(()=>window.yaoyaoDesktop.modeState()),{mode:'client',serverURL:remoteURL,switching:false})
+    await expect.poll(async()=>JSON.parse(await readFile(join(home,'desktop-preferences.json'),'utf8')).startupChoice).toBe('remote')
+    // Unchecking "ask at startup" must retain the active client role.
+    await app.evaluate(({Menu})=>{const item=Menu.getApplicationMenu().getMenuItemById('desktop-host-ask');item.click(item)})
+    await expect.poll(async()=>JSON.parse(await readFile(join(home,'desktop-preferences.json'),'utf8')).startupChoice).toBe('ask')
+    await app.evaluate(({Menu})=>{const item=Menu.getApplicationMenu().getMenuItemById('desktop-host-ask');item.click(item)})
+    await expect.poll(async()=>JSON.parse(await readFile(join(home,'desktop-preferences.json'),'utf8')).startupChoice).toBe('remote')
+    const denied=await app.evaluate(async({BrowserWindow},{origin,preload})=>{
+      const outsider=new BrowserWindow({show:false,webPreferences:{sandbox:true,contextIsolation:true,preload}})
+      try{
+        await outsider.loadURL(origin)
+        return await outsider.webContents.executeJavaScript('Promise.all([window.yaoyaoDesktop.modeState(),window.yaoyaoDesktop.switchMode("server"),window.yaoyaoDesktop.openRemoteLogin(),window.yaoyaoDesktop.authorizeComputer("csrf-test")].map(p=>p.then(()=>false,()=>true)))')
+      }finally{outsider.destroy()}
+    },{origin:remoteURL,preload:join(root,'desktop/preload.cjs')})
+    assert.deepEqual(denied,[true,true,true,true])
+    await page.evaluate(()=>{void window.yaoyaoDesktop.switchMode('server')})
+    await page.waitForURL(origin+'/**')
+    await expect.poll(()=>page.evaluate(()=>window.yaoyaoDesktop.modeState())).toEqual({mode:'server',serverURL:origin,switching:false})
+    assert.equal(JSON.parse(await readFile(join(home,'desktop-preferences.json'),'utf8')).startupChoice,'local')
+    assert.equal(local.listening,true,'switching must leave an independent service running')
+    assert.equal(remote.listening,true)
+    // The server picker remains available after either login/mode selection.
+    const opened=app.waitForEvent('window');await page.evaluate(()=>window.yaoyaoDesktop.openRemoteLogin())
+    const login=await opened;await login.waitForLoadState()
+    assert.equal(app.windows().length,2)
+    await page.evaluate(()=>window.yaoyaoDesktop.openRemoteLogin())
+    assert.equal(app.windows().length,2)
+    await login.evaluate(()=>{void window.yaoyaoRemoteLogin.useLocal()})
+    await expect.poll(()=>app.windows().length).toBe(1)
+    await page.evaluate(()=>{void window.yaoyaoDesktop.switchMode('client')})
+    await page.waitForURL(remoteURL+'/**')
+    const pickerOpened=app.waitForEvent('window');await page.evaluate(()=>window.yaoyaoDesktop.openRemoteLogin())
+    const picker=await pickerOpened;await picker.waitForLoadState()
+    await picker.evaluate(()=>{void window.yaoyaoRemoteLogin.useLocal()})
+    await page.waitForURL(origin+'/**')
+    await expect.poll(()=>page.evaluate(()=>window.yaoyaoDesktop.modeState())).toEqual({mode:'server',serverURL:origin,switching:false})
+  }finally{
+    releaseIdentity();await app?.close().catch(()=>{})
+    await Promise.all([local,remote].map(server=>new Promise(done=>{server.close(done);server.closeAllConnections()})))
+    await rm(home,{recursive:true,force:true})
+  }
+})

+ 7 - 4
desktop/preferences.mjs

@@ -3,11 +3,14 @@ import {join} from 'node:path'
 import {randomUUID} from 'node:crypto'
 import {homedir} from 'node:os'
 export class DesktopPreferences {
-  constructor(home){this.home=home;this.path=join(home,'desktop-preferences.json');this.value={backgroundAtLogin:false}}
-  async load(){try{let source;try{source=await readFile(this.path,'utf8')}catch(error){if(error.code!=='ENOENT'||this.home!==join(homedir(),'.yaoyao'))throw error;source=await readFile(join(homedir(),'.hermes-yaoyao','desktop-preferences.json'),'utf8')}const value=JSON.parse(source);this.value={backgroundAtLogin:value.backgroundAtLogin===true}}catch(error){if(error.code!=='ENOENT')throw new Error('无法读取桌面偏好设置')}return this.value}
-  async setBackgroundAtLogin(enabled){
-    const value={backgroundAtLogin:enabled===true},temporary=this.path+'.'+randomUUID()
+  constructor(home){this.home=home;this.path=join(home,'desktop-preferences.json');this.value={backgroundAtLogin:false,startupChoice:'ask',remoteServer:''}}
+  async load(){try{let source;try{source=await readFile(this.path,'utf8')}catch(error){if(error.code!=='ENOENT'||this.home!==join(homedir(),'.yaoyao'))throw error;source=await readFile(join(homedir(),'.hermes-yaoyao','desktop-preferences.json'),'utf8')}const value=JSON.parse(source);this.value={backgroundAtLogin:value.backgroundAtLogin===true,startupChoice:['ask','local','remote'].includes(value.startupChoice)?value.startupChoice:'ask',remoteServer:typeof value.remoteServer==='string'?value.remoteServer.slice(0,200):''}}catch(error){if(error.code!=='ENOENT')throw new Error('无法读取桌面偏好设置')}return this.value}
+  async write(value){
+    const temporary=this.path+'.'+randomUUID()
     await mkdir(this.home,{recursive:true,mode:0o700})
     try{await writeFile(temporary,JSON.stringify(value),{flag:'wx',mode:0o600});await rename(temporary,this.path);this.value=value}finally{await rm(temporary,{force:true})}
   }
+  async setBackgroundAtLogin(enabled){await this.write({...this.value,backgroundAtLogin:enabled===true})}
+  async setStartupChoice(choice){await this.write({...this.value,startupChoice:['ask','local','remote'].includes(choice)?choice:'ask'})}
+  async setRemoteServer(url){await this.write({...this.value,remoteServer:typeof url==='string'?url.slice(0,200):''})}
 }

+ 24 - 3
desktop/preferences.test.mjs

@@ -8,11 +8,32 @@ test('background login remains opt-in and persists without changing system login
   const home=await mkdtemp(join(tmpdir(),'yaoyao-desktop-preferences-'))
   try{
     const preferences=new DesktopPreferences(home)
-    assert.deepEqual(await preferences.load(),{backgroundAtLogin:false})
+    assert.deepEqual(await preferences.load(),{backgroundAtLogin:false,startupChoice:'ask',remoteServer:''})
     await preferences.setBackgroundAtLogin(true)
-    assert.deepEqual(await new DesktopPreferences(home).load(),{backgroundAtLogin:true})
+    assert.deepEqual(await new DesktopPreferences(home).load(),{backgroundAtLogin:true,startupChoice:'ask',remoteServer:''})
     assert.equal((await stat(preferences.path)).mode&0o777,0o600)
     await preferences.setBackgroundAtLogin(false)
-    assert.deepEqual(await new DesktopPreferences(home).load(),{backgroundAtLogin:false})
+    assert.deepEqual(await new DesktopPreferences(home).load(),{backgroundAtLogin:false,startupChoice:'ask',remoteServer:''})
+  }finally{await rm(home,{recursive:true,force:true})}
+})
+test('startup choice persists independently of background login',async()=>{
+  const home=await mkdtemp(join(tmpdir(),'yaoyao-desktop-preferences-'))
+  try{
+    const preferences=new DesktopPreferences(home)
+    await preferences.load()
+    await preferences.setStartupChoice('remote')
+    assert.deepEqual(await new DesktopPreferences(home).load(),{backgroundAtLogin:false,startupChoice:'remote',remoteServer:''})
+    await preferences.setBackgroundAtLogin(true)
+    assert.deepEqual(await new DesktopPreferences(home).load(),{backgroundAtLogin:true,startupChoice:'remote',remoteServer:''})
+    await preferences.setStartupChoice('local')
+    assert.deepEqual(await new DesktopPreferences(home).load(),{backgroundAtLogin:true,startupChoice:'local',remoteServer:''})
+    await preferences.setStartupChoice('ask')
+    assert.deepEqual(await new DesktopPreferences(home).load(),{backgroundAtLogin:true,startupChoice:'ask',remoteServer:''})
+    await preferences.setStartupChoice('nonsense')
+    assert.equal((await new DesktopPreferences(home).load()).startupChoice,'ask')
+    await preferences.setRemoteServer('http://192.168.1.10:15300')
+    assert.deepEqual(await new DesktopPreferences(home).load(),{backgroundAtLogin:true,startupChoice:'ask',remoteServer:'http://192.168.1.10:15300'})
+    await preferences.setRemoteServer(undefined)
+    assert.equal((await new DesktopPreferences(home).load()).remoteServer,'')
   }finally{await rm(home,{recursive:true,force:true})}
 })

+ 8 - 1
desktop/preload.cjs

@@ -5,7 +5,14 @@ contextBridge.exposeInMainWorld('yaoyaoDesktop', Object.freeze({
   forceSync: () => ipcRenderer.invoke('desktop:force-sync'),
   logs: () => ipcRenderer.invoke('desktop:logs'),
   openUpdates: () => ipcRenderer.invoke('desktop:updates'),
-  openComputer: id => ipcRenderer.invoke('desktop-computer:open', id),
+  modeState: () => ipcRenderer.invoke('desktop:mode-state'),
+  switchMode: mode => ipcRenderer.invoke('desktop:mode-switch', mode),
+  openRemoteLogin: () => ipcRenderer.invoke('desktop:remote-login'),
+  authorizeComputer: csrfToken => ipcRenderer.invoke('desktop:computer-authorize', csrfToken),
+  /** 'local' on the YaoYao server Mac; paired host uuid in remote mode; null if unknown. */
+  deviceHost: () => ipcRenderer.invoke('desktop:device-host'),
+  openComputer: (id, target) => ipcRenderer.invoke('desktop-computer:open', id, target),
+  computerTargetChanged: target => ipcRenderer.invoke('desktop-computer:target', target),
   computerClosed: () => ipcRenderer.invoke('desktop-computer:closed'),
   onComputerClose: callback => {
     const listener = () => callback()

+ 5 - 0
desktop/remote-login-preload.cjs

@@ -0,0 +1,5 @@
+const { contextBridge, ipcRenderer } = require('electron')
+contextBridge.exposeInMainWorld('yaoyaoRemoteLogin', Object.freeze({
+  submit: value => ipcRenderer.invoke('desktop-remote-login:submit', value),
+  useLocal: () => ipcRenderer.invoke('desktop-remote-login:use-local'),
+}))

+ 21 - 0
desktop/remote-login.css

@@ -0,0 +1,21 @@
+:root { color-scheme: light dark; }
+* { box-sizing: border-box; }
+body { margin: 0; min-height: 100vh; display: grid; place-items: center; padding: 28px;
+  font: 14px/1.6 -apple-system, "PingFang SC", "Helvetica Neue", sans-serif;
+  background: #f7f7f7; color: #1d2129; }
+@media (prefers-color-scheme: dark) { body { background: #14181e; color: #dce1e7; } }
+main { width: min(360px, 100%); display: grid; gap: 22px; }
+header { display: grid; justify-items: center; text-align: center; gap: 10px; }
+h1 { margin: 0; font-size: 19px; }
+header p { margin: 0; font-size: 12.5px; opacity: .75; }
+form { display: grid; gap: 14px; padding: 20px; border: 1px solid rgba(128,128,138,.35); border-radius: 14px; background: rgba(127,127,127,.06); }
+label { display: grid; gap: 6px; font-size: 13px; }
+input { font: inherit; padding: 9px 11px; border: 1px solid rgba(128,128,138,.5); border-radius: 8px; background: transparent; color: inherit; min-width: 0; }
+input:focus-visible, button:focus-visible { outline: 2px solid #3b82f6; outline-offset: 1px; }
+button { font: inherit; min-height: 38px; padding: 8px 14px; border: 1px solid rgba(128,128,138,.5); border-radius: 8px; background: transparent; color: inherit; cursor: pointer; }
+button.primary { background: #2f6fed; border-color: #2f6fed; color: #fff; }
+button.primary:disabled { opacity: .55; cursor: default; }
+footer { display: grid; justify-items: center; }
+footer button { border: 0; font-size: 12.5px; opacity: .8; }
+#error { margin: 0; font-size: 12.5px; color: #d5443c; }
+#status { margin: 0; font-size: 12.5px; opacity: .75; }

+ 17 - 0
desktop/remote-login.html

@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'self'; style-src 'self'; img-src 'self'">
+<title>登录远程 · 夭夭</title><link rel="stylesheet" href="remote-login.css"></head>
+<body><main>
+  <header><img src="icon.png" alt="" width="56" height="56"><h1>登录远程夭夭</h1>
+    <p>连接另一台电脑上的夭夭服务器。登录后本机无需 Hermes,也不运行 Web 服务,窗口直接使用远程夭夭;管理员账号同时会把这台 Mac 注册为可远程控制的电脑。</p></header>
+  <form id="login-form" aria-label="远程登录">
+    <label>服务器地址<input id="server" name="server" required autocomplete="off" spellcheck="false" placeholder="192.168.1.10:15300" inputmode="url"></label>
+    <label>用户名<input id="username" name="username" required autocomplete="username" autocapitalize="none" spellcheck="false"></label>
+    <label>密码<input id="password" name="password" type="password" required autocomplete="current-password"></label>
+    <button type="submit" id="submit" class="primary">登录</button>
+    <p id="error" role="alert" hidden></p>
+    <p id="status" role="status" aria-live="polite" hidden></p>
+  </form>
+  <footer><button type="button" id="use-local">改为作为服务器运行</button></footer>
+</main><script src="remote-login.js"></script></body></html>

+ 23 - 0
desktop/remote-login.js

@@ -0,0 +1,23 @@
+const byId = id => document.getElementById(id)
+const form = byId('login-form')
+const preset = new URLSearchParams(location.search).get('server')
+if (preset) byId('server').value = preset
+form.addEventListener('submit', async event => {
+  event.preventDefault()
+  const error = byId('error'), status = byId('status'), submit = byId('submit')
+  error.hidden = true; status.hidden = false; status.textContent = '正在登录…'; submit.disabled = true
+  try {
+    const result = await window.yaoyaoRemoteLogin.submit({
+      serverURL: byId('server').value,
+      username: byId('username').value,
+      password: byId('password').value,
+    })
+    if (!result.ok) throw new Error(result.error || '登录失败')
+    status.textContent = result.hostRegistered ? '登录成功,已注册本机为电脑…' : '登录成功…'
+  } catch (cause) {
+    status.hidden = true; error.hidden = false
+    error.textContent = cause instanceof Error ? cause.message : '登录失败'
+    submit.disabled = false
+  }
+})
+byId('use-local').addEventListener('click', () => { void window.yaoyaoRemoteLogin.useLocal() })

+ 62 - 0
desktop/remote-login.mjs

@@ -0,0 +1,62 @@
+/** Native remote login: username/password against a yaoyao Web server.
+ *  Mirrors the browser's CSRF/Origin dance so no server changes are needed,
+ *  and can enroll this Mac as a computer with the logged-in session. */
+
+export function normalizeServerURL(input){
+  const raw=String(input??'').trim()
+  if(!raw)throw new Error('请填写夭夭服务器地址')
+  const withScheme=/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(raw)?raw:`http://${raw}`
+  let url
+  try{url=new URL(withScheme)}catch{throw new Error('服务器地址无效')}
+  if(!['http:','https:'].includes(url.protocol)||url.username||url.password||url.search||url.hash||(url.pathname!==''&&url.pathname!=='/'))throw new Error('服务器地址无效')
+  return url.origin
+}
+
+/** Minimal cookie jar across the bootstrap → login dance. */
+class CookieJar{
+  constructor(){this.cookies=new Map()}
+  absorb(response){
+    for(const line of response.headers.getSetCookie?.()??[]){
+      const pair=line.split(';')[0],eq=pair.indexOf('=')
+      if(eq>0)this.cookies.set(pair.slice(0,eq).trim(),pair.slice(eq+1).trim())
+    }
+  }
+  header(){return [...this.cookies.entries()].map(([name,value])=>`${name}=${value}`).join('; ')}
+}
+
+export async function remoteSession(serverURL,{username,password},fetchImpl=globalThis.fetch){
+  const base=normalizeServerURL(serverURL)
+  const user=String(username??'').trim(),pass=String(password??'')
+  if(!user||!pass)throw new Error('请填写用户名和密码')
+  const jar=new CookieJar()
+  const bootstrap=await fetchImpl(new URL('/api/app/bootstrap',base),{headers:{accept:'application/json'},redirect:'error'})
+  jar.absorb(bootstrap)
+  if(!bootstrap.ok)throw new Error(`无法连接服务器(HTTP ${bootstrap.status})`)
+  const info=await bootstrap.json().catch(()=>{throw new Error('服务器响应无效,请确认这是夭夭 Web 地址')})
+  if(typeof info?.csrfToken!=='string')throw new Error('服务器响应无效,请确认这是夭夭 Web 地址')
+  const response=await fetchImpl(new URL('/api/app/login',base),{
+    method:'POST',redirect:'error',
+    headers:{accept:'application/json','content-type':'application/json',cookie:jar.header(),'x-csrf-token':info.csrfToken,origin:base},
+    body:JSON.stringify({username:user,password:pass}),
+  })
+  jar.absorb(response)
+  if(response.status===401||response.status===403)throw new Error('用户名或密码不正确')
+  if(!response.ok)throw new Error(`登录失败(HTTP ${response.status})`)
+  const result=await response.json().catch(()=>{throw new Error('登录响应无效')})
+  if(!result?.user?.id)throw new Error('登录响应无效')
+  return {origin:base,user:result.user,csrfToken:String(result.csrfToken??info.csrfToken),cookies:[...jar.cookies.entries()]}
+}
+
+export async function enrollDesktopHost(session,{name,installId,previousHostId},fetchImpl=globalThis.fetch){
+  const cookie=session.cookies.map(([key,value])=>`${key}=${value}`).join('; ')
+  const response=await fetchImpl(new URL('/api/app/admin/desktop-hosts',session.origin),{
+    method:'POST',redirect:'error',
+    headers:{accept:'application/json','content-type':'application/json',cookie,'x-csrf-token':session.csrfToken,origin:session.origin},
+    body:JSON.stringify({name:String(name).slice(0,100),...(installId?{installId}:{}),...(previousHostId?{previousHostId}:{})}),
+  })
+  if(response.status===403)throw new Error('需要管理员账号,才能把这台 Mac 注册为可远程控制的电脑')
+  if(!response.ok)throw new Error(`注册电脑失败(HTTP ${response.status})`)
+  const result=await response.json()
+  if(typeof result?.token!=='string'||!result?.host?.id)throw new Error('注册电脑响应无效')
+  return result
+}

+ 77 - 0
desktop/remote-login.test.mjs

@@ -0,0 +1,77 @@
+import {test} from 'node:test'
+import assert from 'node:assert/strict'
+import {createServer} from 'node:http'
+import {randomUUID,randomBytes} from 'node:crypto'
+import {remoteSession,enrollDesktopHost,normalizeServerURL} from './remote-login.mjs'
+
+test('server addresses are normalized like browser URLs',()=>{
+  assert.equal(normalizeServerURL('192.168.1.10:15300'),'http://192.168.1.10:15300')
+  assert.equal(normalizeServerURL('http://192.168.1.10:15300/'),'http://192.168.1.10:15300')
+  assert.equal(normalizeServerURL('https://yaoyao.example.com'),'https://yaoyao.example.com')
+  assert.throws(()=>normalizeServerURL(''),/服务器地址/)
+  assert.throws(()=>normalizeServerURL('https://user:pass@example.com'),/无效/)
+  assert.throws(()=>normalizeServerURL('http://example.com/path'),/无效/)
+  assert.throws(()=>normalizeServerURL('ftp://example.com'),/无效/)
+})
+
+async function fakeServer(){
+  const csrf=randomUUID(),session=randomBytes(24).toString('base64url'),token=randomBytes(32).toString('base64url'),hostId=randomUUID()
+  const requests=[]
+  const server=createServer((req,res)=>{
+    const chunks=[];req.on('data',chunk=>chunks.push(chunk));req.on('end',()=>{
+      const body=Buffer.concat(chunks).toString()
+      requests.push({method:req.method,url:req.url,origin:req.headers.origin,csrf:req.headers['x-csrf-token'],cookie:req.headers.cookie??'',body})
+      const json=payload=>{res.setHeader('content-type','application/json');res.end(JSON.stringify(payload))}
+      if(req.url==='/api/app/bootstrap'&&(req.method==='GET'||req.method==='HEAD')){res.setHeader('set-cookie','csrf=test-csrf; Path=/; HttpOnly');return json({authRequired:true,csrfToken:csrf})}
+      if(req.url==='/api/app/login'&&req.method==='POST'){
+        const credentials=JSON.parse(body||'{}')
+        if(credentials.username!=='admin'||credentials.password!=='pass'){res.statusCode=401;return json({error:'invalid'})}
+        if(req.headers['x-csrf-token']!==csrf||!String(req.headers.cookie).includes('csrf=')){res.statusCode=403;return json({error:'csrf'})}
+        res.setHeader('set-cookie',[`session=${session}; Path=/; HttpOnly`,`csrf=${csrf}.sig; Path=/; HttpOnly`])
+        return json({user:{id:randomUUID(),username:'admin',role:'admin'},csrfToken:csrf+'-rotated'})
+      }
+      if(req.url==='/api/app/admin/desktop-hosts'&&req.method==='POST'){
+        if(req.headers['x-csrf-token']!==csrf+'-rotated'||!String(req.headers.cookie).includes(`session=${session}`)){res.statusCode=403;return json({error:'session'})}
+        return json({host:{id:hostId,name:JSON.parse(body||'{}').name,enabled:true},token})
+      }
+      res.statusCode=404;json({error:'not found'})
+    })
+  })
+  await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve))
+  return {server,url:`http://127.0.0.1:${server.address().port}`,requests,csrf,session,token,hostId}
+}
+
+test('logs in with username and password and enrolls this Mac as a computer',async()=>{
+  const fake=await fakeServer()
+  try{
+    const auth=await remoteSession(fake.url,{username:'admin',password:'pass'})
+    assert.equal(auth.user.role,'admin')
+    assert.equal(auth.origin,fake.url)
+    assert.ok(auth.cookies.some(([name])=>name==='session'))
+    const installId='22222222-2222-4222-8222-222222222222',previousHostId='33333333-3333-4333-8333-333333333333'
+    const enrollment=await enrollDesktopHost(auth,{name:'书房 iMac',installId,previousHostId})
+    assert.equal(enrollment.host.id,fake.hostId)
+    assert.equal(enrollment.token,fake.token)
+    const [bootstrap,login,enroll]=fake.requests
+    assert.equal(bootstrap.url,'/api/app/bootstrap')
+    assert.equal(login.origin,fake.url)
+    assert.equal(login.csrf,fake.csrf)
+    assert.equal(enroll.csrf,fake.csrf+'-rotated')
+    assert.ok(enroll.cookie.includes(`session=${fake.session}`))
+    assert.deepEqual(JSON.parse(enroll.body),{name:'书房 iMac',installId,previousHostId})
+  }finally{
+    fake.server.close();fake.server.closeAllConnections?.()
+  }
+})
+
+test('wrong credentials and non-admin accounts surface clear errors',async()=>{
+  const fake=await fakeServer()
+  try{
+    await assert.rejects(()=>remoteSession(fake.url,{username:'admin',password:'wrong'}),/用户名或密码不正确/)
+    await assert.rejects(()=>remoteSession(fake.url,{username:'',password:'pass'}),/用户名和密码/)
+    const auth={origin:fake.url,csrfToken:'stale',cookies:[['session','x']]}
+    await assert.rejects(()=>enrollDesktopHost(auth,{name:'x'}),/管理员账号|注册电脑失败/)
+  }finally{
+    fake.server.close();fake.server.closeAllConnections?.()
+  }
+})

+ 1 - 1
docker.env.example

@@ -3,7 +3,7 @@ HERMES_YAOYAO_BIND_ADDRESS=127.0.0.1
 HERMES_YAOYAO_PUBLISHED_PORT=15300
 # 远程通用镜像支持 AMD64 / ARM64;每次发布更新 latest 并保留旧版本标签。
 # HERMES_YAOYAO_IMAGE=samienluo/yaoyao:latest
-# 固定版本:samienluo/yaoyao:v0.4.22;仅 AMD64:samienluo/yaoyao:v0.4.22-amd。
+# 固定版本:samienluo/yaoyao:v0.4.61;仅 AMD64:samienluo/yaoyao:v0.4.61-amd。
 # 留空时使用本地构建名称 yaoyao:local。
 # YAOYAO_DESKTOP_IMAGE=hermes-yaoyao-desktop:0.4.0
 # Cursor Universal 兼容桌面的本地构建名称;基础镜像在 deploy/computer/Dockerfile.cursor 中固定。

+ 7 - 4
docs/bot-agent-teams.md

@@ -6,7 +6,7 @@
 
 日常建群只需要名称、成员、负责人和可选群规则,创建后直接聊天。团队模板和高级协作设置默认收起。顶部的「话题」用于隔离不同聊天上下文,不代表已经启动交付目标。
 
-需要机器人自主组队时,在 Bot 模式创建或编辑 Agent,打开「允许组建团队」并保存。例如只准备团队:
+Bot 模式的组队权限由服务端统一管理,可以直接要求机器人自主组队。例如只准备团队:
 
 > 建一个调研群,优先复用已有成员,先不执行任务。
 
@@ -27,7 +27,7 @@ Web/macOS 的群聊输入区可开启「交付目标」,发送后在当前话
 - Web 服务和发起者的 Hermes 必须在同一机器/网络命名空间,以回环地址连接。远程节点和远端引用 Agent 可作为成员,不能开启发起组队权限。
 - 发起者的基础 Profile 需安装并启用既有 `yaoyao-bot-bridge` 工具桥,能力响应必须包含 `version: 1`、`ready: true`、`in_process: true`、`native_tools: true`。插件由 Hermes Bot 提供;按其安装流程部署并重新加载,Named Profile 需要各自安装、启用。
 - 服务端在首次授予权限及每轮执行前检查条件。不满足时返回具体错误,普通 Agent 对话仍不查询工具桥。
-- 先部署 Web 分支,再使用配套 iOS 分支。现有记录缺少 `canManageTeam` 时按关闭处理;新建成员默认关闭。
+- 当前版本由服务端统一开放持久 Bot 的组队与协作权限;临时助手仍受所属任务限制。
 
 ## 工具与权限
 
@@ -36,7 +36,8 @@ Web/macOS 的群聊输入区可开启「交付目标」,发送后在当前话
 | `workspace_list_sources` | 当前账号获准的基础 Profile |
 | `workspace_list_agents` | 当前账号可使用的已有成员 |
 | `workspace_list_teams` | 发起者担任管理员的团队 |
-| `workspace_create_agent` | 创建成员,禁止授予组队权限 |
+| `workspace_create_agent` | 创建成员时填写初始提示词和角色偏好,沿用服务端统一权限 |
+| `workspace_get_self_rules` / `workspace_update_self_rules` | 读取及修改自身名称、长期提示词和角色规则,更新需要当前版本 |
 | `workspace_create_team` | 默认创建平等讨论团队,也可指定负责人协调或自由协作 |
 | `workspace_start_team_task` | 在发起者管理的团队启动任务 |
 | `workspace_update_team_goal` | 提炼或调整验收要求,校验 `expectedRevision` |
@@ -45,11 +46,13 @@ Web/macOS 的群聊输入区可开启「交付目标」,发送后在当前话
 | `workspace_update_assignment` / `workspace_cancel_assignment` | 调整或停止子任务,保留原因与历史 |
 | `workspace_review_assignment` | 验收、明确返工或记录受阻 |
 | `workspace_finish_team_task` / `workspace_resume_team_task` | 记录目标结论,或从用户新指令恢复目标 |
-| `workspace_update_created_agent` / `workspace_archive_created_agent` | 管理自己创建且符合使用状态限制的成员 |
+| `workspace_update_created_agent` / `workspace_archive_created_agent` | 仅改名或归档自己创建且符合使用状态限制的成员,不能再修改对方规则 |
 | `workspace_update_team` | 调整空闲团队的规则、成员或归档状态 |
 
 所有变更工具要求 `requestId`(UUID);重试同一操作必须复用它。服务端持久保存回执;相同编号用于不同参数返回冲突,重复请求不会重复创建。原生工具调用 ID 也在本轮去重。
 
+持久 Bot 可维护自己的名称、描述、`instructions`、`job`、`antiJobs`、`voice`、`voiceCustom` 和 `actBias`。先读取完整规则及版本,再提交局部更新;未提交字段保持原值,可选角色偏好传 `null` 清除。新规则在后续轮次注入,当前轮次仍可继续使用已授权工具。临时助手与远端引用不开放自我修改;基础 Hermes Profile、模型、执行环境、工具权限和记忆开关不在此接口的可写字段中。创建者只在创建成员时填写对方规则,创建后由成员自身或用户维护。
+
 账号和调用 Agent 从正在运行的服务端轮次取得,模型参数不能指定 owner、token 或调用身份。创建成员只能引用当前账号获准的基础 Profile;子账号的分配规则保持有效。只有团队管理员可以启动或读取该团队的任务。当前群内的用户指令可以将尚无目标的话题升级为目标;自动回传不能重复启动目标。
 
 每轮使用独立随机凭据、独立原生工具 ID 和回环监听端口,凭据仅传给经过认证的工具桥绑定接口。权限、账号、Profile、成员归属、归档和停止状态在每次调用时校验,异步操作在写入前再次校验。绑定保留 Agent 的配置版本;关闭后重新开启权限也不能使旧轮次重新生效。完成、取消、连接结束或服务关闭时销毁监听器并解绑;最长 30 分钟,运行时每 5 分钟续租。断线恢复只核对原执行,不重新提交已有工具副作用;下一轮重新授权。

+ 9 - 1
docs/bot-collaboration-memory.md

@@ -4,7 +4,9 @@
 
 ## 使用方式
 
-- Bot 资料中的“允许 Bot 协作”和“自动记录长期事实”默认开启。创建成员、团队和项目仍需“允许组建团队”。
+- Bot 的组队和协作由服务端统一开放,资料中只展示权限状态;旧客户端提交的单 Bot 组队、协作开关不会覆盖服务端策略。“自动记录长期事实”仍可单独暂停。
+- 持久 Bot 可通过 `workspace_get_self_rules` 读取自己的名称、完整提示词、角色规则和版本,再用 `workspace_update_self_rules` 修改名称、描述、长期提示词、职责、边界、语气和行动偏好。更新校验 `expectedRevision`,新规则从后续轮次生效;不修改基础 Hermes Profile、模型或工具权限。
+- Bot 创建成员时可填写对方的初始提示词和角色规则。创建完成后,创建者不能再修改对方规则;原有改名、归档权限保持不变。成员仍可修改自己的规则,用户也可继续在客户端编辑。临时助手不开放自我修改,记忆维护仍遵守下文的独立权限。
 - 在聊天中要求 Bot 联系同伴。`workspace_send_to_agent` 立即返回投递凭据,同伴回复稍后唤醒原 Bot;`workspace_post_to_group` 发布到自己参加的群。界面可查看请求、结果、状态,并停止整条协作。
 - 新建群默认平等讨论,无需选择负责人;未点名时全体参与。普通消息一轮、讨论默认两轮,可通过发送选项或文字指定 1–12 轮,最多 8 位成员,逐轮轮换发言顺序。成员失败不阻止其他成员。
 - 已有群保留原模式,空闲时可切换。需要交付时再开启“交付目标”、选择有组队权限的负责人,沿用原有任务与验收流程。
@@ -22,6 +24,12 @@
 
 暂停自动记录不会删除现有记忆。遗忘和人工修订记录旧内容与旧证据标记,防止旧提炼任务通过改写措辞恢复旧事实。遗忘记忆不会删除原聊天。
 
+记忆分为 `profile`(基础事实)、`log`(历史)和 `note`(仅搜索)三层。Bot、项目、用户三个范围共用 16,000 字符的提示预算,包含说明、范围标题和来源标识。先轮流选取各范围的基础事实,再按各范围的最近更新时间选取历史;只放入完整条目。超出预算的事实仍保留,可通过 `workspace_memory_search` 查询。
+
+后台提炼请求包含提示、已有记忆和本轮证据,总长度最多 60,000 字符,低于工具桥的 65,000 字符限制。证据按序列化后的 JSON 长度计算,保留用户消息优先级和完整 JSON 结构,不通过截断 JSON 字符串控制长度。
+
+本地文件搜索按正文关键词匹配。启用 OpenViking 后保留授权范围内的语义命中和关键词命中,不再要求语义结果包含查询原文。
+
 ## 文件布局与备份
 
 根目录为 `<HERMES_YAOYAO_HOME>/bot-workspace/<账号 ID>/`:

+ 9 - 0
docs/chat-appearance/README.md

@@ -0,0 +1,9 @@
+# 聊天气泡外观
+
+入口:设置 → 外观 → 聊天气泡。
+
+三套预设:当前样式(经典蓝灰)、Grok Bot(黑白灰)、Codex(浅蓝双气泡)。点击立即应用,也可分别调整用户/助手气泡的纯色或渐变、浅/深色配色、圆角、边框与尾巴。文字自动适配对比度;支持撤销上一步和恢复默认。
+
+设置只保存在当前设备,并应用到该设备的所有会话。普通聊天和 Bot 聊天使用同一设置;媒体、工具、错误与技术卡片继续使用自身样式。
+
+本目录包含实际运行截图;完整视觉和交互验收记录见仓库根目录 `design-qa.md`。

BIN
docs/chat-appearance/approved-design.png


BIN
docs/chat-appearance/web-chat-dark.jpg


BIN
docs/chat-appearance/web-desktop-codex.jpg


BIN
docs/chat-appearance/web-mobile-grok.jpg


+ 2 - 2
docs/computer-provider.md

@@ -7,8 +7,8 @@
 - Docker 和 Podman 使用同一份接口与配置校验;远程引擎要求将 Runner 放到目的电脑,避免把本机目录误当作远程挂载路径。
 - 镜像必须使用完整不可变 ID,并验证兼容的 CUA 驱动标签。当前采用本机已有的 OpenMausBot CUA 0.20.0、layer 5 镜像接口;没有复制或修改参考仓库。
 - 环境运行在容器隔离层。macOS 上 Docker/Podman 的底层 Linux 虚拟机由运行时提供,每个环境不是一台独占内核的 VM。
-- 仅挂载该环境的持久工作目录;不挂载 Docker socket、宿主 HOME、Hermes 配置或凭据。命令固定以 guest UID/GID 1000 执行,工作目录为 `/home/cua/workspace`。
-- 固定独立 IPC/cgroup 命名空间、禁止提权、收紧 capability,并设置 CPU、内存、swap 与进程数上限。每次执行前核对运行实例、镜像、归属、挂载与约束。
+- 仅挂载该环境的持久工作目录;不挂载 Docker socket、宿主 HOME、Hermes 配置或凭据。命令默认以 guest UID/GID 1000 执行,也可显式选择 root;工作目录为 `/home/cua/workspace`。
+- 固定独立 IPC/cgroup 命名空间并收紧 capability,同时设置 CPU、内存、swap 与进程数上限。每次执行前核对运行实例、镜像、归属、挂载与约束;Bot 可显式选择 cua 或 root 用户执行 Linux 命令。
 - 默认 `--network none`,不发布任何端口。容器只有 loopback 网卡,不能直接访问宿主服务或外网。自己的主机名映射到 loopback,保证 XFCE/VNC 在无网络环境下正常启动。可通过专属进程通道启用受控公网代理,仍不增加外部网卡或端口。详见 `docs/computer-network.md`。
 - 桌面通过容器内的 CUA socket 操作;验收已读取真实截图。查看和人工接管已接入账号鉴权及独立控制租约,见 `docs/computer-control.md`。
 - 取消或无法确认的 guest 命令会停止所属私有容器,确认停止后才释放串行执行位置。仅终止 `docker exec` 客户端不能证明 guest 进程已停止。

BIN
docs/design/approval-card-ios-before.jpg


BIN
docs/design/approval-card-ios.jpg


BIN
docs/design/approval-card-reference.png


BIN
docs/design/approval-card-web-before.jpg


BIN
docs/design/approval-card-web-dark.jpg


BIN
docs/design/approval-card-web.jpg


BIN
docs/design/bot-approval-desktop.jpg


BIN
docs/design/bot-profile-mobile.jpg


+ 58 - 0
docs/desktop-hosts.md

@@ -0,0 +1,58 @@
+# 服务器与电脑
+
+一台服务器集中运行 Web(15300)与 Hermes(9119),其他 Mac 安装夭夭 App 后作为“电脑”出站连接服务器,向服务器上的 Bot 提供自己的真实桌面(截图、键鼠、独立浏览器)。产品中只用两种名称:运行服务的一端叫“服务器”,连接服务器的 Mac 叫“电脑”。服务器自己机器上的 App 继续走本机回环通道,内部编号为 `local`。
+
+## 服务端执行与统一权限
+
+所有 Bot 的聊天、模型、配置、记忆提炼都运行于服务端 Hermes。客户端 App 只负责界面和已授权的电脑操作,无需安装 Hermes。虚拟机 Runner 只在调用 `computer_*` 时建立工具会话;虚拟机离线不会转移聊天,也不会让普通聊天启动虚拟机。
+
+电脑开放范围与审批策略在 Bot 设置统一管理,默认开放服务器、电脑、Grok Bot 云电脑和虚拟机。旧 Bot 的 `computer`、`execution`、`envs`、`approvalPolicy` 不再决定实际设备权限或模型运行位置。旧虚拟机共享关系保留,任务助手仍受所属任务的生命周期约束。
+
+- **消息来源**:客户端每次发送时重新读取 `deviceHost`,服务端保存到消息和运行。省略 `host` 或使用「本机」/`local` 时,只解析为本轮来源电脑;切换客户端后新消息覆盖来源,已经运行的任务保留自己的来源快照。
+- **明确目标**:`desktop_*` 的 `host` 可指定电脑名称或编号;`server` /「服务器」固定指服务器。重复名称需要用编号。来源未知、离线或全局关闭时明确报错,不用旧消息、Bot 绑定或其他在线机器兜底。普通浏览器未提供可控设备身份时须点名目标。
+- **协作与定时任务**:Bot 转交、子任务和结果回传继承触发消息的来源。定时任务保存自己的「本机」目标,重启或换客户端查看不会改变它;旧任务未保存目标时须在内容中明确指定。
+- **并行环境**:同一 Bot 可在一轮中操作多个环境。连接、系统授权和人工接管状态按设备校验,不按 Bot 区分权限。文件与命令授权不依赖屏幕录制或辅助功能。
+- **审批**:所有 Bot 共用「询问我 / 自动允许 / 自动拒绝」,变更用于后续审批请求;已等待的请求单独答复。聊天中的允许只作用于本次,旧客户端的 `auto` 答复也只允许一次。
+- **Hermes 原生工具**:原生终端和文件工具始终操作服务器,与消息来源无关;访问来源客户端应使用 `desktop_*`。全局服务器电脑开关控制 desktop 适配器,旧 `denyServerTools` 字段停用,不再展示未接入的封禁开关。
+- **接管界面**:`/api/app/agents/:id/computer` 系列接受 `backend=desktop|cloud|vm`,桌面可附带 `host`。界面显式选择目标。此处的 `host=local` 是历史 API 的服务器编号,不等于 Bot 工具中随消息变化的别名。
+
+## 启用流程
+
+1. 在那台 Mac 上启动夭夭 App。**首次启动会询问这台 Mac 的使用方式:「连接服务器(客户端)」或「作为服务器运行」,默认选择客户端**。
+   - 选「连接服务器」:弹出登录窗口,填写**夭夭服务器地址(如 `192.168.1.10:15300`)、用户名和密码**。登录成功后窗口直接使用远程服务器的夭夭界面(本机不运行 Web 服务);用**管理员账号**登录时,App 会自动把这台 Mac 注册为电脑(令牌经系统钥匙串加密保存在数据目录 `desktop-host.enc`,0600),无需任何配置文件。非管理员账号只登录界面,并提示需要管理员账号才能注册电脑控制。
+   - 选「作为服务器运行」:在这台机器运行 Web,并连接这里配置的 Hermes。
+   - 勾选「记住选择,之后启动不再询问」会把选择写入偏好(`startupChoice`);也可在菜单「运行模式 → 启动时询问运行模式」恢复每次询问。
+2. 后续启动直接进入远程模式;若登录会话已过期,App 会重新弹出登录窗口(服务器地址已预填)。会话 Cookie 保存在 App 的会话存储中,密码不落盘。使用中可随时通过「运行模式」切换服务器与客户端模式;「电脑 → 断开并忘记配置」会移除本机的电脑凭据。
+3. 服务器管理侧(可选):「设置 → Hermes 连接 → 电脑」列出各台已注册电脑(在线状态、机器名、最后在线)并可停用;停用立即断开那台 Mac。被停用的电脑不会因启动或普通重连自行恢复;用户再次显式登录管理员账号,或选择「电脑 → 重新授权…」后,服务复用原记录、轮换令牌并恢复连接。旧版没有安装编号的电脑通过原记录编号完成迁移,避免产生重复记录。
+4. 手动注册并下载 `desktop-host.json` 仍可用于不便登录的机器(菜单「电脑 → 导入电脑配置…」),但常规流程不再需要。
+5. 管理员在全局设置中开放电脑类型,在聊天右侧电脑面板查看各台电脑的连接与授权状态;无需为各 Bot 单独勾选环境或绑定默认执行机。
+6. 首次授权:管理员点「在桌面端授权」,那台 Mac 弹出原生授权对话框;确认后引导开启屏幕录制与辅助功能。授权按账号哈希(ownerKey)记录在各 Mac 的 `computer-permissions.json`,各机独立;菜单「撤销本机控制授权」同时作用于本机与远程通道。
+
+## 文件与命令(全面操作)
+
+屏幕授权之外是独立的第二档授权「文件与命令」:电脑面板直接提供「授权文件与命令」按钮,无需先完成屏幕授权,Mac 端弹窗单独确认。授权后该账号下所有机器人获得四个工具:
+
+- `desktop_file_list` / `desktop_file_read` / `desktop_file_write`:在这台 Mac 的**用户主目录**范围内列目录、读文件(≤12MB)和写文件(≤10MB);`..`、绝对路径越界和符号链接逃逸都会被拒绝,TCC 保护目录仍按系统权限处理。
+- `desktop_shell`:在主目录执行一条 zsh 命令(最长 120 秒,stdout/stderr 各截断 512KB,超时终止并如实报告)。
+
+两档授权分别记录(`approved` 与 `approvedFull`),「撤销本机控制授权」同时清除;工具目录按账号下可用设备的授权汇总,且每次调用在服务端二次校验。
+
+## 传输与边界
+
+- 机器端点 `POST /api/desktop-host/v1/<hostId>/exchange`:Bearer 令牌(sha256 后 timingSafeEqual)+ `x-desktop-host-protocol: 1`;拒绝任何携带 Origin 的请求,不进入用户会话、CSRF 或 CORS 体系;Host 白名单照常生效。
+- 交换协议沿用桌面端 `{host, results} → {commands}` 格式:每轮最多 8 条命令、20 条结果,请求体上限 24MB。App 成功后 400ms 轮询,网络错误指数退避至 5s;令牌失效(401/403)即停止并提示重新导入。
+- 每台电脑独立持有命令队列、截图缓存、接管凭据与授权状态;连接 epoch(App 每次启动/撤销时轮换的 `host.id`)变化即围栏在途命令。人工接管的 generation/epoch/30 秒续期语义与单台电脑时一致,接管记录以 `desktop:<hostKey>:<resource>` 区分。
+- 远程明文 HTTP(服务器地址以 `http://` 登录)时,App 保存的电脑配置自动带 `allowInsecureLan: true`,与 Runner 规则一致;公网部署应使用 HTTPS 并把域名加入外网访问地址。登录凭据只走该服务器地址,密码不落盘。
+- 停用电脑立即断开那台 Mac 并围栏其在途命令;旧令牌不能恢复,必须通过显式管理员登录重新授权。
+
+## 范围
+
+- 物理机控制仅支持 macOS(屏幕录制、辅助功能与 computer-helper 签名校验均为 macOS 专属)。
+- 本功能只提供真实桌面与独立浏览器环境;远程机器上的 Linux 虚拟桌面(无 Hermes 电脑节点)不在本范围。
+- 服务器侧 Bot 会话、模型与记忆全部留在服务器的 Hermes;卫星机不安装 Hermes。
+
+## 验证
+
+- 服务端:`tests/server/desktopHosts.test.ts`(注册令牌一次性、准入与协议头、撤销围栏)、`tests/server/desktopEnvironments.test.ts`(消息来源解析、离线不回退、全局权限、文件与屏幕授权独立、并发来源隔离、按机围栏)。
+- App:`desktop/remote-login.test.mjs`(地址归一化、账号密码登录的 CSRF/Origin 往返、管理员注册电脑、错误路径)、`desktop/host-files.test.mjs`(目录内列/读/写、路径与符号链接逃逸拒绝、命令退出码/超时/工作目录)、`desktop/host-manager.test.mjs`(配置校验、加密导入、交换往返、403 停止、退避重试)、`desktop/preferences.test.mjs`(启动选择与远程地址偏好持久化)。启动选择/登录窗口需按上述流程手工验收(自动化桌面测试通过 fixture 环境固定走本地路径)。
+- 浏览器:`tests/e2e/desktop-hosts.spec.ts`(注册/下载/停用;模拟远程电脑连接与电脑面板状态)。真实多机链路需按上述流程手工验收。

+ 4 - 0
docs/desktop-lifecycle.md

@@ -1,5 +1,9 @@
 # macOS App 与后台服务
 
+同一个 App 支持两种角色。客户端模式只连接服务器并提供已授权的设备操作,无需本机 Hermes;服务器模式管理下表中的后台服务。切到客户端会关闭 App 的本机操作通道、停止其子进程并断开本机服务连接;独立后台服务继续遵循原生命周期,可通过停止后台服务菜单关闭。首次选择默认是客户端。
+
+登录后可在「我的设置 → 运行模式」查看当前角色和服务器地址,选择「客户端模式」或「服务器模式」并切换,也可通过「更换服务器」重新登录其他服务器。此入口向桌面 App 的所有账号开放,管理的是当前电脑,不依赖远程账号的管理员权限;普通浏览器不显示本机运行模式控制。原生菜单栏另有常驻的「运行模式」菜单。切换成功后记住选择,账号与聊天数据保留在各自服务器。
+
 | 操作 | 结果 |
 | --- | --- |
 | 关闭窗口 | 隐藏窗口,App 与后台继续运行 |

+ 7 - 7
docs/docker-install.md

@@ -12,14 +12,14 @@
 
 | 标签 | 架构 |
 | --- | --- |
-| `v0.4.22-amd` | `linux/amd64` |
-| `v0.4.22` | `linux/amd64`、`linux/arm64`,拉取时自动匹配 |
-| `latest` | 最新稳定通用镜像,当前指向与 `v0.4.22` 相同的镜像 |
+| `v0.4.61-amd` | `linux/amd64` |
+| `v0.4.61` | `linux/amd64`、`linux/arm64`,拉取时自动匹配 |
+| `latest` | 最新稳定通用镜像,当前指向与 `v0.4.61` 相同的镜像 |
 
 ```sh
-docker pull samienluo/yaoyao:v0.4.22
+docker pull samienluo/yaoyao:v0.4.61
 # 需要固定 AMD64 时:
-docker pull samienluo/yaoyao:v0.4.22-amd
+docker pull samienluo/yaoyao:v0.4.61-amd
 ```
 
 每次新版本发布都会更新 `latest`,旧版本标签继续保留。需要固定部署版本时使用具体版本标签。
@@ -34,7 +34,7 @@ cp docker.env.example docker.env
 
 | 配置 | 用途 |
 | --- | --- |
-| `HERMES_YAOYAO_IMAGE` | 远程镜像可设为 `samienluo/yaoyao:v0.4.22` 或 `samienluo/yaoyao:latest`;未设置时使用本地构建名称 |
+| `HERMES_YAOYAO_IMAGE` | 远程镜像可设为 `samienluo/yaoyao:v0.4.61` 或 `samienluo/yaoyao:latest`;未设置时使用本地构建名称 |
 | `HERMES_YAOYAO_UPSTREAM` | Hermes 上游地址,默认 `http://host.docker.internal:9119` |
 | `HERMES_YAOYAO_BIND_ADDRESS` | Web 的宿主机发布地址,默认 `127.0.0.1`;局域网访问可设为 `0.0.0.0` |
 | `HERMES_YAOYAO_PUBLISHED_PORT` | 宿主机 Web 端口,默认 `15300` |
@@ -191,7 +191,7 @@ curl --fail http://127.0.0.1:15300/healthz
 使用 Docker Hub 发布镜像时,在 `docker.env` 设置:
 
 ```dotenv
-HERMES_YAOYAO_IMAGE=samienluo/yaoyao:v0.4.22
+HERMES_YAOYAO_IMAGE=samienluo/yaoyao:v0.4.61
 YAOYAO_CURSOR_DESKTOP_IMAGE=samienluo/yaoyao-desktop:v0.4.12-cursor-amd
 ```
 

+ 4 - 3
docs/local-vm.md

@@ -6,7 +6,7 @@
 
 1. 进入应用设置 → **本地虚拟机**。macOS App 的应用菜单也提供“本地虚拟机设置…”。
 2. 检查 Docker/Podman 已安装并启动,在 **准备虚拟机镜像** 中选择 **标准桌面** 或 **Cursor Universal**,点击 **准备所选镜像**。两个镜像可分别准备;会复用对应的兼容镜像或构建固定版本,验证驱动和实际截图后标记就绪。准备前先停止所有虚拟机任务和实例。外部执行节点需更新配套 Runner。
-3. 选择 **共享虚拟机** 或 **每个 Agent 独立**,最多同时运行 1–4 台,默认 2 台。同一账号、同一执行节点的持久 Agent 共用桌面、工作文件和浏览器资料,新建成员会继承当前共享策略。临时任务助手继续使用任务隔离环境,完成后单独清理,不会删除持久共享工作区。
+3. 选择 **共享虚拟机** 或 **每个 Agent 独立**,最多同时运行 1–4 台,默认 2 台。同一账号、同一执行节点的持久 Agent 共用桌面、工作文件和浏览器资料,新建成员会继承当前共享策略。临时任务助手继续使用任务隔离环境,完成后单独清理,不会删除持久共享工作区。切换共享方式或重建本机执行节点时,服务会自动把成员归并到当前唯一共享组,并停止不再使用的旧桌面,避免旧实例占用运行数量上限。共享桌面上多个机器人的轮次并行执行:命令与文件操作并发运行(执行车道,最多 8 路同时),桌面鼠标键盘操作交替进行(桌面车道,一次一个);启动、停止、换镜像等生命周期操作会先排空所有操作再执行。任一机器人的轮次失败只作废自己的执行权,最后一个使用者离开后才按空闲策略停止桌面。人工接管时暂停该桌面上的所有机器人,接管者与桌面上的其他持有者一样获得自己的执行权;交还后机器人继续原会话。
 4. 打开 Agent 聊天,点击右上角 **电脑**。右侧电脑面板中选择 **本地虚拟机**,在 **虚拟机镜像** 中选择已准备的镜像,再创建桌面。独立桌面可分别选择不同镜像并同时运行;同一个共享桌面的所有成员只能使用这台桌面的一个镜像。
 5. 右侧显示真实画面及运行状态,可停止或重建虚拟机;点击预览或 **打开桌面** 后接管交互。
 6. **打开双桌面** 在主工作区显示两台虚拟机,保留聊天侧栏。进入时仅查看,不会创建/启动机器;切换操作对象时先交还前一台的控制权。
@@ -42,10 +42,11 @@
 - 每个 Profile 单独显示安装版本、实际加载版本和状态。缺少后台入口时,先安装或更新默认 Profile,再安装命名 Profile。
 - “安装并启用”只启用选中的工具桥及其工具集,保留其他插件、禁用项和模型配置。每次安装保留原插件与配置备份,界面可查看备份位置。
 - 检查会比较插件文件指纹与 Hermes 启动时加载的指纹;同版本修复后未重启也会显示“待重启”,不会仅凭安装文件判断就绪。
-- 安装不会自动重启 Hermes。请在空闲时重启 Dashboard 服务(默认 9119),再点击“重新检查”。正在执行任务时暂不可安装。
+- 安装不会自动重启 Hermes。由 Yaoyao 桌面服务自己启动并持有进程的本机 Dashboard(`127.0.0.1:9119`),可在此页面点击“重启 Hermes Dashboard”,完成后自动检查各 Profile 的实际加载状态。重启影响整个 Dashboard,而非单个 Profile。
+- 正在执行任务、安装工具桥或已有重启操作时不可重启;重启期间暂不接受新任务,定时任务等待下一次检查。外部启动的 Dashboard、Docker 目录映射与远程 Hermes 仍需在所在节点重启,再点击“重新检查”。正在执行任务时暂不可安装。
 - 本机安装用于当前服务可访问的本机 Hermes。Docker 可显式映射对应 Hermes 数据目录以安装工具桥,详见 [Docker 目录映射](docker-install.md#映射-hermes-目录以安装工具桥);其他远程节点支持状态检查,需在对应节点安装。
 
-管理员 API:`GET /api/app/admin/hermes-bridge` 与 `POST /api/app/admin/hermes-bridge/install`,安装参数仅为 `profile` 和可选的 `enable`;不接受客户端传入目录、命令或 Python 路径。
+管理员 API:`GET /api/app/admin/hermes-bridge`、`POST /api/app/admin/hermes-bridge/install` 与 `POST /api/app/admin/hermes-bridge/restart`。重启接口无需参数,状态中的 `dashboard` 提供托管状态、是否可重启及原因;安装参数仅为 `profile` 和可选的 `enable`。不接受客户端指定重启目标或执行命令。
 
 需要 Runner 的 `hermes-computer-v2` 和 `workspace-memory-bind-v1` 能力,以及每个使用中的 Profile 安装工具桥 **1.2.1**,能力响应包含 `computer_runtime_version: 2`。旧插件会明确提示更新,不回退启动 Worker。
 

BIN
docs/media-qa/approved-design.png


BIN
docs/media-qa/desktop.png


BIN
docs/media-qa/mobile-dark-order.png


BIN
docs/media-qa/mobile-light-order.png


BIN
docs/media-qa/mobile-ordinary.png


BIN
docs/media-qa/mobile.png


+ 5 - 0
docs/releases/v0.4.26.md

@@ -0,0 +1,5 @@
+# v0.4.26
+
+- 远程电脑:其他 Mac 用服务器地址与账号密码“登录远程”,窗口直接使用远程夭夭;管理员账号自动把本机注册为可远程控制的电脑(看屏/键鼠/文件/命令,分档授权)。
+- 机器人环境改为并列多选(envs):本地虚拟机 / 云端 Grok / 本机控制(多台 Mac 按名寻址)/ 仅浏览器同时启用;虚拟机按执行节点可用性自动降级;旧单选选择自动迁移。
+- 修复:与 0.4.25 同版本安装时本机 Web 不会更新的问题——本版本号递增,安装后 App 会用配套 Web 覆盖旧版。

+ 4 - 0
docs/releases/v0.4.27.md

@@ -0,0 +1,4 @@
+# v0.4.27
+
+- 机器人电脑面板的环境多选区重新设计为卡片式:图标 + 名称 + 说明 + 勾选态高亮,与整体界面风格统一。
+- 勾选「本地虚拟机」后,即使虚拟机尚未准备,面板也会保留「设置本地虚拟机」入口,方便首次配置。

+ 5 - 0
docs/releases/v0.4.28.md

@@ -0,0 +1,5 @@
+# v0.4.28
+
+- 修复机器人电脑面板在多环境并列时的闪跳:轮询刷新不再被本机/云端的中间状态覆盖,镜像选择与设置入口保持稳定;连续快速勾选多个环境不再丢失前一次勾选。
+- 桌面查看与接管支持环境切换:本机与各远程 Mac(按名称)、云端 Grok、本地虚拟机可在查看器顶部随时切换;服务端接管通道支持按主机寻址,未授权主机会给出明确提示。
+- 环境多选卡片选中态调整:去掉深色描边,勾选时复选框为绿色对勾、卡片带淡绿底色。

+ 4 - 0
docs/releases/v0.4.29.md

@@ -0,0 +1,4 @@
+# v0.4.29
+
+- 机器人电脑面板预览区顶部新增桌面下拉框:多环境并列时可切换显示 本机 / 各远程 Mac / 云端 Grok / 本地虚拟机,解决勾选本机或云端后虚拟机画面不再显示的问题;「自动」保持原有优先级。
+- 从预览打开桌面时按所选桌面直达对应接管通道(含具体 Mac 主机)。

+ 4 - 0
docs/releases/v0.4.30.md

@@ -0,0 +1,4 @@
+# v0.4.30
+
+- Bot 操作目标改为自动判断:默认始终在服务器(安装并启动 Hermes 的那台)桌面上操作;已授权的卫星 Mac 由 Bot 在工具调用中按电脑名称点名操作,不再需要人工预先绑定。
+- 电脑面板取消「操作的电脑」绑定选择器,改为逐台 Mac 的授权状态卡片(控制授权/屏幕录制/辅助功能/文件与命令),每台可单独发起授权;旧的绑定设置仅在服务器桌面离线时作为兜底生效。

+ 4 - 0
docs/releases/v0.4.31.md

@@ -0,0 +1,4 @@
+# v0.4.31
+
+- Bot 结构化人设:一句话职责、反任务清单、语气、行动偏好,自动注入系统提示词,聊天列表以职责为副标题。
+- 新建 Bot 支持从 Grok Bot 模板导入:粘贴 x.ai/bot 链接自动抓取(可选代理),或直接粘贴描述一键生成;按"项目管理/家庭管家/通用"三套模板翻译为夭夭的工具与工作规则(Notion→任务计划、CreateAgent→组建团队、盯邮件日历→本机命令+定时任务建议)。

+ 5 - 0
docs/releases/v0.4.32.md

@@ -0,0 +1,5 @@
+# v0.4.32
+
+- 修复 Profile 会话停止轮询时向 active_list 误传 session_id 被上游契约拒收的问题。
+- 修复普通聊天在上游立即接受时本地镜像队列未出队导致的“幻影排队”。
+- 含 v0.4.31 的 Bot 结构化人设与 Grok Bot 模板导入。

+ 5 - 0
docs/releases/v0.4.33.md

@@ -0,0 +1,5 @@
+# v0.4.33
+
+- 卫星执行节点改为直接连接服务器 Hermes,不再依赖本地 Runner。
+- Bot 多环境并列正式生效:勾选的虚拟机/云端/本机/浏览器同时可用,去除旧的单选互斥。
+- 含 v0.4.31–0.4.32 的结构化人设、Grok Bot 模板导入与会话修复。

+ 5 - 0
docs/releases/v0.4.34.md

@@ -0,0 +1,5 @@
+# v0.4.34
+
+- 修复工具回合的分段完成不再误关正在进行的回复(882478d)。
+- 思考指示点改为弹跳动画并去掉胶囊底,视觉更轻。
+- 含 v0.4.33 的卫星节点直连与多环境并列等全部内容。

+ 6 - 0
docs/releases/v0.4.35.md

@@ -0,0 +1,6 @@
+# v0.4.35
+
+- 对话记录留在服务端,虚拟环境改为外派工具,卫星机内操作更直接(9cfc4e4)。
+- 服务端虚拟机只在机内操作,不再提示允许本机环境(ba3569e)。
+- 修复插入的用户消息按插入时机排序(75f1472)。
+- 等待指示加上绕身彩带并去掉等待时间(65f3663)。

+ 6 - 0
docs/releases/v0.4.36.md

@@ -0,0 +1,6 @@
+# v0.4.36
+
+- Bot 资料增加每轮带上的描述,记忆按基础、历史、短暂分层注入,服务端工具禁用改为全局开关(70ea7c6)。
+- 组队和协作改为默认能力,去掉单独开关,临时助手仍不能组队(953339c)。
+- 去掉仅浏览器环境线,电脑浏览器和仅浏览器不再可选(1589880)。
+- 修复可选的工作表情不再套上等待彩带(fd317fb)。

+ 4 - 0
docs/releases/v0.4.37.md

@@ -0,0 +1,4 @@
+# v0.4.37
+
+- 电脑开关改为全局设置,单个机器人不再勾选电脑;电脑、服务器、虚拟环境和云虚拟机,以及文件访问和 Bot 记忆,都进 Bot 设置(997371b)。
+- 虚拟环境操作对齐云虚拟机,先看桌面再操作;恢复会话时不再带 Hermes 不认的 disabled_tool_sets(997371b)。

+ 3 - 0
docs/releases/v0.4.38.md

@@ -0,0 +1,3 @@
+# v0.4.38
+
+- 在 Bot 设置里给服务器和已配对的电脑改显示名,机器人按新名字点名;写「本机」仍然指向当前消息来源电脑(027d4dc)。

+ 3 - 0
docs/releases/v0.4.39.md

@@ -0,0 +1,3 @@
+# v0.4.39
+
+- 创建 Hermes 会话时不再发送 `disabled_toolsets`。当前 Hermes 拒收这个字段,新建 Bot 发消息会报版本不同步(a340ba4)。

+ 4 - 0
docs/releases/v0.4.40.md

@@ -0,0 +1,4 @@
+# v0.4.40
+
+- 本机工具开关只写进提示词,不再传给 Hermes(df82f81)。
+- 含未发版的 v0.4.39 全部内容:创建 Hermes 会话不再发送 `disabled_toolsets`,修复新建 Bot 发消息报版本不同步(a340ba4)。

+ 4 - 0
docs/releases/v0.4.41.md

@@ -0,0 +1,4 @@
+# v0.4.41
+
+- 用量按文字自计,回复结束后不再向 Hermes 查询;消息和上文都没提到环境时只留开放名单(0ba7963)。
+- 同一台卫星电脑只登记一行,再次登录沿用安装编号,不再新开一台(ea7993f)。

+ 4 - 0
docs/releases/v0.4.42.md

@@ -0,0 +1,4 @@
+# v0.4.42
+
+- 服务器与电脑分开,按云虚拟机方式先看真实桌面再操作,本机只指当前消息来源电脑;Bot 可用 Hermes 全部工具,长期记忆仍用 Bot 自己的(159943e)。
+- 去掉卫星执行节点和远程机器人:执行节点只服务虚拟环境,不再接管聊天;远程 Bot 不再导入或转发到别的服务器(e79d455)。

+ 3 - 0
docs/releases/v0.4.43.md

@@ -0,0 +1,3 @@
+# v0.4.43
+
+- 消息带设备来源,「本机」按发消息的电脑解析:用户消息携带 local/主机编号,网页无来源时仍默认服务器(33a855d)。

+ 4 - 0
docs/releases/v0.4.44.md

@@ -0,0 +1,4 @@
+# v0.4.44
+
+- 修复 ~/ 路径越权(~/Desktop 不再被解析成 /Desktop),执行节点透传真实工具错误(9aed519)。
+- 提示改为文件/命令直走工具,只有看窗口才截图(9aed519)。

+ 3 - 0
docs/releases/v0.4.45.md

@@ -0,0 +1,3 @@
+# v0.4.45
+
+- 虚拟机租约延后到真正用电脑工具时再拿:会话 create/resume 不再抢池子,computer_*/skill 首次调用才 ensureLease;池子忙或环境故障软回工具结果,查天气等非电脑回合不再整轮被 computer_busy 掐死(0a3b332)。

+ 3 - 0
docs/releases/v0.4.46.md

@@ -0,0 +1,3 @@
+# v0.4.46
+
+- 统一服务端 Bot 执行与设备权限,按消息来源解析「本机」(dd1e337)。

+ 4 - 0
docs/releases/v0.4.47.md

@@ -0,0 +1,4 @@
+# v0.4.47
+
+- 增加登录后的服务器与客户端模式切换入口(d00de24)。
+- 修复非默认 Profile 工具目录,并补充 Hermes 超时定位信息(64095d4)。

+ 6 - 0
docs/releases/v0.4.48.md

@@ -0,0 +1,6 @@
+# v0.4.48
+
+- 新增服务器与电脑之间的直接文件复制(b6dd8a5)。
+- 修复电脑选择与桌面窗口目标不一致(5b4ae36)。
+- 修复命名 Profile 模型串用与工具桥初始化等待(a6a8eae)。
+- 修复设备编号并发重复,并区分同名电脑的配对记录(4a16d50)。

+ 4 - 0
docs/releases/v0.4.49.md

@@ -0,0 +1,4 @@
+# v0.4.49
+
+- 支持 Bot 独立模型设置,并在所有会话的下一轮统一应用(287ed83)。
+- 区分 Bot 模型设置与管理员模型服务的草稿提示(27ac742)。

+ 4 - 0
docs/releases/v0.4.50.md

@@ -0,0 +1,4 @@
+# v0.4.50
+
+- 修复 Bot 冷恢复后模型设置失效,并记录本地多模型实测(79e65e3)。
+- 为工具桥增加本机托管 Dashboard 重启功能(9d96522)。

+ 4 - 0
docs/releases/v0.4.51.md

@@ -0,0 +1,4 @@
+# v0.4.51
+
+- 默认隐藏 Bot 和普通聊天的思考过程与工具,可在会话偏好里打开(34762fd)。
+- 修复历史工具导致输入动画残留与虚拟机状态误报(63922d9)。

+ 4 - 0
docs/releases/v0.4.52.md

@@ -0,0 +1,4 @@
+# v0.4.52
+
+- 修复 Bot 记忆搜索与上下文预算,并统一远程能力契约(a7f6256)。
+- 统一角色偏好样式并稳定空态预览(67d4f01)。

+ 3 - 0
docs/releases/v0.4.53.md

@@ -0,0 +1,3 @@
+# v0.4.53
+
+- 允许 Bot 修改自身名称和角色规则,并限制创建后改写其他成员(c932d11)。

+ 5 - 0
docs/releases/v0.4.54.md

@@ -0,0 +1,5 @@
+# v0.4.54
+
+- 统一文件卡片识别规则,说明性链接不再误显示为文件卡片(c195e59、a2cb84e)。
+- 修复归档和删除 Bot 时自动清理电脑共享关系(0673c72)。
+- 将 Hermes 工具桥绑定超时延长至 60 秒(172f12f)。

+ 3 - 0
docs/releases/v0.4.55.md

@@ -0,0 +1,3 @@
+# v0.4.55
+
+- 重设计任务进度与提问交互:任务计划、提问卡片和任务结果通知更新呈现方式(008c763)。

+ 3 - 0
docs/releases/v0.4.56.md

@@ -0,0 +1,3 @@
+# v0.4.56
+
+- 修复电脑停用后的重新授权,并统一「脚本机/服务器」相关术语(30c1125)。

+ 4 - 0
docs/releases/v0.4.57.md

@@ -0,0 +1,4 @@
+# v0.4.57
+
+- 交付进展卡片默认折叠(fe09a09)。
+- 调整输入指示器头像间距(439cf8e)。

+ 5 - 0
docs/releases/v0.4.58.md

@@ -0,0 +1,5 @@
+# v0.4.58
+
+- 修复 Bot 会话同步,并统一跨设备文件传输上限(3e4789b)。
+- 聊天页头同步显示头像和名称,随后移除页头同步状态(100efe9、c2f75e1)。
+- 移除从 Grok Bot 导入功能(e64d847)。

+ 6 - 0
docs/releases/v0.4.59.md

@@ -0,0 +1,6 @@
+# v0.4.59
+
+- 桌面端新增聊天气泡预设与自定义外观(2a0309d)。
+- 将群聊交付目标入口收进加号菜单(f523319)。
+- 统一聊天错误提示并折叠重复技术报错(53b0d51)。
+- 统一等待头像身份并修复绕身彩带(568b7a7)。

+ 5 - 0
docs/releases/v0.4.60.md

@@ -0,0 +1,5 @@
+# v0.4.60
+
+- 修复 Bot 记忆提炼空结果与 OpenViking 检索,并显示保存结果(0ead85f,含远端主分支合并 4c0ad44)。
+- 按原顺序独立展示消息正文、图片和文件(b844ee1)。
+- 统一桌面和移动网页系统提示的极简样式(3e0a07c)。

+ 45 - 0
docs/releases/v0.4.61.md

@@ -0,0 +1,45 @@
+# 夭夭 AI v0.4.61
+
+本次发布 Web、macOS Apple Silicon 桌面版和 Docker 双架构镜像,不提供 APK。此版本汇总 v0.4.22 之后的本地更新,并包含最新头像刷新修复。
+
+## 更新内容
+
+- 修复刷新页面时短暂出现绿色默认头像的问题。头像资料尚未加载或图片失效时显示中性占位,保留用户设置的照片与造型。
+- 完善 Bot 资料、结构化角色偏好、独立模型设置与分层记忆;修复冷恢复后模型设置失效、记忆提炼空结果和记忆检索问题,并显示保存结果。
+- 完善多台电脑及虚拟环境管理,支持桌面端切换客户端与服务器模式、远程登录、逐台授权、电脑改名和重新授权。
+- 电脑接管页面支持切换预览环境,减少轮询造成的闪跳。完善共享桌面的执行调度、多环境操作、文件与命令授权及跨设备文件复制。
+- 修复 Bot 会话同步、普通聊天排队与停止状态、节点失联时的任务退出,以及工具分段完成后输入动画提前消失或持续残留的问题。
+- 消息正文、图片和文件按原顺序独立展示;统一文件卡片识别及传输上限,提供聊天气泡预设与自定义外观。
+- 统一任务进度、审批、提问与错误提示,默认折叠交付进展,默认隐藏思考过程和工具细节,减少重复技术报错。
+- 修复文件路径权限边界,并在归档或删除 Bot 时清理相关电脑共享关系。
+
+## 升级说明
+
+- 升级前备份完整 `.yaoyao` 数据目录。保留旧数据目录迁移兼容逻辑,不改变现有数据归属。
+- 建议同步更新桌面端与配套执行节点,并检查工具桥实际加载状态及电脑授权状态。
+- 本次不构建、不上传 APK;旧版本标签和附件继续保留。
+- 主项目采用 Apache-2.0,第三方组件保留各自许可与署名。
+
+## 下载
+
+- `Yaoyao-0.4.61-arm64.dmg`:macOS Apple Silicon,Apple Development 开发签名,未公证。
+- `Yaoyao-0.4.61-source.tar.gz`:Web/桌面源码及部署配置。
+- `SHA256SUMS.txt`:上述两个附件的 SHA-256 校验值。
+
+## Docker Hub
+
+| 镜像 | 架构 |
+| --- | --- |
+| `samienluo/yaoyao:v0.4.61-amd` | `linux/amd64` |
+| `samienluo/yaoyao:v0.4.61` | `linux/amd64`、`linux/arm64` |
+| `samienluo/yaoyao:latest` | 验证后更新为同一通用镜像 |
+
+```sh
+docker pull samienluo/yaoyao:v0.4.61
+docker compose --env-file docker.env pull web
+docker compose --env-file docker.env up -d --no-build web
+```
+
+Compose 中设置 `HERMES_YAOYAO_IMAGE=samienluo/yaoyao:v0.4.61`。镜像发布到 Docker Hub,GitHub 仅提供安装包、源码及校验文件。
+
+附件摘要、镜像摘要与实际验证结果见 [GitHub 发布页](https://github.com/Lsamien/yaoyao/releases/tag/v0.4.61)。

BIN
docs/system-notices/approved-design.png


+ 234 - 0
docs/system-notices/checks.json

@@ -0,0 +1,234 @@
+[
+  {
+    "name": "desktop",
+    "alignment": [
+      {
+        "title": "已分派子任务",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "任务已有新结果",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "响应超时",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "回复暂时中断",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "子任务已完成",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "上下文已压缩",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "后台子任务已完成",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      }
+    ],
+    "keyboardDisclosure": true,
+    "diagnostic": true,
+    "partialReply": true,
+    "errors": []
+  },
+  {
+    "name": "mobile",
+    "alignment": [
+      {
+        "title": "已分派子任务",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "任务已有新结果",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "响应超时",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "回复暂时中断",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "子任务已完成",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "上下文已压缩",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "后台子任务已完成",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      }
+    ],
+    "keyboardDisclosure": true,
+    "diagnostic": true,
+    "partialReply": true,
+    "errors": []
+  },
+  {
+    "name": "mobile-dark",
+    "alignment": [
+      {
+        "title": "已分派子任务",
+        "offset": 0,
+        "color": "rgb(160, 160, 154)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "任务已有新结果",
+        "offset": 0,
+        "color": "rgb(160, 160, 154)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "响应超时",
+        "offset": 0,
+        "color": "rgb(160, 160, 154)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "回复暂时中断",
+        "offset": 0,
+        "color": "rgb(160, 160, 154)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "子任务已完成",
+        "offset": 0,
+        "color": "rgb(160, 160, 154)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "上下文已压缩",
+        "offset": 0,
+        "color": "rgb(160, 160, 154)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "后台子任务已完成",
+        "offset": 0,
+        "color": "rgb(160, 160, 154)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      }
+    ],
+    "keyboardDisclosure": true,
+    "diagnostic": true,
+    "partialReply": true,
+    "errors": []
+  },
+  {
+    "name": "ordinary",
+    "alignment": [
+      {
+        "title": "已分派子任务",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "任务已有新结果",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "响应超时",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "回复暂时中断",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "子任务已完成",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "上下文已压缩",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      },
+      {
+        "title": "后台子任务已完成",
+        "offset": 0,
+        "color": "rgb(111, 111, 105)",
+        "background": "rgba(0, 0, 0, 0)",
+        "height": 44
+      }
+    ],
+    "keyboardDisclosure": true,
+    "diagnostic": true,
+    "partialReply": true,
+    "errors": []
+  }
+]

BIN
docs/system-notices/comparison.png


BIN
docs/system-notices/desktop-expanded.png


BIN
docs/system-notices/desktop.png


BIN
docs/system-notices/mobile-dark-expanded.png


BIN
docs/system-notices/mobile-dark.png


Một số tệp đã không được hiển thị bởi vì quá nhiều tập tin thay đổi trong này khác